Advances in Usability of Formal Methods for Code Verification with Frama-C

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

Starting from the experience gained in organizing TAPSOFT'85, the paper discusses the place of formal methods in software development. It distinguishes two notions of theory: the mathematical science of computation and the treatment of computing as a human activity. An adequate software theory needs to take both theoretical perspectives into account. Therefore, the paper explores the borderline of formalization and human activity in several directions: concerning the role and scope of formalized procedures, the relation between formal models and situated use, the process of learning in software development and the ways computer programs become effective in use. Fundamental assumptions underlying formal methods and their relation to emancipatory approaches such as participatory design are discussed. The paper closes with calling for a dialogical framework for further pursuing these questions.

The benefits of formal methods in software development are well recognised and well documented. Design recovery involves analysing the source code and recovers the desired design elements based on design recovery specification. One way to ensure the correctness of the recovered design is to use formal methods in the process. This paper describes an approach to apply formal methods to design recovery. We present the Concept Mapping Language (CML), which is largely based on an adapted form of first-order languages with an object-oriented syntactical extension, to specify the recovery specification that guides the design recovery process. CML enforces consistency in the specification through formal notations and syntax, and the formal specification ensures correctness in the recovered design through formally correct specification. The result is a simple and reliable approach to apply formal methods to design recovery that will ensure correctness in the specification and therefore the recovered design.

Formal methods for software development receive much attention in research centres, but are rarely used in industry for the development of (large) software systems. One of the reasons is that little is known about the integration of formal methods in the software process, and the exact role of formal methods in the software life-cycle is still unclear. In this paper, a detailed examination is made of the application of, and the benefits resulting from, a generally applicable formal method (VDM) in a standard model for software development (DoD-STD-2167A). Currently, there is no general agreement on how formal methods should be used, but in order to analyse the use of formal methods in the software process, a clear view of such use is essential. Therefore, we show what is meant by ‘using a formal method’. The different activities of DoD-STD-2167A are analysed with regard to their suitability for applying VDM and the benefits that may result from applying VDM for that activity. Based on this analysis, an overall view on the usage of formal methods in the software process is formulated.

The proper use of formal methods in software development strongly influences the nature and relationships between the various kinds of documentation produced. Rather than being a mass of heterogeneous information produced mainly for immediate use and then discarded, product documentation should be a coherent collection of information of lasting value in the continuing life of the product. In this paper we look first at the nature of product documentation in a mature product developed with the aid of formal methods. Next we consider how different people in a software development organisation interact with product documentation in their work. Finally we examine the problems that face managers of existing products who wish to construct product documentation in the mould described here.

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.

Relying on implementations in verification results in specifications and implementations that do not lend themselves well to reuse. Moreover, conventional verification tells engineers rather little about actual software or design quality ("Trust me, it's good."). We regard ease of formal specification, quality assessment and specification reuse, particularly in the form of declarative specifications, to be decisive factors in furthering the application of formal methods in software development. We aim to provide new, tool-supported techniques combining, and enabling, practical specification formalisms, implementation less model checking of structured specifications and complex measures for specification quality.

Clean room software engineering is a formal software development method that can strictly engineer software development and eliminate defects before they can cause serious harm. The clean room software engineering model has its own advantages and disadvantages in use. To use it in traditional software engineering, it is necessary to clarify the relationship between it and traditional software engineering methods and practices. Based on the technology and principles of the clean room software process, this paper gets the advantages and disadvantages of the clean room. Corresponding the traditional method-based software process to the key technology of the clean room, making the traditional management-based software engineering method and the tailored clean room compatible, and the software engineering practice of the clean room software process is compared with the traditional software engineering practice. To discuss the clean room and traditional software engineering, in order to expand the use of clean room methods, improve the clean room software process, and improve the quality of software.

Specification and Verification of Safe Software Systems

Specifications are important in software development because a large percentage of the errors at implementation and test phases are traceable to a lack of precision of the specifications. Formal methods are studied and applied to produce clear specifications and argue about them rigorously. As formal methods may even increase the ratio of specification phase in the software life-cycle, it is necessary to be efficient in debugging, modification, and reuse of specifications to reduce cost of the whole software development process. In a large scale specification in particular, parts extracted from the specification are useful. We introduce here a specification slicing that supports debugging, modification and reuse of specifications. In this paper, we define specification slice as a part of a specification that defines or restricts values of a particular variable used in the specification. Attention is also directed to applications of specification slicing and support tools. >

This paper introduces a new approach of using automata to model behaviour of objects. Automata allow to design a software model on the abstract level of states and transitions. We make precise the meaning of states and transitions in the context of objects and types. This formal semantics serves as a link between informal and formal software development methods. Second, we give a formal, but nevertheless intuitive definition of automata specialization which not only provides a way for reuse of type definitions in subtypes, but also shows how to incrementally design types through refinement. Third we define the notion of a role an object takes when viewed from the environment. Then we can give a formal, but short proof that our definitions satisfy the subtype requirement, that means that an object of the subtype plays the roles of its Supertypes.

Project on Diverse Software — An Experiment in Software Reliability

A. Joe TurnerThe role of formal methods for program development and verification in computer science curricula will be discussed. The panel members will address the questions1) What should be taught?2) When should it be taught?3) What are the objectives in teaching this material?4) What are the problems in teaching this material at this level?The panel members and an outline of their positions is given below.Susan L. GerhartCertain things are understood to be needed for applying verification technology to actual software. The basic knowledge needed to apply verification methods using current technology to large-scale problems will be discussed, based on actual experience in using the technology in such areas as database systems, operating systems, and communications systems.Eric C. HehnerThe Dijkstra/Gries approach to program development is an important and useful component of the computer science curriculum. Good programmers use this approach informally, and instruction in the formal methods can provide the understanding that will improve average programmers. Although the subject matter is currently taught at the senior/graduate level at Toronto, it should be taught earlier, for example during the second year. Teaching the material earlier does require a different approach, however, and good student preparation in logic would be essential for success.Harlan D. MillsFormal methods and a large structured set of principles for program design and verification should be taught early in the computer science curriculum. Instruction in programming can be improved by teaching a large set of small principles, and teaching by apprenticeship. Students learn easier and faster when they are freshmen than later after they have become hackers.

The Use of Analytic Hierarchy Process for Software Development Method Selection: A Perspective of e-Government in Indonesia

The use of formal methods is often recommended to guarantee the provision of necessary services and to assess the correctness of critical properties, such as functional safety, cybersecurity, and reliability, in medical and health care devices. In the past, several formal and rigorous methods have been proposed and consequently applied for trustworthy development of medical software and systems. In this paper, we perform a systematic literature review on the available state of the art in this domain. We collect the relevant literature on the use of formal methods for modeling, design, development, verification, and validation of software‐intensive medical systems. We apply standard systematic literature review techniques and run several queries in well‐known repositories to obtain information that can be useful for people who are either already working in this field or planning to start. Our study covers both quantitative and qualitative aspects of the subject.