Machine learning applied to financial transaction records can predict how likely a small business is to repay a loan. For this purpose we compared a traditional scorecard credit risk model against various machine learning models and found that XGBoost with monotonic constraints outperformed scorecard model by 7% in K-S statistic. To deploy such a machine learning model in production for loan application risk scoring it must comply with lending industry regulations that require lenders to provide understandable and specific reasons for credit decisions. Thus we also developed a loan decision explanation technique based on the ideas of WoE and SHAP. Our research was carried out using a historical dataset of tens of thousands of loans and millions of associated financial transactions. The credit risk scoring model based on XGBoost with monotonic constraints and SHAP explanations described in this paper have been deployed by QuickBooks Capital to assess incoming loan applications since July 2019.

A major part of financial accounting involves tracking and organizing business transactions over and over each month and hence automation of this task is of significant value to the users of accounting software. In this paper we present a large-scale recommendation system that successfully recommends company specific categories for several million small businesses in US, UK, Australia, Canada, India and France and handles billions of financial transactions each year. Our system uses machine learning to combine fragments of information from millions of users in a manner that allows us to accurately recommend user-specific Chart of Accounts categories. Accounts are handled even if named using abbreviations or in a foreign language. Transactions are handled even if a given user has never categorized a transaction like that before. The development of such a system and testing it at scale over billions of transactions is a first in the financial industry.

We compare five industrial software architecture design methods and we extract from their commonalities a general software architecture design approach. Using this general approach, we compare across the five methods the artifacts and activities they use or recommend, and we pinpoint similarities and differences. Once we get beyond the great variance in terminology and description, we find that the 5 approaches have a lot in common and match more or less the "ideal" pattern we introduced.

Mobile phones serve as platforms for a variety of mobile applications including text and picture messaging as well as personal information management, including data synchronization with remote servers and desktop computers. They also host a range of communication-centered applications most of which have real-time constraints. To improve the performance of the mobile phone software, we focused on the runtime software architecture - a partition of all software functions into concurrent units and a scheduling policy that delivers the best possible service to the user with available resources. The units of concurrency in most products are operating system tasks. Thus, partition of software into tasks and allocation of functionality to tasks in the form of objects or functions are the most important decisions in the design of the runtime architecture (Ran et al., 2003). In this paper, we focus on the scheduling policy and its parameters. Some problems encountered in our project can be solved by a different task design. However, task redesign often is not feasible in industrial setting since it takes a long time and has high costs.

Making sense of runtime architecture for mobile phone software.

No abstract available.

No abstract available.

Test suites are designed to validate the operation of a system against requirements. One important aspect of a test suite design is to ensure that system operation logic is tested completely. This is a difficult task. Code coverage tools support test suite designers by providing the information about which parts of source code are covered during system execution. Unfortunately, code coverage tools produce only source code coverage information. For a test engineer it is often hard to understand what the noncovered parts of the source code do and how they relate to requirements. We propose a generic approach that provides design coverage of the executed software, simplifying the development of new test suites. We demonstrate our approach on common design abstractions such as statecharts and structure diagrams. We implement the design coverage using tracing and a trace analysis framework. Using design coverage, test suites could be created faster by focussing on untested design elements.

Architecture of software is a collection of design decisions that are expensive to change. How to identify which design decisions are expensive to change? What are architecture views and which views are needed to adequately describe the architecture of a specific system? How to create and manage software architecture for a product family? This tutorial offers answers to these and other questions that arise in the context of complex software development. We introduce a system of concepts useful in order to understand, design, and evaluate architecture of software intensive systems and system families. Our approach utilizes different software structures in order to control important system qualities related to its development, performance, and evolution. We draw our experience primarily from software embedded in voice and data communication systems. However the same principles can be applied to software architecture in other domains. This tutorial should be useful to engineers and technical managers involved in construction or evaluation of complex software.

Another concept of Third Eye is the tracing state. Tracing state is a set of event types generated in that state, other event types are filtered out and not reported. The system is always in a specific tracing state. Tracing states correspond to specifications. A program specification describes a set of constraints on events. The event types used in a specification have to be monitored to validate a trace against this specification. All event types contained in a specification and monitored for this specification form a tracing state. Tracing states also control the overhead of tracing on the executing system.The Third Eye framework includes modules for event type definition, event generation and reporting, tracing state definition and management, trace logging, query and browsing interfaces. Modules of event type definition, event reporting facility and tracing state controler are integrated with the software of the system under trace (SUT). The rest of the modules are independent from the SUT and can be deployed on a different execution platform to minimize the influence on system performance. Trace delivery for logging and analysis uses alternative interfaces to accommodate devices with different data storage and connectivity capabilities. We have implemented Third Eye framework prototype currently used by the Third Eye project team in collaboration with product development teams in Nokia's business units. We used Third Eye to test a number of software systems: the memory subsystem of one of Nokia's handsets, Apache Web Server, and WAP (Wireless Application Protocol) client. WAP is an industrial standard for applications and services that operate over wireless communication networks. We validated message sequences in this protocol by adding events in the functions that correspond to the protocol primitives and then checking whether the event sequence corresponds to the protocol message sequence. Events are mapped to Prolog facts and constraints are expressed as Prolog rules. Third Eye can be used for debugging, monitoring, specification validation, and performance measurements. These scenarios use typed events—a concept simple and yet expressive enough to be shared by product designers and developers. The Third Eye has an open architecture allowing easy replacement of third-party tools, including databases, analysis and validation tools. Third Eye is a practical framework for specification-based analysis and adaptive execution tracing of software systems.

The main problem in developing software product families is how to share effort and reuse parts of design and implementation while providing variation of features and capabilities in the products.We discuss the mechanisms that are commonly used to achieve reuse and sharing in product families, and the kind of variance each is best suited for.Our analysis motivates a need for a new mechanism to deal with ad hoc variation of features found in different members of a family.We argue that higher level abstraction and parametrization techniques are not well suited for this task.We propose an alternative approach that enables sufficiently detailed designs for every variant and at the same time achieves a level of design reuse without making designs unnecessarily complex or implementations inefficient.