FoCaLiZe: Inside an F-IDE

For years, Integrated Development Environments have demonstrated their usefulness in order to ease the development of software. High-level security or safety systems require proofs of compliance to standards, based on analyses such as code review and, increasingly nowadays, formal proofs of conformance to specifications. This implies mixing computational and logical aspects all along the development, which naturally raises the need for a notion of Formal IDE. This paper examines the FoCaLiZe environment and explores the implementation issues raised by the decision to provide a single language to express specification properties, source code and machine-checked proofs while allowing incremental development and code reusability. Such features create strong dependencies between functions, properties and proofs, and impose an particular compilation scheme, which is described here. The compilation results are runnable OCaml code and a checkable Coq term. All these points are illustrated through a running example.Comment: In Proceedings F-IDE 2014, arXiv:1404.578

Integrated environment of systems automated engineering

The Standardization of a development process for systems of medium complexity, entirely supported by an integrated development environment, could mean a double contribution to the industry of systems development. On the one hand it would contribute to the reduction of costs by shortening times of development and facilitating the maintenance of the systems. On the other hand, by using conceptual models of a high level of abstraction, final users would be able to visualize and follow the progress of systems development and to commit themselves in the process actively, guaranteeing their success. The purpose of this series of papers is to identify, design, develop and integrate the components of an integrated environment for a system automated development, starting from high-level-abstraction formal specifications. It is intended to achieve a generation of systems starting from only two models: the static or data structure model, and the dynamic or functional model. The former is based on an adaptation of the conceptual pattern of entities and relationships, and the latter on the formal specification of operations in objects relational algebra and on the finite automaton theory. The maintenance of the systems generated by the tool would be made by operating directly on the static and dynamic models, with no need for either re-coding or making reverse engineering. The strength of the proposal is based on integration of the Software Engineering and the analysis and metrics of quality. Storage protocols of data definitions and storage protocols of interface definitions corresponding to a graph, through the state transitions and their gradation so that the user could visualize the development of the life cycle[6][32][33][47]. Any artifact or document can be measured and estimated if it is produced during the software life cycle. This study is an approximation to a process of activities supported by an effective help tool. Abstraction and visualization capacities are provided to the artifacts with the system design and analysis (CASE). Such artifacts under controlled conditions trace the software life cycle taking information of the structure (framework) of the application; with Quality, Reliability and Metrics.Eje: Ingeniería de Software y Base de DatosRed de Universidades con Carreras en Informática (RedUNCI

SPEEDY: An Eclipse-based IDE for invariant inference

SPEEDY is an Eclipse-based IDE for exploring techniques that assist users in generating correct specifications, particularly including invariant inference algorithms and tools. It integrates with several back-end tools that propose invariants and will incorporate published algorithms for inferring object and loop invariants. Though the architecture is language-neutral, current SPEEDY targets C programs. Building and using SPEEDY has confirmed earlier experience demonstrating the importance of showing and editing specifications in the IDEs that developers customarily use, automating as much of the production and checking of specifications as possible, and showing counterexample information directly in the source code editing environment. As in previous work, automation of specification checking is provided by back-end SMT solvers. However, reducing the effort demanded of software developers using formal methods also requires a GUI design that guides users in writing, reviewing, and correcting specifications and automates specification inference.Comment: In Proceedings F-IDE 2014, arXiv:1404.578

Executable component-based semantics

The potential benefits of formal semantics are well known. However, a substantial amount of work is required to produce a complete and accurate formal semantics for a major language; and when the language evolves, large-scale revision of the semantics may be needed to reflect the changes. The investment of effort needed to produce an initial definition, and subsequently to revise it, has discouraged language developers from using formal semantics. Consequently, many major programming languages (and most domain-specific languages) do not yet have formal semantic definitions.To improve the practicality of formal semantic definitions, the PLanCompS project has developed a component-based approach. In this approach, the semantics of a language is defined by translating its constructs (compositionally) to combinations of so-called fundamental constructs, or ‘funcons’. Each funcon is defined using a modular variant of Structural Operational Semantics, and forms a language-independent component that can be reused in definitions of different languages. A substantial library of funcons has been developed and tested in several case studies. Crucially, the definition of each funcon is fixed, and does not need changing when new funcons are added to the library.For specifying component-based semantics, we have designed and implemented a meta-language called CBS. It includes specification of abstract syntax, of its translation to funcons, and of the funcons themselves. Development of CBS specifications is supported by an integrated development environment. The accuracy of a language definition can be tested by executing the specified translation on programs written in the defined language, and then executing the resulting funcon terms using an interpreter generated from the CBS definitions of the funcons. This paper gives an introduction to CBS, illustrates its use, and presents the various tools involved in our implementation of CBS

Formal Reasoning Using an Iterative Approach with an Integrated Web IDE

This paper summarizes our experience in communicating the elements of reasoning about correctness, and the central role of formal specifications in reasoning about modular, component-based software using a language and an integrated Web IDE designed for the purpose. Our experience in using such an IDE, supported by a 'push-button' verifying compiler in a classroom setting, reveals the highly iterative process learners use to arrive at suitably specified, automatically provable code. We explain how the IDE facilitates reasoning at each step of this process by providing human readable verification conditions (VCs) and feedback from an integrated prover that clearly indicates unprovable VCs to help identify obstacles to completing proofs. The paper discusses the IDE's usage in verified software development using several examples drawn from actual classroom lectures and student assignments to illustrate principles of design-by-contract and the iterative process of creating and subsequently refining assertions, such as loop invariants in object-based code.Comment: In Proceedings F-IDE 2015, arXiv:1508.0338

Development of New Model-based Methods in ASIC Requirements Engineering

Requirements in the development of application-specific integrated circuits (ASICs) continue to increase. This leads to more complexities in handling and processing the requirements, which often causes inconsistencies in the requirments. To better manage the resulting complexities, ASIC development is evolving into a model-based process. This thesis is part of a continuing research into the application and evolution of a model-based process for ASIC development at the Robert Bosch GmbH. It focuses on providing methologies that enable tracing of ASIC requirements and specifications as part of a model-based development process to eliminate inconsistencies in the requirements. The question of what requirements are and, what their traceability means, is defined and analysed in the context of their relationships to models. This thesis applies requirements engineering (RE) practices to the processing of ASIC requirements in a development environment. This environment is defined by availability of tools which are compliant with some standards and technologies. Relying on semi-formal interviews to understand the process in this environment and what stakeholders expect, this thesis applies the standards and technologies with which these tools are compliant to provide methodologies that ensures requirements traceability. Effective traceability methods were proven to be matrices and tables, but for cases of fewer requirements (ten or below), requirement diagrams are also efficient and effective. Furthermore, the development process as a collaborative effort was shown to be enhanced by using the resulting tool-chain, when the defined methodologies are properly followed. This solution was tested on an ASIC concept development project as a case study