Formal Methods In Software Development Research Articles

Мониторинг и тестирование на основе многоуровневых спецификаций программ

Research on formal methods of software development and verification focuses on building specifications using incremental and iterative development methodologies. The presence of several levels of specifications simplifies proving of properties, since it is possible to reuse the proofs that were performed for more abstract layers of the model. It is desirable to use the same models that were used for formal verification also in testing of real systems for compliance with the requirements set by these models. In practice, large software systems are described by multi-level models. There was no experience of using such models as the basis for testing and monitoring. The paper discusses various methods for developing multi-level models, new opportunities that can be obtained through a combination of functional specifications and implementation-level refinements, limitations that must be considered during testing and monitoring of real systems for compliance with multi-level models.

Formal methods and software development

I am exploring the use of Formal Methods in Software Development. The need for high-integrity and safety-critical software is increasing, and formal methods hold out the promise of progress in that...

A fresh recipe for designers: HCI approach to explore the nexus between design techniques and formal methods in software development

Emerging companies involved in design and implementation of innovative products demand multidisciplinary teams to be competitive in the market. This need mainly exposes designers to extend their knowledge not only in User Interface elements of the design process but also in software methodologies to cover the lack of resources and expertise in start-ups. It raises the question of how designers can line up HCI techniques with best practices in software development while preserving usability and easy-to-use principles. To explore this gap, this paper proposes an approach which combines existing technology and methods by studying the nexus between HCI prototyping and software engineering. The approach is applied into a case study in the design of a virtual shop harmonizing the use of storyboards and the spiral. A comprehensive analysis is performed by using a Technology acceptance model (TAM) regarding with two variables: usability and easy-to-use. The present finding underlines the positive integration of HCI techniques and formal methods without compromising user satisfaction with a potential benefit for small companies in a formation stage.

Transformation of UML Behavioral Diagrams to Support Software Model Checking

Unified Modeling Language (UML) is currently accepted as the standard for modeling (object-oriented) software, and its use is increasing in the aerospace industry. Verification and Validation of complex software developed according to UML is not trivial due to complexity of the software itself, and the several different UML models/diagrams that can be used to model behavior and structure of the software. This paper presents an approach to transform up to three different UML behavioral diagrams (sequence, behavioral state machines, and activity) into a single Transition System to support Model Checking of software developed in accordance with UML. In our approach, properties are formalized based on use case descriptions. The transformation is done for the NuSMV model checker, but we see the possibility in using other model checkers, such as SPIN. The main contribution of our work is the transformation of a non-formal language (UML) to a formal language (language of the NuSMV model checker) towards a greater adoption in practice of formal methods in software development.

Model checking of safety-critical software in the nuclear engineering domain

Instrumentation and control (I&C) systems play a vital role in the operation of safety-critical processes. Digital programmable logic controllers (PLC) enable sophisticated control tasks which sets high requirements for system validation and verification methods. Testing and simulation have an important role in the overall verification of a system but are not suitable for comprehensive evaluation because only a limited number of system behaviors can be analyzed due to time limitations. Testing is also performed too late in the development lifecycle and thus the correction of design errors is expensive. This paper discusses the role of formal methods in software development in the area of nuclear engineering. It puts forward model checking, a computer-aided formal method for verifying the correctness of a system design model, as a promising approach to system verification. The main contribution of the paper is the development of systematic methodology for modeling safety critical systems in the nuclear domain. Two case studies are reviewed, in which we have found errors that were previously not detected. We also discuss the actions that should be taken in order to increase confidence in the model checking process.

Formal methods in software development: A road less travelled

An integration of traditional verification techniques and formal specifications in software engineering is presented. Advocates of such techniques claim that mathematical formalisms allow them to produce quality, verifiably correct, or at least highly dependable software and that the testing and maintenance phases are shortened. Critics on the other hand maintain that software formalisms are hard to master, tedious to use and not well suited for the fast turnaround times demanded by industry. In this paper some popular formalisms and the advantages of using these during the early phases of the software development life cycle are presented. Employing the Floyd-Hoare verification principles during the formal specification phase facilitates reasoning about the properties of a specification. Some observations that may help to alleviate the formal-methods controversy are established and a number of formal methods successes is presented. Possible conditions for an increased acceptance of formalisms in oftware development are discussed.

Really Rethinking 'Formal Methods'

We must question the assumptions underlying the well-known current formal software development methods to see why they have not been widely adopted and what should be changed.

A metamodel approach on multiview consistency checking based on BCCS

MDA is an approach that uses modeling languages such as UML or BON to establish requirement models for the complementary of software specification,as well as for further implementation.However,models of complex information systems always require multiple views,such as static views and dynamic views to describe different perspectives of the system,thus may cause inconsistency in them.A metamodel in which a unifying framework was provided to ensure and check for model consistency was proposed.The authors used B,a full spectrum formal software development method,integrated with CCS,as the foundation to specify the approach.

Assessing the practical benefits of formal methods for software development

We describe a case study where one software module of an existing physical access control system was re-developed using formal software development methods. Because of increased software quality and comparable development efforts, we are considering the use of formal methods for the future development of critical modules. Further results of this work include the identification of a critical property of the given requirements, as well as insights into overall requirements quality.

Editorial

This issue of the Journal of Functional Programming is dedicated to work presented at the Workshop on Implicit Computational Complexity in Programming Languages, affiliated with the 1998 meeting of the International Conference on Functional Programming in Baltimore.Several machine-independent approaches to computational complexity have been developed in recent years; they establish a correspondence linking computational complexity to conceptual and structural measures of complexity of declarative programs and of formulas, proofs and models of formal theories. Examples include descriptive complexity of finite models, restrictions on induction in arithmetic and related first order theories, complexity of set-existence principles in higher order logic, and specifications in linear logic. We refer to these approaches collectively as Implicit Computational Complexity. This line of research provides a framework for a streamlined incorporation of computational complexity into areas such as formal methods in software development, programming language theory, and database theory.A fruitful thread in implicit computational complexity is based on exploring the computational complexity consequences of introducing various syntactic control mechanisms in functional programming, including restrictions (akin to static typing) on scoping, data re-use (via linear modalities), and iteration (via ramification of data). These forms of control, separately and in combination, can certify bounds on the time and space resources used by programs. In fact, all results in this area establish that each restriction considered yields precisely a major computational complexity class. The complexity classes thus obtained range from very restricted ones, such as NC and Alternating logarithmic time, through the central classes Poly-Time and Poly-Space, to broad classes such as the Elementary and the Primitive Recursive functions.Considerable effort has been invested in recent years to relax as much as possible the structural restrictions considered, allowing for more exible programming and proof styles, while still guaranteeing the same resource bounds. Notably, more exible control forms have been developed for certifying that functional programs execute in Poly-Time.The 1998 workshop covered both the theoretical foundations of the field and steps toward using its results in various implemented systems, for example in controlling the computational complexity of programs extracted from constructive proofs. The five papers included in this issue nicely represent this dual concern of theory and practice. As they are going to print, we should note that the field of Implicit Computational Complexity continues to thrive: successful workshops dedicated to it were affiliated with both the LICS'99 and LICS'00 conferences. Special issues, of Information and Computation dedicated to the former, and of Theoretical Computer Science to the latter, are in preparation.

Lessons learned from rigorous system software development

This article describes the rigorous application of formal methods of software development to a system software development project within a conventional industrial software development environment. This project applied formal methods to a small part (one subsystem) of the development of a release of a system software product. The formal methods VDM and B were used to specify, design and implement the administration subsystem of a product that was otherwise developed along conventional lines. Support tools were used to assist with the use of both methods throughout the development lifecycle. Metrics for effort and quality were collected from the project and compared with historical metrics for similar projects to allow the impact of formal methods on cost and quality to be assessed. This article briefly outlines the product being developed and the subsystem to which formal methods were applied. The environment in which this development was performed and the particular approach used are described. The results of this industrial application of formal methods and the lessons learned by the project are discussed at some length.

Lessons learned from rigorous system software development

This article describes the rigorous application of formal methods of software development to a system software development project within a conventional industrial software development environment. This project applied formal methods to a small part (one subsystem) of the development of a release of a system software product. The formal methods VDM and B were used to specify, design and implement the administration subsystem of a product that was otherwise developed along conventional lines. Support tools were used to assist with the use of both methods throughout the development lifecycle. Metrics for effort and quality were collected from the project and compared with historical metrics for similar projects to allow the impact of formal methods on cost and quality to be assessed. This article briefly outlines the product being developed and the subsystem to which formal methods were applied. The environment in which this development was performed and the particular approach used are described. The results of this industrial application of formal methods and the lessons learned by the project are discussed at some length.

Strongest postcondition semantics as the formal basis for reverse engineering

Reverse engineering of program code is the process of constructing a higher level abstraction of an implementation in order to facilitate the understanding of a system that may be in a “legacy” or “geriatric” state. Changing architectures and improvements in programming methods, including formal methods in software development and object-oriented programming, have prompted a need to reverse engineer and re-engineer program code. This paper describes the application of the strongest postcondition predicate transformer (sp) as the formal basis for the reverse engineering of imperative program code.

ON THE ANIMATION OF “NOT EXECUTABLE” SPECIFICATIONS BY PROLOG

An impediment to the widespread use of formal methods for software development is the difficulty in dealing with specifications, namely using them consistently in the software process. One approach to easing the management of specifications and improving their impact in the software process is animation, allowing developers to “execute” formal specifications as prototypes. This paper illustrates how Prolog can serve a multifaceted role for animating and prototyping specifications—as a target language, as the compilation/translation language, and to facilitate the advantages of formal methods through help in building formal proofs of properties such as correctness. Further, there is an implicit claim that, because of the correctness and directness of the translation, a subset of Z, not definitively established here, can be viewed as equivalent to a subset of Prolog.

Specification and Verification of Safe Software Systems

Starting with a short introduction to formal methods for software development the verification support environment (VSE) is presented. VSE was realized by a consortium of companies and university institutes on behalf of Bundesamt fur Sicherheit in der Informationstechnik, the German security agency. VSE supports the integrated development of safety critical and non safety critical subsystems including formal specification and verification of safety critical parts. Besides the structure and the components of VSE it is explained how to use VSE to develop software systems and which kinds of software systems can be supported. Using a simple example from the traffic control area the formal specification means are explained. Finally industrial experiences are provided gained during the development of two large case studies and eight industrial pilot projects.

Attitudes toward the teaching of formal methods of software development in the undergraduate computer science curriculum

This paper reports on a survey related to current views concerning the feasibility and importance of teaching formal methods of software development at the undergraduate level. Principle areas of interest considered include formal logic, formal specification, and formal proofs of correctness of programs. After alluding to several points of contact with current literature on this topic, the paper reports on a questionnaire designed by the authors that was mailed to computer science departments of selected colleges and universities in the United States and Canada. The principle goal of the survey is to determine attitudes of computer science faculty concerning the teaching of formal methods at the undergraduate level.

The practice of formal methods in safety-critical systems

By describing several industrial-scale applications of formal methods, we demonstrate that formal methods for software development and safety analysis are being increasingly adopted in the safety-critical systems sector. The benefits and limitations of formal methods are described, and the problems in developing software for safety-critical systems are analyzed.

FACILITATING THE MAINTENANCE OF SAFETY-CRITICAL SYSTEMS

As software is increasingly used to control safety-critical systems, correctness becomes paramount. Formal methods in software development provide many benefits in the forward engineering aspect of software development. Reverse engineering is the process of constructing a high-level representation of a system from existing lower level instanti-ations of that system. Reverse engineering of program code into formal specifications facilitates the utilization of the benefits of formal methods in projects where formal methods may not have previously been used, thus facilitating the maintenance of safety-critical systems.

Introduction to Algebraic Specification. Part 2: From Classical View to Foundations of System Specifications

Part 1 of this paper concerning algebraic specifications is an informal introduction to formal methods for software development using algebraic techniques. The intention of this second part of the paper is to survey the research field of algebraic specifications developed within the last two decades and the role of this field concerning formal methods in computer science. The aim of this paper is to show that the classical field of algebraic specifications, using equational axioms, equational logic and algebraic data types and varieties, has reached a consolidated status by now. It can be considered as an important kernel of a more general theory which is presently under development, focusing on the foundations of system specifications in general. Algebraic specification is a formal specification approach that emerged in the mid 1970s in order to provide an abstract and implementation-independent definition of data types. This original idea of using algebraic specifi- cations as a formal specification technique for abstract data types was quite successful. It was extended within the last decade to horizontal and vertical structuring of specifications as required from the software engineering point of view. Today algebraic specification is a well- known formal method for software development. In part 1 of this paper we have given an introduction to algebraic specification from the software engineering point of view which shows how algebraic specification techniques can support the general software development process. 14 In this second part of the introduction to algebraic specification we concentrate more on the mathematical theory, which has been developed from a subfield of universal algebra to a categorical theory for the founda- tions of system specifications. Algebraic specification originally concentrated on the use of equational logic as the basic formalism for research. This use has been one of the causes of its success, since the good behaviour of equational logic with respect to a number of semantic constructs has helped in the study of new specification concepts and constructs. Moreover, the abstract categorical techniques used to obtain these results allow a generic study of specification constructs independent of any specific formalism. In this sense, research in algebraic specifi- cation departed from equational logic a number of years ago and has concentrated, on the one hand, in extending the concepts and results for more expressive formalisms. On the other hand, the generic study of specification constructs provides the new aim of allowing the possibility of integrating several 'logics' into a single specification framework, in such a way that different aspects of a given system could be specified using the most appropriate formalism. Therefore, one may argue now that the area has broadened so much, with respect to techniques, aims and views, that it is no longer appropriate to call it algebraic specification. As a consequence, to describe all the work going on in this area we advocate using the name 'Foundations of System Specification', where algebraic specifications can be considered to be an important special case. The rest of the paper is organised as follows. In the following section we present the basic specification concepts using the equational formalism, i.e. the classical view of algebraic specifications. In Sections 3 and 4 we present the main constructions for building specifications and for implementations of specifications. Current work in the foundations of system specification is briefly described in Section 5. Finally a conclusion and references are given in Sections 6 and 7.

Introduction to Algebraic Specification. Part 1: Formal Methods for Software Development

The intention of this part 1 of an overview paper on algebraic specifications is an informal introduction to formal methods for software development in general and to applications of algebraic specifications in particular. Horizontal structuring and vertical refinement techniques for algebraic specifications are shown to support the general software development process. Moreover, a short overview of case studies and tools in the ESPRIT projects LOTOSPHERE and PROSPECTRA is given