An Empirical Study on Teaching Formal Methods to Millennials

This paper summarises our experience in teaching Formal Methods to Computer Science and Software Engineers students from various universities around the world, including the University of Madeira in Portugal, the Pontificia Universidad Javeriana and the University of The Andes in Colombia, Carnegie Mellon University (CMU) in the USA, and Innopolis University (INNO) in Russia. We report challenges we have faced during the past 10 to 15 years when teaching formal methods using the Event B formalism, and describe how we have evolved the structure of our courses to respond to those challenges. We strive to help students to build skills on Formal Methods that they can employ later on in their future IT jobs in software Industry. Our goal is to promote the wide use of Formal Methods by software Industry. We consider that this goal cannot be achieved without first universities transferring to Industry students with a strong background in Formal Methods and related formal tools. Formal Methods are key to software development because they are based on Discrete Mathematics which can be used to properly reason about properties that the software one develops should have. We have conducted two surveys among our students, the first one at CMU and the second one at INNO, that we use here to document and justify our decisions in terms of the course structure. The first survey is about the use of Event B as main mathematical formalism, and the second one is about the organisation of teams of students within the classroom to work on software projects that use Event B as main mathematical formalism. Our hope is that our work can be reused by other Faculty to make their own decisions on course structure and content in the teaching of their Formal Methods courses.

This white paper argues that formal methods need to be better rooted in higher education curricula for computer science and software engineering programmes of study. To this end, it advocates improved teaching of formal methods; systematic highlighting of formal methods within existing, ‘classical’ computer science courses; and the inclusion of a compulsory formal methods course in computer science and software engineering curricula. These recommendations are based on the observations that formal methods are an essential and cost-effective means to increase software quality; however computer science and software engineering programmes typically fail to provide adequate training in formal methods; and thus there is a lack of computer science graduates who are qualified to apply formal methods in industry. This white paper is the result of a collective effort by authors and participants of the 1st International Workshop on Formal Methods – Fun for Everybody which was held in Bergen, Norway, 2–3 December 2019. As such, it represents insights based on learning and teaching computer science and software engineering (with or without formal methods) at various universities across Europe.

Teachers of formal methods courses often experience disinterest or even disgust towards the topic from software engineering students. As one of the significant reasons of this situation we see the fact that students are not in touch with domains where their use is desired and worth the effort. In this paper we deal with a toolset we developed to improve the situation. The toolset brings to students, in a virtual form, one of the most successful domains of formal methods application - railway systems. It consists of a modified version of a railway centralized traffic control simulator called Train Director and a tool that allows signals and switches in a railway scenario, simulated by Train Director, to be controlled by a separate formally developed control program. We briefly describe the toolset and its typical use within a formal methods course and discuss its usability with respect to various formal methods.

A new style of formal methods course is described, based on a pragmatic approach that emphasizes testing. The course introduces students to formal specification using Z, and shows how formal specification and testing can benefit each other, in both the validation and verification phases. It uses a tools‐based approach, with practical work that reinforces formal specification techniques as well as traditional software engineering skills, such as unit and system testing, inspection and defensive programming with assertions. The two main results are to identify several practical uses of formal specifications that are not widely practised or taught, and to demonstrate that teaching them results in a more interesting and relevant formal methods course. Copyright © 2001 John Wiley & Sons, Ltd.

Formal methods encompass a wide choice of techniques and tools for the specification, development, analysis, and verification of software and hardware systems. Formal methods are widely applied in industry, in activities ranging from the elicitation of requirements and the early design phases all the way to the deployment, configuration, and runtime monitoring of actual systems. Formal methods allow one to precisely specify the environment in which a system operates, the requirements and properties that the system should satisfy, the models of the system used during the various design steps, and the code embedded in the final implementation, as well as to express conformance relations between these specifications. We present a broad scope of successful applications of formal methods in industry, not limited to the well-known success stories from the safety-critical domain, like railways and other transportation systems, but also covering other areas such as lithography manufacturing and cloud security in e-commerce, to name but a few. We also report testimonies from a number of representatives from industry who, either directly or indirectly, use or have used formal methods in their industrial project endeavours. These persons are spread geographically, including Europe, Asia, North and South America, and the involved projects witness the large coverage of applications of formal methods, not limited to the safety-critical domain. We thus make a case for the importance of formal methods, and in particular of the capacity to abstract and mathematical reasoning that are taught as part of any formal methods course. These are fundamental Computer Science skills that graduates should profit from when working as computer scientists in industry, as confirmed by industry representatives.

Formal methods should be taught as part of any degree in computing science or software engineering. We believe that discrete mathematics is the foundation upon which software development can be lifted up to the heights of a true engineering discipline. The transfer of formal methods to industry cannot be expected to occur without first transferring, from academia to industry, graduates who are well grounded in suchmathematical techniques. These graduatesmust bring a positive, yet realistic, view on the application of formal methods. Our goal is to produce software engineers who will go out into industry understanding the principles of specification, design and implementation. As these graduates develop their engineering skills, in an industrial setting, they should have the means, and the motivation, to integrate formality and rigour into any environment in which they are found. In this way, the formal methods should start to 'sell themselves'. This paper reports on our first attempt to teach a formal methods course as part of a degree in software engineering. Rather than concentrating on one particular method, we worked on a set of small case studies, using the mathematics in a flexible and intuitive manner, where the students could appreciate the need for formality. Each case study was intended to illustrate, in turn, the need for some fundamental formalism. An unexpected result was that we also identified weaknesses in our understanding of formal methods: students' naive questioning helped us to identify how the methods, and the teaching of these methods, could be improved. In brief, it was not just the students who were learning!

We present the contents of a new formal methods course taught to undergraduate students in their third year at the University of Rennes 1 in France. This course aims at initiating students to formal methods, using the Why3 platform for deductive verification. It exposes students to several techniques, ranging from testing specifications, designing loop invariants, building adequate data structures and their type invariants, to the use of ghost code. At the end of the course, most of the students were able to prove correct in an automated way non-trivial sorting algorithms, as well as standard recursive algorithms on binary search trees.

In a wide range of application areas, system behavior is modeled using variations of scenarios and state machines. In telecommunications, ITU standards SDL (Specification and Description Language) and MSC (Message Sequence Charts) are used for formal specifications and descriptions. Also, for behavioral modeling of object-oriented software systems, UML interaction diagrams (sequence or collaboration diagrams) and statechart diagrams are commonly used. Use cases can be conveniently refined using interaction diagrams, which in turn aid in recognizing class operations and associations and in building statechart specifications of object behaviour. The aim of this workshop is to build a shared understanding on the relation between scenarios and state machines and to gain insight on techniques and tools that may leverage from combining these approaches to behaviour modeling. In this workshop, we will discuss the usage of scenario-based approaches in software engineering. An emphasis area is the relation between scenarios and state-machines. Areas of interest of this one-day workshop include, but are not limited to the following three main discussion topics: 1) Models and notations (requirements for different application areas, shortcomings in current notations, new suggestions for models or notations, categorizations); 2) Algorithms (e.g., synthesizing state machines from scenarios, implied scenarios, generating scenarios from state machines, consistency checks); 3) Tools (tool support for the issues above, different application areas). Moreover, we will identify the limitations and shortcomings of current approaches and outline possible directions for future research in the domain. A related workshop (scenario-based roundtrip eng.) was organized at OOPSLA 2000.

An application developer’s primary task is to produce performant systems that meet their specifications. Formal methods techniques allow engineers to create models and implementations that have a high assurance of satisfying a specification. In this experience report, we take a model-based approach to software development that adds the assurance of formal methods to software construction while automating over 90% of the formal modeling. We discuss a software development methodology and two specific examples that illustrate how to integrate formal methods and their benefits into a traditional (testing-based) software development process.

Teaching an Advanced Maude-Based Formal Methods Course in Oslo

Situation-awareness is a desirable feature of application software systems in mobile computing environments. In this paper, we present an extended finite state machine model for the situation-aware mobile application software systems. In this model, each state represents an impromptu condition that a system is presented, and the state is characterized by the historical context record and the internal action record. Each state transition in the model represents a context input. The whole finite state machine models the dynamicity of the situation-aware application software system that adjusts its own behavior according to the situation changes. The situation-aware requirement is application-specific, and each situation-aware requirement is corresponding to an FSM. This model is useful in the mobile application software development: it can be used to verify the validness of the situation-aware requirement; it can be used to generate test cases that represent the situation changes a system may experience in a mobile environment.

UML is widely accepted and practiced in industries for modeling and design of software systems. Software requirements and design are very important parts of software development, which must be validated and verified before implementation. UML State Machine diagram is an important formalism to model the dynamics of the system. In this paper, a comparative study of the test case generation techniques from UML State Machine diagram has been done. This study is an attempt to find out the work that has already been done in this field and various aspects of UML state machines that have been considered for generating test cases. Finally, this paper presents a scope to generate test data for complex state machine involving concurrent states and events.

UML is widely accepted and practiced in industries for modeling and design of software systems. Software requirements and design are very important parts of software development. UML State Machine diagram is an important formalism to model the dynamic behavior of the system. In this paper, we present a new approach to generate compact and efficient Java code from complex state machine involving hierarchical-concurrent states; the proposed code can be used as a Java implementation pattern for automatic code generation for an object-oriented system. The main idea of our study is using Java Enum type with attributes for implementing complex state machines.

This article presents results from an evaluation of an online statistics lab as part of a foundations research methods course for master's-level social work students. The article discusses factors that contribute to an environment in social work that fosters attitudes of reluctance toward learning and teaching statistics in research methods courses. Students' evaluations (N = 25) suggest that implementing online statistics labs as a part of a foundations research methods course may help students form more positive attitudes toward statistics and improve their ability to read scholarly articles. Description of the course is provided, and challenges to implementation are discussed.

Formal methods are crucial in program specification and verification. Instead of building cases to test functionalities, formal methods specify functionalities as properties and mathematically prove them. Nevertheless, the applicability of formal methods is limited in most development processes due to the requirement of mathematical knowledge for developers. To promote the application of formal methods, we formulate formalism-driven development (FDD), which is an iterative and incremental development process that guides developers to adopt proper formal methods throughout the whole development lifespan. In FDD, system graphs, a variant of transition systems optimized for usability, are designed to model system structures and behaviors with representative properties. System graphs are built iteratively and incrementally via refinement. Properties of system graphs are specified in propositional and temporal logics and verified by model-checking techniques with interpretation over transition system. In addition, skeleton programs are generated based on system graphs and expose implementable interfaces for executing external algorithms and emitting observable effects. Furthermore, we present Seniz, a framework that practicalizes and automates FDD. In this paper, we explicate the concepts and taxonomy of FDD and discuss its practice.