Research

Overview

Dr. Richardson's primary research is directed toward the integration of formal specification methods and analysis with software testing. Her current work is largely focussed at the architecture and component level. A current project supported by Conexant and UC MICRO is studying Architecture and Component Analysis based on Software Dependence. In this project, we are developing a two-tiered dependence analysis method that independently studies a deployable component and its inclusion in a software structure represented by an architectural description language (ADL). In the Quality by Design project, sponsored by the NSF Information Technology Research Program, Richardson and Redmiles are combining for the first time (1) formal architecture and component design models, (2) analysis and testing techniques based on these formalisms, together with (3) cognitive-based, design environments for critiquing software design. The focus of the project is to help software developers design quality into their systems, rather than considering quality as an afterthought.

Professor Richardson has active projects with several Ph.D. students in ICS. Chang Liu is working on Redundant Arrays of Independent Components, a project working toward building reliable software applications using redundant component arrays with just-in-time software component testing and component state recovery techniques. Marlon Vieira is working on Analyzing Dependencies in Large Component-Based Systems, developing a technique to analyze dependencies in large component-based systems based on partial-order multi-sets. Marcio Dias is working on Architecture-Based Debugging technology.

Richardson is working with Italian collaborators Henry Muccini, who is currently visiting UC Irvine, and Paola Inverardi, both of the Univesity of L'Aquila, on a project called Software Architecture for Testing, Coordination and Views Model Checking. Basically, this project is trying to bring together the pieces of work focussed on using software architecture in testing and coordination.

Richardson inspired much of the work in" specification-based testing", beginning with her early development of the Partition Analysis Method, which proposed incorporating information from both specification and implementation in an integrated application of verification and testing techniques.  Along with Thompson and Clarke, Richardson developed the Relay model for the formal definition of test data selection criteria and evaluation of their fault detection capabilities. As a principal investigator on the Arcadia project, Richardson collaborated on developing analysis and testing capabilities within a process-centered environment to support integration of and experimentation with a variety of techniques.  She developed ProDAG, a program dependence analysis toolset that provides automated support for software understanding, debugging, test adequacy criteria, and maintenance, and TAOS, a testing environment that supports management of test assets, monitored test execution, automatic test result checking, and test coverage measurement. More recently, she developed the EASOF model of specification-based testing with support for execution-time checking of test results against formal specifications of required behavior.

As a principal investigator on the ARPA-funded EDCS Perpetual Testing project, Richardson collaborated with Clarke, Osterweil and Young on capabilities to support analysis and testing throughout the software lifecycle, from early requirements analysis through operational use.She and Wolf were principal investigators on the NSF&ARPA-funded Formal Architecture-Based Approach to Software Testing project, which first extended specification-based testing techniques to be applicable at the level of software architecture. She and Dillon collaborated on developing an Integrated Toolset for Specifying and Testing Critical Software-intensive Systems in a UC MICRO and Hughes/Raytheon sponsored project.

Current/Recent Projects

Architecture and Component Analysis based on Software Dependence

As computing environments become more distributed and modular and software development methodologies become more sophisticated, increasingly complex applications are possible in which concurrent units of computation communicate and share information. Such interaction creates dependence relationships between computational units (i.e., components). It is difficult, if not impossible, to create robust and reliable systems when developers do not understand dependencies between components. Yet in the distributed, inter-organizational development processes in practice today, it is difficult for developers to be fully aware of all potential component relationships. Different developers create components, often working in different groups, and potentially with different methodologies. Some components may even be outsourced to a service provider, in which case little or no information is available. Thus, it is very common to find cases in which a component fails because a dependence relationship is not properly understood or resolved. Problems also occur during testing, debugging, maintenance, and evolution when a component is changed and other components are affected. Analysis technologies to support these activities must catch up with the consequences of sophisticated development methodologies and complex applications. This project in part addresses this need.

We propose a two-tiered dependence analysis method that independently studies a deployable component and its inclusion in a software structure represented by an architectural description language (ADL). Our research takes a view of dependence relationships focused on the concerns of component interactions and their composition. Both the structural and the behavioral relationships among components are critical to the analysis method. The structural dependencies allow one to locate source specifications that contribute to the description of some interaction. The behavioral dependencies allow one to relate component interactions to other interactions. Both structural and behavioral dependencies are important to capture and understand when analyzing a system built with components.

Major facets of this research project include: (a) construction of a theoretical model of component dependencies, defining what it means for one component to depend on another and also determining the sources of those dependencies; (b) development of a method for identifying precise sets of dependencies; (c) implementation of a prototype tool supporting the use of our approach; and (d) investigation of various applications of dependence information, such as software testing and debugging, maintenance and evolution, and dynamic architectural reconfiguration. The prototype and applications will be built atop the ARGUS-I “All-Seeing” Architecture Analysis Toolset, which analyzes architectural elements (e.g., components) as well as topology (i.e., the connections). ARGUS-I provides a complimentary set of analysis and testing capabilities from type checking, dependence analysis, model checking and simulation (during specification) to debugging, monitoring and conformance verification.

Quality by Design

Quality has always been a concern with respect to software. Yet now, with such great reliance on software in every aspect of our lives (business and commerce, environment, education, health care, national defense, and even entertainment), there is greater need than ever to address quality in software development. By high quality software, we mean software whose specifications meet customers’ requirements and whose implementations meet specifications, all in a timely manner. Qualities of concern, therefore, range from reliability, predictability, and robustness to modifiability and adaptability.

The focus of this project is to help software developers design quality into their systems, which is far more cost-effective than relying solely on post-implementation quality evaluation and corrective maintenance. In particular, this research project encompasses a plan for combining for the first time (1) formal architecture and component design models, (2) analysis and testing techniques based on these formalisms, together with (3) cognitive-based, design environments for critiquing software design. The research explores innovative user interface approaches to delivering critical design-related quality assessment information to software developers as they interactively develop designs. The information to be delivered is based on design heuristics, results of formal analysis and testing, and usage data and feedback from end users of prototype software products. The delivery of information is performed in a manner consistent with research in human cognition. Finally, to ensure that this research has the potential to impact real work, the formal architecture and component design models leverage and extend industry standards.

Redundant Arrays of Independent Components

The recent advent of Internet-based infrastructure for distributed software components will enable software programmers to publish software components on the Internet with relatively trivial effects. This may soon give application developers access to an abundance of independent and inexpensive software components. But before the Internet-scale component-based approach becomes a mainstream software development method, several problems must be addressed. First, remote software components on Internet are inherently unreliable. Not only do network conditions vary from time to time, but also remote components are subject to changes or upgrades without notice. There needs to be a way to isolate applications from uncertainties of remote components. Second, the cost of component integration has to go down before application developers can take advantage of existing components. Third, component developers must have incentives to publish their work.

We propose to use Redundant Array of Independent Components (RAIC) to address these problems, particularly the first one. The primary goal of RAIC is to use to enhance reliability or achieve better performance through redundancy while minimizing the complexity of component integration. Using RAIC, applications only need to interface with the RAIC controller, which behaves like a single component. Thus, both application programmers and application code are shielded from the complexity of component integration.

Analyzing Dependencies in Large Component-Based Systems

The current trend in software engineering is to develop large systems using a component-based approach. Analyses of individual components and their integration into a system play a key role in the reliability and robustness of component-based systems. However, some difficult technical problems remain to be explored and resolved to allow the effective use of analysis techniques during development with components. Among those problems is the need to identify potential dependencies among the system’s components. That is, the potential for one component to affect or be affected by other component(s) that compose the system. In this paper, we approach issues related to component dependencies and present a technique to analyze dependencies in large component-based systems. Our method is based on the denotational semantics of partial-order multi-sets (pomsets, for short), a well-established model in the class of linear-time non-interleaving models. The use of pomsets provides a scalable way for modeling and analyzing inter-component dependencies.

Architecture-Based Debugging

Software monitoring is a well-known technique for observing and understanding the dynamic behavior of programs when executed. Multiples are the purposes for monitoring software applications, such as: testing; debugging; performance evaluation and enhancement; security; dependability (reliability); correctness checking; etc. Monitoring should not be seen as a final technique: it is an intermediate technique that enhances and complements other known techniques, including static techniques.

Although every software monitoring system have the same theoretical basis, there is no single one that can be applied to all those purposes. When a monitoring system can be (semi- or) automatically installed, it is often based on low-level abstraction of program events (e.g., process and I/O events). On the other hand, when a monitoring system deals with higher level events (such as a bank account transaction or a book order), its installation usually requires too much human effort (for program instrumentation and source code management).

We have been working on software monitoring at the application's architectural level, so that the developer can have the adequate abstraction of details, i.e., at the application and component domain levels. One benefit is to reduce the effort required to install software monitoring. Another is to be able to analyze the evolution of dynamic systems at its architectural level. We are also working on ways to allow the monitoring system to be effortless used for multiples purposes, according to the developer's needs.

Software Architecture for Testing, Coordination and Views Model Checking

During the last ten years, Software Architecture (SA) has become an autonomous discipline, recognized by researchers in industry and academia as the most promising approach to tackle the problems of scaling up in software engineering, reducing development times and costs.

Putting SA into practice, software architects have learned some lessons: 1) SA production and management is, in general, an expensive task – thus, architectural choices must be extensively analyzed and validated with respect to behavioral and quantitative properties; 2) SA descriptions do not live in isolation, but must be integrated into a software development process and used to drive/constrain subsequent steps in the life-cycle; 3) Many software aspects and properties must be reflected in the SA description (e.g., coordination, mobility, security).

Some work has been proposed in the past to analyze SA and some development processes encompassing SA have been used in practice. Although we argue that the proposed approaches do not satisfy all three "requirements" identified above.

This project is exploring ways to suitably describe and analyze SAs, encompassing that within the development process. A SA-based testing approach and a views model consistency checking technique are integrated in the same development process in which coordination aspects are identified, modeled, and analyzed.

Perpetual Testing

The Perpetual Testing project is developing technologies to support seamless, perpetual analysis and testing of software through deployment and evolution. Whereas the current dominant paradigm treats testing as a phase that succeeds development and precedes delivery, we are building the foundation for treating analysis and testing as on-going activities to improve quality assurance without pause through several generations of product, in the development environment as well as the deployed environment. Software in the deployed environment is monitored not only to check conformance to required properties but also to validate and refine the models and assumptions on which quality assurance activities in the development environment depend. The degree of monitoring and transmission of information to the development environment differs depending on performance and security requirements of the end-user and is always be under user control.

Perpetual testing is necessarily incremental. Analysis and testing processes are carried out in response to changes in software artifacts or associated information or in anticipation of change. Improvements to existing technologies focus largely on scalability and incrementality for large evolving systems. Analysis and testing is aimed at attaining and maintaining adequate adherence of all software artifacts to relations captured by a rich web of hypercode links, including dependence relations among software components and among properties and analysis techniques.

For more information, go to the Perpetual Testing project page.

Formal Architecture-Based Approach to Software Testing

There are five major contributions to software architecture and software testing technology arising from this research. First, a set of architecture-based integration test criteria will be defined to provide requirements for testing architectural aspects of a system; methods will also be developed for applying these criteria to architectural styles and domain-specific architectures. Second, methods will be developed for testing an implementation in terms of its conformance to a specified architecture via architecture conformance oracles. Third, architecture-level slicing techniques will be defined for localizing architectural defects and minimizing regression testing. Fourth, methods will be developed for using feature tests to discover the architecture of a system from its implementation. Finally, various approaches to formal architecture specification will be evaluated with respect to their suitability to testing technologies.

For more information, go to the Formal Approach to Architecture-Based Software Testing project page.

Integrated Toolset for Specifying and Testing Critical Software-Intensive Systems

Critical systems have behavioral requirements that must be satisfied and thus require sophisticated testing to enable high assurance in system dependability.  Furthermore, competent testing necessitates a thorough understanding of required behavior, which is achievable only when requirements are formally specified.  Analysis and testing should be done throughout the development process, beginning with analysis of behavioral requirements and continuing through design and coding.  In addition, critical system behaviors should be continuously tested; their run-time behavior should be checked not only during development but also during operation.  Moreover, complex systems are evolving systems -- that is, they are continually modified to meet new needs throughout development, maintenance, reuse, and reengineering -- and require testing throughout evolution.  In this MICRO project, we have been developing support for specifying, testing and debugging of critical software-intensive systems that will lead to dramatic improvements in software dependability and reduced costs within the software industry.

This MICRO project is developing an integrated toolset to support the production of highly dependable critical systems by combining and refining several advanced technologies including:  GIL, a language with tools for intuitively specifying and reasoning about temporal properties of complex systems;  TAOS, a testing toolkit and environment that supports test artifact production, automated test execution, formal behavior verification, and test adequacy measurement;  ProDAG, a tool that analyzes the dependences between software components to identify components whose behavior may be affected by others.  The proposed toolset will provide capabilities for formal specification of critical behavioral requirements, formal reasoning about specified requirements, continuous testing to provide assurance of behavioral correctness and/or detect failures, assisted debugging to reason about the cause of a failure, and cost-effective testing of evolving software systems.  The long-term goal of this project is to provide a discipline for effective demonstration of the dependability of complex software-intensive systems.  The benefits of this research are broad based and will be useful to all systems/software engineering organizations.

For more information, go to the Integrated Support for Specifying and Testing Critical Software-Intensive Systems project page.

Interactions

Faculty

• Lori Clarke, University of Massachusetts, Amherst
• Lee Osterweil, University of Massachusetts, Amherst
• Richard N. Taylor, University of California, Irvine
• David Redmiles, University of California, Irvine
• Laura K. Dillon, Michigan State University
• Alex L. Wolf, University of Colorado, Boulder
• William G. Griswold, University of California, San Diego
• Paola Inverardi, University of L'Aquila, Italy
• Henry Muccini, University of L'Aquila, Italy

Graduate Students

Affiliated Graduate Students

• Marcio Dias
• Chang Liu
• Michele Rousseau
• Marlon Vieira

Recent Ph. D. Graduates

• Margaret C. Thompson, February 1991, getting an MD from University of Massachusetts Medical Center Worcester
• T. Owen O'Malley, December 1996, now at Sun Microsystems Labs
• Nancy Eickelmann, June 1997, now at Motorola Research Laboratory
• Hadar Ziv, June 1997, now at eBuilt, Inc.
• Juei Chang, March 1999, now at Yodlee, Inc.
• Arthur Reyes, August 1999, now at University of Texas at Arlington
• Clark Turner, August 1999, now at Cal Poly San Luis Obispo

Agencies

• NSF CCR SEL Program: Software Engineering and Languages
• DARPA EDCS Program: Evolutionary Design of Complex Systems
• UC MICRO Program: Microelectronics Innovation and Computer Research Opportunities

Industrial Organizations

• Conexant Systems, Inc.
• Sun Microsystems
• MCC: Microelectronics and Computer Technology Corporation