Project on Diverse Software — An Experiment in Software Reliability

It is often felt that the use of formal specification techniques (FSTs) precludes the use of informal, structured specification techniques (ISTs). Research on integrated FSTs and ISTs (FISTs) has shown that this is not necessarily the case, and that the use of formal techniques can enhance the use of informal specification techniques and vice versa.

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.

Many regular business operations are transforming into digital services, increasing advanced multi-platforms, rapid operational alignment, flexibility, and environmental impact through energy consumption, hardware waste, and technology investments. Flexible and sustainable system development models emphasizing energy efficiency can help innovate software development as digital servicing applications shift. This research is motivated by the need to improve energy consumption in early software design and development due to rising technological efficiency and sustainability demands. Although effective in iterative development and stakeholder engagement, traditional Agile methodologies often struggle with long-term sustainability and energy efficiency. Extended Agile, combining Agile, layered architecture, and aspect-oriented frameworks (ALAI), promises to improve system modularity, flexibility, maintainability, and sustainability. This study’s findings are not just theoretical, but also practically relevant, as they explore the energy efficiency of ALAI software development methodologies, using graduate admission information system services (GAISS) as an example. GAISS is a complex system that handles the entire process of graduate admissions, from application submission to final decision. The study quantifies the energy usage of a student-list webpage by analyzing Microsoft IIS server logs from February 2022 to May 2024. Directly applicable findings show that the GAISS based on the ALAI framework reduces energy consumption by 10.7914% compared to traditional Agile software developments. ALAI used 892.80 kWh versus Agile’s 1000.80 kWh during operations, saving energy. These findings demonstrate the benefits of integrating aspect-oriented frameworks and layering approaches into Agile methodologies, contributing to sustainable software development discourse. The study emphasizes the importance of energy-efficient frameworks such as ALAI to reduce software systems’ environmental impact and promote software development sustainability. The findings of this study, with their practical relevance, assist software developers and organizations in choosing software design and development methods that maximize operational efficiency and environmental sustainability.

Facilitating formal specification acquisition by using recursive functions on context-free languages

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

This paper is an overview of the panel session on integrating specification techniques that was held in the International Workshop on Industrial-strength Formal Techniques in October 22nd 1998.

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.

The existing software engineering seldom considers software usability, and human-computer interaction (HCI) techniques which can improve the software usability cannot guarantee development efficiency. Recently, more and more stakeholders and users begin to regard the usability as an important software requirement. In order to bring respective advantages of software engineering and HCI techniques into full play to improve software usability and development efficiency, the paper presents user model driven software development, which integrates HCI techniques into software development method by eliciting user model under the participation of user, HCI designer and software engineer. Applications show that the method can be effectively applied to small software development team, and can raise software usability and development efficiency.

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.

It is well recognized that Agent Communication Languages (ACL’s) are critical elements of Multi-Agent Systems and a key to their successful application in commerce and industry. The established field ofprotocol engineering, which concerns itself with how to specify machine communication languages and protocols, verify their properties and validate implementations thereof, has developed powerful, theoretical and practical techniques for doing so, and a mature understanding of the essential requirements that such specifications should meet. Regrettably, this body of knowledge and practice appears to have had little influence on recently proposed ACL standards. For example, the latest ACL specifications proposed by the Foundation for Intelligent Physical Agents (FIPA) are a confusing mix of different formal and informal specification techniques whose net result is ambiguous, inconsistent and under-specified. Allowances must be made, as these are still draft specifications, but rather than providing a verified foundation for reliable communication between heterogeneous agents, they run the risk of leading to unreliable or incompatible implementations, or of being ignored in favour of more pragmatic and robust approaches. In this paper, we propose a set of basic requirements which an ACL specification should meet, describe how the FIFA ACL measures up against these, and contrast its features with those of a small ACL which was designed with reliability and ease of verification as prime objectives.

It is well recognized that Agent Communication Languages (ACL’s) are a critical element of Multi-Agent Systems and a key to their successful application in commerce and industry. The field of protocol engineering, which addresses the problems of specifying and verifying machine communication languages and testing implementations, has developed powerful theoretical and automated techniques for doing this, and more importantly, a mature understanding of the requirements that communication language and protocol specifications should meet. Unfortunately, those developing and promulgating ACL’s appear not to have taken advantage of this body of knowledge. An examination of the current ACL specifications being developed by the Foundation for Intelligent Physical Agents (FIPA) reveals a confusing amalgam of different formal and informal specification techniques whose net result is ambiguous, inconsistent and certainly under-specified. Allowances must be made, as these are draft specifications, but rather than providing a verified foundation for reliable communication between heterogeneous agents, they seem likely to lead to a host of unreliable and incompatible implementations, or to be ignored in favour of more pragmatic and robust approaches. In this paper, we propose a set of requirements against which an ACL specification can be judged, briefly explore some of the shortcomings of the FIPA ACL and their origins, and contrast it with a small ACL which was designed with reliability and ease of verification as prime objectives.KeywordsAgent CommunicationCommunication LanguageMessage TypePragmatic PerspectiveContent LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Focusing on aspects during early stages of the software development lifecycle has received special attention by many researchers, leading to the advent of numerous Aspect-Oriented Software Development (AOSD) methods. This has consequently given a relatively high level of maturity to aspect-oriented processes. Process patterns, on the other hand, have been adopted as suitable mechanisms for defining or tailoring processes to fit specific organizational/project requirements. Process patterns, which essentially are reusable process components extracted from successful processes and practices, can be used to engineer new software development methodologies or to enhance existing ones. We propose a generic Aspect-Oriented Software Process (AOSP), constructed through studying and abstracting prominent aspect-oriented processes. Based on the proposed AOSP, process patterns are provided which incorporate well-established aspect-oriented practices for different development stages. By employing specific process evaluation criteria, the characteristics of these patterns have been analyzed.

Formal methods can only gain widespread use in industrial software development if they are integrated into software development techniques, tools, and languages that are used in practice. The objective of this tutorial is to show how formal specification and deductive verification of object-oriented programs can be done within a software development platform that supports contemporary design and implementation methodologies. The KeY System (developed by the tutorial presenters) is used for demonstration purposes, which implements our approach and integrates formal methods into the commercial CASE tool Borland Together Control Center 6.2 and, alternatively, the open extensible IDE Eclipse.

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.