Stephen P. Masticola

Lattice frameworks for multisource and bidirectional data flow problems

Multisource data flow problems involve information which may enter nodes independently through different classes of edges. In some cases, dissimilar meet operations appear to be used for different types of nodes. These problems include bidirectional and flow-sensitive problems as well as many static analyses of concurrent programs with synchronization. K-tuple frameworks, a type of standard data flow framework, provide a natural encoding for multisource problems using a single meet operator. Previously, the solution of these problems has been described as the fixed point of a set of data flow equations. Using our k-tuple representation, we can access the general results of standard data flow frameworks concerning convergence time and solution precision for these problems. We demonstrate this for the bidirectional component of partial redundancy suppression and two problems on the program summary graph. An interesting subclass of k-tuple frameworks, the join-of-meets frameworks, is useful for reachability problems, especially those stemming from analyses of explicitly parallel programs. We give results on function space properties for join-of-meets frameworks that indicate precise solutions for most of them will be difficult to obtain.

A Simple Estimate of the Cost of Software Project Failures and the Breakeven Effectiveness of Project Risk Management

Based on easily obtained data, a rough (but simple) estimate of the cost to an enterprise of software project failures can be formed. Using similar analysis, it is possible to estimate the effectiveness that a software quality improvement project will need to have upon the project failure rate in order to break even economically. This provides an informal calculation that can be used to cost-justify either a more complete investigation or risk management.

Schedulability-analyzable exception handling for fault-tolerant real-time languages

Exceptions add a significant element of robustness and fault-tolerance to an application. In real-time systems, however, we require not only semantic correctness, robustness, and fault-tolerance, but also timely behavior. For restricted languages, schedulability analysis can be made efficient through use of polynomial-time analyses and transformations. In this paper, we show how a reasonable level of exception handling can be added to such a language. Specifically, we present an exception mechanism which reasonably provides for (1) guaranteed schedulability, (2) fine granularity of exception handling, (3) possibility of non-termination of the process that raises the exception, (4) reuse of exception handlers within the program, (5) information hiding in exception handlers, (6) exceptions as first-class objects, (7) casting or binding of exceptions, and (8) deadline modification. Furthermore, the mechanism allows for easy specification of multi-mode operation, and permits program component assignment using expected behavior while enabling schedulability analysis of worst-case (often exceptional) behavior. While adding features to exception handler semantics can create new analysis problems while solving expressivity problems, we show that the exception handling features described above are desirable, that the complexity of static schedulability analysis in the presence of these features is manageable, and that existing language provides all these desirable features.

Model-Based scalability estimation in inception-phase software architecture

Scalability is one of the crucial nonfunctional requirements that must be evaluated in the Inception Phase of the Rational Unified Process [9]. This is the phase in which the least information is generally available to form a principled evaluation. We demonstrate how an estimate of user scalability can be formed using sequence diagrams of the common user scenarios, together with experimentation (ranging from simple timing measurements to more complex architectural prototypes), published study data, and performance data from baseline systems. Despite being quite inexpensive, the techniques used by our team enabled us to identify and guide corrective actions for major bottlenecks before they became serious design flaws in the Elaboration and Construction phases of the Unified Process. The same techniques also allowed us to quickly evaluate the effects of high-level architecture and technology alternatives on user scalability and response time.

Experience With Developing a High-Productivity Test Framework for Scalable Embedded and Mechatronic Systems

We describe the software core of a generic system test framework, named TF, for engineering verification of embedded and mechatronic systems. TF originated as an automated system test framework for the Siemens FireFinder XLS fire-safety system, but can be easily customized to place other systems under test. As a scalable and safety-critical system under rigorous certification constraints, XLS placed some very stringent requirements on the test harness. We performed a thorough evaluation of the available options for test executives, selecting the best one for our purposes. We then built TF on that test executive. TF enables high levels of productivity for both test developers and framework maintainers. TF also allows simulators to be substituted for physical hardware, without modifying the test scripts or underlying infrastructure. This feature is vitally important in scalability testing.Copyright

Challenges in practice: 4th international workshop on the automation of software test report

The Fourth International Workshop on Automation of Software Test (AST 2008) ICSE 2009 expanded previous programs to two days, supported a special theme of Testing Web Services, added a Case Studies from Business and Industry session, and included a charette-style work session. At the workshop, 15 regular papers and 7 short case-study papers were presented in 7 sessions at the workshop. This report summarizes the organization of the workshop as well as the sessions and papers presented, the results of the charette session, attendee feedback, and lessons learned. (This is an updated and expanded version of the workshop summary that was included in the ICSE 2009 proceedings.

Vision: testing of mechatronics software using agile simulation

Mechatronics is the practice of creating systems that synergize electrical, mechanical, and software technology. With few exceptions, testing software that is embedded in mechatronics systems has historically been done only with the hardware in the loop (HIL). There are many disadvantages to HIL testing, including cost, schedule delays, and resource bottlenecks. Ironically, cost and schedule delays are also often seen by technical managers as impediments to simulating the mechatronics hardware. We present a vision for agile simulation, with the intent to lower the cost and time barriers of simulating mechatronics hardware to test software. Some key ideas include: focus on validating the software alone, rather than the entire system; doing the minimum amount of dynamic modeling needed to test the software; work even with legacy systems that might not have been designed with testability in mind; leverage existing tools wherever possible; support stubbing out the hardware using agile techniques such as refactoring and test-driven development.

Expanding, theory, and practice: Report on the 4 th International Workshop on the Automation of Software Test

The Fourth International Workshop on Automation of Software Test (AST 2009) at the 31st International Conference on Software Engineering (ICSE 2009) expands to two days, supports a special theme of Testing Web Services, adds a Case Studies from Business and Industry session, and includes a charette-style work session. 14 regular papers and 7 short case-study papers will be presented. This report summarizes the organization of the workshop as well as the sessions and papers to be presented.

Lightweight Risk Mitigation for Software Development Projects Using Repository Mining

Many software projects fail to deliver their needed results on-time and on-budget. There are a variety of reasons why this may occur. For some of these reasons (notably deterioration of the codebase), corrective action is often difficult to cost-justify or to implement efficiently in practice. To address this, an approach of lightweight risk mitigation is proposed: mine risk data from configuration management and defect tracking systems, integrate this data with project-cost data in a flexible dashboard, and facilitate strategic refactoring with semi-custom transforms where necessary. This prescriptive information would simultaneously help the project manager to cost-justify repair efforts and lowers the cost of finding and fixing hot spots.