A new concept of refinement used for behaviour modelling with automata

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 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.

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.

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.

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.

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.

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

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.

Industrial usage of code analysis tools based on semantic analysis, such as the Frama-C platform, poses several challenges, from the setup of analyses to the exploitation of their results. In this paper, we discuss two of these challenges. First, such analyses require detailed information about the code structure and the build process, which are often not documented, being part of the implicit build chain used by the developers. Unlike heuristics-based tools, which can deal with incomplete information, semantics-based tools require stubs or specifications for external library functions, compiler builtins, non-standard extensions, etc. Setting up a new analysis has a high cost, which precludes industrial users from trying such tools, since the return on investment is not clear in advance: the analysis may reveal itself of little use w.r.t. the invested time. Improving the usability of this first step is essential for the widespread adoption of formal methods in software development. A second aspect that is essential for successful analyses is understanding the data and navigating it. Visualizing data and rendering it in an interactive manner allows users to considerably speed up the process of refining the analysis results. We present some approaches to both of these issues, derived from experience with code bases given by industrial partners.

Specification and Verification of Safe Software Systems

This research work explores the trends in formal and agile software development methods. Software development has evolved, from the era of “code and fix” to methods categorized as “heavyweight” and “lightweight”. The heavyweight methods are championed by the waterfall method, while agile methods are considered the lead in lightweight methods of software development. Both methods have proven records of successes and failures. Bridging the divide between them and harmonizing their symbiotic properties has the synergy of creating beneficial and more robust methodology with complementary advantage which is termed ambidexterity. Ambidexterity allows for a high level approach of selecting a methodology on the basis of the problem requirements, and coordinates their independent processes complementarily without conflict. Keywords: Global Software Development, Agile Software Development, off Shoring, Near-shoring, Distribution

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. >

The B Method is a full spectrum formal software development method that covers the software process from specification to implementation. The method uses state machines, defined using logic and set theory with a notation similar to that of Z, that export operations. The method supports a notion of refinement and implementation, which is based on the notion of refinement in the refinement calculus with the exception that there is no distinction between procedural and data refinement. The B Toolkit is a configuration tool that manages developments under the B Method, generating proof obligations and supporting tools for the discharge of those proof obligations. There is also support for the generation of documentation, and for the browsing of developments.

Abstract: Small and medium enterprises (SMEs) are increasingly becoming targets of cyber-attacks due to their limited resources and inadequate cyber security practices. Knowledge sharing is crucial in enhancing cyber security practices among SMEs. This study investigates the effects of different knowledge-sharing methods on cyber security practices in SMEs. The study employs a mixed-methods approach, including surveys and interviews with SMEs in North Sulawesi. The results suggest that both formal and informal knowledge-sharing methods positively influence cybersecurity practices in SMEs. Formal methods, such as training sessions and workshops, are effective in improving cyber security awareness and knowledge, while informal methods, such as peer-to-peer sharing and mentoring, promote the adoption of cyber security best practices in SMEs. The study also identifies challenges and barriers to knowledge sharing and provides recommendations for enhancing knowledge sharing and cyber security practices in SMEs. Overall, this study highlights the importance of knowledge sharing in promoting cyber security practices in SMEs and provides insights for improving cyber security in this sector. Keywords: Cyber Security, Knowledge Sharing, Small Medium Enterprises.

Development of interactive systems and their user interfaces combines engineering and design, formal and informal development methods from different domains. Diverse models and tools can be used to support the developers’ work. In model-driven development, software systems are specified systematically using dedicated models for different aspects of the system. Yet, appropriate design of user interfaces is as important as functional correctness. This workshop provides a forum of multi-disciplinary discussion on how to integrate model-driven development with the often more informal methodologies used in user-centered design and engineering. Starting point of the discussion are the tools, models, methods and experiences of the workshop participants.KeywordsUser-interface engineeringinteraction designmodel-driven developmentuser-centered designmodels