Towards a Dynabook for verified VM construction

Program synthesis automates the process of writing code, which can be a very useful tool in allowing people to better leverage computational resources. However, a limiting factor in the scalability of current program synthesis techniques is the large size of the search space, especially for complex programs. We present a new model for synthesizing programs which reduces the search space by composing programs from program pieces, which are component functions provided by the user. Our method uses genetic programming search with a fitness function based on refinement type checking, which is a formal verification method that checks function behavior expressed through types. We evaluate our implementation of this method on a set of 3 benchmark problems, observing that our fitness function is able to find solutions in fewer generations than a fitness function that uses example test cases. These results indicate that using refinement types and other formal methods within genetic programming can improve the performance and practicality of program synthesis.

Formal methods, whereby a system is described and/or analyzed using precise mathematical techniques, is a well-established and yet, under-used approach for developing software systems. One of the reasons for this is that project deadlines often impose an unsatisfactory development strategy in which code is produced on an ad hoc basis without proper thought about the requirements and design of the piece of software in mind. The result is a large, often poorly documented and un-modular monolith of code that does not lend itself to formal analysis. Because of their complexity, formal methods work best when code is well structured, e.g., when they are applied at the modeling level. UML is a modeling language that is easily learned by system developers and, more importantly, an industry standard, which supports communication between the various project stakeholders. The increased popularity of UML provides a real opportunity for formal methods to be used on a daily basis within the software lifecycle. Unfortunately, the lack of precision of UML means that many formal techniques cannot be applied directly. If formal methods are to be given the place they deserve within UML, a more precise description of UML must be developed. This chapter surveys recent attempts to provide such a description, as well as techniques for analyzing UML models formally.

This paper addresses the problem of alignment of domain ontologies and meta-models of Domain Specific Languages DSL in order to facilitate the DSL development process by formal methods. The solution presented in this paper automatically generates design templates of a DSL meta-model that are consistent with a given domain ontology represented in OWL DL. Consistency of alignment is ensured by predefined mapping rules between constructs of ontology modelling language OWL DL and a modelling language used for representing DSL meta-models. The approach is implemented as an extension to the CoCoViLa system and the CoCoViLa modelling language is used for representing DSL meta-models. The evaluation of the provided method is carried out by developing the DSL for the IT risk analysis and management domain.

A novel approach for automatic software test generation is presented, which combines ideas from structural and functional testing as well as formal verification methods. It involves as an intermediate step, the construction of graphs and refinement types, which can be regarded as an automatically constructed semi-specification and used for formal verification. The technique is illustrated using a simple functional language, with algorithms for assigning refinement types and for test generation. Some desirable theoretical properties of the approach are briefly considered. It is also compared informally to other well-known as well as new techniques for automatic test generation.

In object-oriented development, the Unified Modeling Language (UML) is the ISO/IEC standard modeling language. In relational database development, entity-relationship models are traditionally been use for modeling. Transforming from one model to the other is of great importance in developmental environments where this is required. There are several techniques for transforming UML models to object-relational database systems. Prior research effort examined the benefits of two such approaches. That work, sought to determine the benefits of one approach (formal technique) versus the benefits of the other approach (informal technique), by way of comparative analysis. The results of such work have to be validated, in order for it to become acceptable and its implication applied in software development decision making. In this work, an attempt to apply a similar comparative analysis on a model from a different application domain (Kalman Filter Program Representation), from that which was used in the first study an (Airline Flight Reservation System) was conducted. The goal of this research is to provide validation of the usefulness of this type of transformation.

Linear Hybrid Automata (LHA) is a natural modeling language for real-time embedded systems. However, due to the existences of both discrete and continuous behaviors, formal analysis of LHA is recognized as a very challenging task. Despite decades of active research, the kinds of LHA problems that can be efficiently analyzed is rather limited. On the other hand, Labelled Linear Transition System (LTS) is a widely used modeling language to describe the state changes of the system before and after certain transitions. Lots of research efforts have been devoted into the verification of LTS models. Many off-the-shelf formal techniques and tools are available for analyzing different kinds of problems for LTS systems. In this paper, we propose to express an LHA as an equivalent LTS model explicitly. Then, we can take advantage of all the off-the-shelf formal checkers of LTS to answer different problems of the LHA model. A prototype tool HAT is implemented under this idea. By integrating typical LTS checkers like ARMC and Interproc, we conduct considerably difficult checking problems like reachability verification, termination analysis, and invariant generation of LHA successfully and efficiently. It shows the open possibility of analyzing more kinds of difficult problems of LHA by LTS checkers easily in the future.

Reuse and component design have extensively been applied to software engineering, but reuse and formal design methods in WWW-based system is still in its infancy. Most WWW developers currently design WWW content for the most efficient delivery and do not focus on these factors. This is because, at present, any extra code added to WWW components is often seen as non-essential. This resistance will be overcome over the next few years as the way that uses view content, and the way that they connect to the WWW changes. It is thus more likely that WWW pages will become more refined, and require much shorter design cycles than they typical have now. The key to this will thus be reuse, and in new application models which improved they way that content can be viewed, and reused. With the acceptance of XML (eXtensible Markup Language) as a standard modelling language, there will be an increase in the usage of formal modelling languages, which integrate the WWW with the application domain. A good example of this is EML (Education Modelling Language), which tries to model the education process in a formal way, which can be easily interpreted within a WWW browser.

Pascal’s triangle is a classical mathematical construct, historically studied for centuries, that organises binomial coefficients in a triangular array and serves as a cornerstone in combinatorics, algebra, and number theory. Herein, we propose to model it with Petri nets, a formal specification technique derived from discrete event systems. A minimal Petri net is created that generates Pascal’s triangle under a simple arithmetic rule. Token counts in each place coincide with binomial coefficients, providing a direct combinatorial interpretation. Two other classical structures emerge from this model: by colouring tokens depending on their parity, the Sierpiński triangle appears; by routing tokens randomly at each branching, the binomial distribution arises, converging to a Gaussian limit as depth increases. As a result, a single Petri construction unifies three mathematical objects: Pascal’s Triangle, Sierpiński’s Triangle, and the Gaussian distribution. This connection illustrates the invaluable potential of Petri nets as unifying tools for modelling discrete mathematical structures and beyond.

The formal modeling method can accurately describe systems. Using formal method to test software improves the efficiency of software testing and it is comprehensive. Common real-time embedded software formal testing methods include Z language, finite state machine (FSM) and unified modeling language (UML), Petri net and time input/output automata (TIOA). This paper analyzes the characteristics of embedded software testing. The above formal methods and test case coverage criterions and test data collection methods are introduced. Combined with the characteristics of missile-borne software, this paper presents suitable ideas of testing missile-borne software.

Robots are found in most, if not all, modern production facilities and they increasingly enter other domains, e.g., health care. Robots participate in complex processes and often need to cooperate with other robots to fulfill their goals. They must react to a variety of events, both external, e.g., user inputs, and internal, i.e., actions of other components or robots in the system. Designing such a system, in particular developing the software for the robots contained in it, is a difficult and error-prone task. We developed a formal scenario-based modeling method which supports engineers in this task. Using short, intuitive scenarios engineers can express requirements, desired behavior, and assumptions made about the system’s environment. These models can be created early in the design process and enable simulation as well as an automated formal analysis of the system and its components. Scenario-based models can drive the execution at runtime or can be used to generate executable code, e.g., programmable logic controller code. In this paper we describe how to use our scenario-based approach to not only improve the quality of a system through formal methods, but also how to reduce the manual implementation effort by generating executable PLC code.

Given the central role that C continues to play in systems software, and the difficulty of writing safe and correct C code, it remains a grand challenge to develop effective formal methods for verifying C programs. In this paper, we propose a new approach to this problem: a type system we call RefinedC, which combines ownership types (for modular reasoning about shared state and concurrency) with refinement types (for encoding precise invariants on C data types and Hoare-style specifications for C functions).

Although the Unified Modeling Language (UML) is by now accepted as a standard and is widely used as an object-oriented modeling language, some languages such as Z or VDM are preferred to formally specify reference models. Here, we present a reference model for hypermedia systems in UML. It is an object-oriented and Dexter-based approach that uses UML to provide an intuitive graphical representation of the model. The class diagrams are supplemented with formal constraints in the Object Constraint Language (OCL), adding invariants on elements as well as preconditions and postconditions on operations. The result is an easily extendable reference model for describing specific hypermedia systems, for example, like adaptive or mobile systems. Our contribution shows how formal and semiformal object-oriented techniques can be integrated in the metamodeling process.

Due to the ever increasing complexity of embedded and cyber‐physical systems, corresponding design solutions relying on modelling languages such as Unified Modelling Language (UML)/Object Constraint Language (OCL) find increasing attention. Due to the recent success of formal verification techniques, UML/OCL models also allow to verify and/or check certain properties of a given model in early stages of the design phase. To this end, different approaches for verification and validation have been proposed. In this work, the authors motivate, define, and describe different verification tasks for structural, as well as behavioural UML/OCL models that can be solved using solvers for Boolean satisfiability. They describe how these verification tasks can be translated into a symbolic formulation which is passed to off‐the‐shelf solvers afterwards. The obtained results enable designers to draw conclusions about the correctness of the considered model.

Automation and high coverage are two essential industrial technical requirements of qualified testing method for safety-critical systems. The ioco-testing method is a sound and well-defined formal automation testing technique for labelled transition system. However, when we apply this method to a train control system developed by our industrial partner, we find that some testing requirements are not covered for certain testing objects. Further analysis has shown that the ioco-testing method only generates test cases based on explicit specified system behaviors which may result in low coverage when the implementation under test includes code branches used to deal with faults which can't be defined thoroughly in the specification in practices. Therefore, we propose a labelled transition system testing method based on specification mutation to improve safety-critical system testing coverage. We firstly define the mutation operators for the Input output symbolic transition system (IOSTS) modeling language, then we construct the corresponding test generation algorithm and translate the derived test cases into xml files which can be directly applied to the implementation under test in a simulation and test platform developed by our partner. Preliminary experiments on a safety-critical function named train position determination have shown about 28.5% improvement on the testing coverage.

In spite of its informal semantics and of some ambiguities, UML is a widespread modelling language used in both industry and academia. On the other hand, Petri nets are a mathematical modelling language with a formal semantics and are well suited for formal verification. However, altough there is a growing interest in model checking techniques from industry, the software engineers continue to be unfamiliar with such a formalism. For that reason, it is convenient to supply formal verification techniques of UML diagrams that are completely automatic and transparent to the designer. This is the issue discussed in this paper. We propose to translate UML state diagrams into Coloured Petri nets on which verification of some desired properties can be checked automatically. We show on our example that, when expected properties are not checked, this is an opportunity to revise the model into a more adequate one