Verification and validation in software product line engineering

Verification and Validation (V&V) is currently performed during application development for many systems, especially safety-critical and mission-critical systems. However, the V&V process has been limited to single system development. This dissertation describes the extension of V&V from an individual application system to a product line of systems that are developed within an architecture-based software engineering environment.;In traditional V&V, the system provides the context under which the software will be evaluated, and V&V activities occur during all phases of the system development lifecycle. The transition to a product line approach to development removes the individual system as the context for evaluation, and introduces activities that are not directly related to a specific system. This dissertation presents an approach to V&V of software product lines that uses the domain model and the domain architecture as the context for evaluation, and enables V&V to be performed throughout the modified lifecycle introduced by domain engineering.;This dissertation presents three advances that assist in the adaptation of V&V from single application systems to a product line of systems. The first is a framework for performing V&V that includes the activities of traditional application-level V&V, and extends these activities into domain engineering and into the transition between domain engineering and application engineering. The second is a detailed method to extend the crucial V&V activity of criticality analysis from single system development to a product line of systems. The third advance is an approach to enable formal reasoning, which is needed for high assurance systems, on systems that are based on commercial-off-the-shelf (COTS) products

Proceedings of the Resolve Workshop 2006

The aim of the RESOLVE Workshop 2006 was to bring together researchers and educators interested in: Refining formal approaches to software engineering, especially component-based systems, and introducing them into the classroom. The workshop served as a forum for participants to present and discuss recent advances, trends, and concerns in these areas, as well as formulate a common understanding of emerging research issues and possible solution paths

Scaling Up Automated Verification: A Case Study and a Formalization IDE for Building High Integrity Software

Component-based software verification is a difficult challenge because developers must specify components formally and annotate implementations with suitable assertions that are amenable to automation. This research investigates the intrinsic complexity in this challenge using a component-based case study. Simultaneously, this work also seeks to minimize the extrinsic complexities of this challenge through the development and usage of a formalization integrated development environment (F-IDE) built for specifying, developing, and using verified reusable software components. The first contribution is an F-IDE built to support formal specification and automated verification of object-based software for the integrated specification and programming language RESOLVE. The F-IDE is novel, as it integrates a verifying compiler with a user-friendly interface that provides a number of amenities including responsive editing for model-based mathematical contracts and code, assistance for design by contract, verification, responsive error handling, and generation of property-preserving Java code that can be run within the F-IDE. The second contribution is a case study built using the F-IDE that involves an interplay of multiple artifacts encompassing mathematical units, component interfaces, and realizations. The object-based interfaces involved are specified in terms of new mathematical models and non-trivial theories designed to encapsulate data structures and algorithms. The components are designed to be amenable to modular verification and analysis

Foundations of object-based specification design

To enhance applicability and encourage its use, a component or a component-based system must have a well-designed set of interface features as well as a proper explanation of these features. The dual problem of designing a suitable set of interface features in addition to properly explaining its behavior is termed the specification design problem. This dissertation identifies observability, controllability, and a performance-motivated pragmatic criterion as essential properties of desirable formal specifications for reusable object-based software components. The pragmatic criterion guides the design of component interfaces and component libraries to a suitable set of features so that they are widely applicable, both in terms of functionality and performance, yet minimal in size, whereas observability and controllability considerations lead to most suitable formal explanations of the interfaces.;This dissertation formally defines the principles of observability and controllability for object-based software specifications, including those with relational behavior. These principles, in addition to the minimality and performance considerations embodied in the pragmatic criterion, lead to the unique collection of concepts in the RESOLVE component specification library. These principles form a basis for evaluation of existing object-based software specifications, and also lead to designs of new specifications that are among the most desirable in terms of understandability and utility

Uni-Prover: A Universal Automated Prover for Specificationally Rich Languages

Formal software verification systems must be designed to adapt to growth in the scope and complexity of software, driven by expanding capabilities of computer hardware and domain of potential usage. They must provide specification languages that are flexible and rich enough to allow software developers to write precise and comprehensible specifications for a full spectrum of object-based software components. Rich specification languages allow for arbitrary extensions to the library of mathematical theories, and critically, verification of programs with such specifications require a universal automated prover. Most existing verification systems either incorporate specification languages limited to first-order logic, which lacks the richness necessary to write adequate specifications, or provide automated provers covering only a fixed collection of mathematical theories, which lack the compass to specify and verify sophisticated object-based software. This dissertation presents an overall design of Uni-Prover, a universal automated prover for atomic sequents to verify software specified with rich languages. Such a prover is a necessary element of any adequate automated verification system of the future. The design contains components to accommodate changes or upgrades that may happen. The congruence class registry at the center of Uni-Prover handles all core manipulations necessary to verify programs, and it includes a multi-level organization for effective searching of the registry. The full functional behavior of the registry component is described mathematically, and a prototype implementation is given. Additionally, the contiguous instantiation strategy, a strategy that requires neither user-supplied heuristics nor triggers when instantiating universally quantified theorems in any theory, is detailed to minimize verification steps by avoiding the proliferation of sequents in the instantiation process

Proceedings of the RESOLVE Workshop 2002

Proceedings of the RESOLVE Workshop 200