Manuel I. Capel

Compositional Model-Checking Verification of Critical Systems

Ensuring the correctness of Critical Systems (CS) becomes more complex if we consider that their behaviour is the result of the concurrent execution of many components. Furthermore, any automaton–based representation of concurrent components yields an explosion in the number of states, thus limiting the use of Model–Checking (MC) verification techniques in practice. This article presents a compositional verification approach, which is formally supported by state–of–the–art MC tools. To facilitate and guarantee the verification of large CS, the proposed approach integrates MEDISTAM–RT (Spanish acronym of Method for System Design based on Analytic Transformation of Real–Time Models), CCTL temporal logic as the property specification formal language, and the formal language CSP+T, used to formally describe a model of the system to be verified. To show a practical use of the proposed approach, a critical part of a realistic industry project related to mobile phone communications is discussed.

On-the-fly model checking from interval logic specifications

Future Interval Logic (FIL) and its intuitive graphical representation, Graphical Interval Logic (GIL), can be used as the formal description language of model checking tools to verify hardware and software systems. An interval clearly defines the temporal scope over which properties are evaluated. From interval formulas specifying the temporal behavior of a system we obtain their semantically equivalent Büchi automata, but in such a way that our algorithm can be integrated into an on-the-fly model checking tool. As the property automaton can be generated simultaneously with, and guided by, the construction of the system model, it is possible to detect that a property is violated by constructing only a part of both state spaces. This is the first time that this kind of algorithm has been developed for an interval logic. The relations with other automated verification techniques from linear temporal logic are also discussed. Moreover, an appendix with proof of the correctness of our algorithm is included.

Automating the Transformation from BPMN Models to CSP+T Specifications

The complexity of modern Business Process Modelling (BPM) together with the absence of the appropriate validation tools is the main reason for the costly and non- evolutionary characteristics of these models. Temporal constructs of Extended Business Process Model and Notation (EBPMN) semantics are disambiguated here by using Communicating Sequential Processes+Time (CSP+T) process calculus, which adds new constructions to timed BPMN modelling entities for non-functional requirements specification. Our objective is to facilitate the description of a business process model as a collection of verified software components, thereby advancing to their complete verification with state-of-the-art model checking tools. One real-life example, Customer Relationship Management (CRM) modelled as a correct business task model is discussed to demonstrate the applicability of the verification approach.

Automata generation for on-the-fly automatic verification using formulas of an interval logic

This paper looks at the application of Future Interval Logic (FIL) to the automatic verification of temporal logic interval formulas. An algorithm is developed to construct a Buchi automaton which is semantically equivalent to a system specification described by means of FIL formulas. The algorithm is intended to be used within the framework of on-the-fly model checking methods as a way of solving the problem of verifying reactive systems. A set of expansion rules is obtained from a formally defined reduction relation and from the FIL semantics. The algorithm uses these rules to reduce a formula into simpler ones, which are satisfied by the states of the automaton run. The acceptance conditions are determined by a new procedure. Finally, some experimental results obtained with it are presented.

Choreography Modeling Compliance for Timed Business Models

Business Process Modeling (BPM) is a conceptual activity for embodying the functioning and complex structure of any enterprise’s business processes, so that these can be then analyzed and improved. A BP can be understood as a set of related, structured, interacting services driven by a choreography that is capable of giving complex functionality to customers. General choreographies of BP cannot be verified, specially timed choreographies, because implementations scarcely show the same behavior than the one initially specified according to business rules. We therefore propose here a formal semantics for a subset of BPMN, in order to check if a given choreography is realizable. This includes formalization of behavioral and temporal aspects of BPMN. A set of transformation rules for choreography diagrams into a timed process algebra is given. Therefore, we obtain an easy verification approach for choreography implementation models based on model–checking tools. In this way we can obtain advantage of the strengths that a formalization of behavioral and temporal aspects of BPMN will bring about, at design and implementation stages, to any model of interest.

Automatic Compositional Verification of Business Processes

Nowadays the Business Process Modelling Notation (BPMN) has become a standard to provide a notation readily understandable by all business process (BP) stakeholders when it comes to carrying out the Business Process Modelling (BPM) activity. In this paper, we present a new Formal Compositional Verification Approach (FCVA), based on the Model–Checking verification technique for software, integrated with a formal software design method called MEDISTAM–RT. Both are used to facilitate the development of the Task Model (TM) associated to a BP design. MEDISTAM–RT uses UML–RT as its graphical modelling notation and CSP+T formal specification language for temporal annotations. The application of FCVA is aimed at guaranteeing the correctness of the TM with respect to initial property specification derived from the BP rules. One instance of a BPM enterprise–project related to the Customer Relationship Management (CRM) business is discussed in order to show a practical use of our proposal.

A Set of Patterns for Concurrent and Parallel Programming Teaching

The use of key parallel-programming patterns has proved to be extremely helpful for mastering difficult concurrent and parallel programming concepts and the associated syntactical constructs. The method suggested here consists of a substantial change of more traditional teaching and learning approaches to teach programming. According to our approach, students are first introduced to concurrency problems through a selected set of preliminar program code-patterns. Each pattern also has a series of tests with selected samples to enable students to discover the most common cases that cause problems and then the solutions to be applied. In addition, this paper presents the results obtained from an informal assessment realized by the students of a course on concurrent and real-time programming that belongs to the computer engineering (CE) degree. The obtained results show that students feel now to be more actively involved in lectures, practical lessons, and thus students make better use of their time and gain a better understanding of concurrency topics that would not have been considered possible before the proposed method was implemented at our University.

Teaching Software Transactional Memory in Concurrency Courses with Clojure and Java

In the field of concurrency and parallelism, it is known that the use of lock-based synchronization mechanisms limits the programming efficiency of concurrent applications and reveals problems in thread synchronization. Software Transactional Memory (STM) is a consolidated concurrency control mechanism that may be considered as an alternative to lock-based constructs for programming critical software, although STM is still not fully accepted as a programming model for the industry. It is our opinion that STM programming must be more emphasized in undergraduate courses on concurrency and parallelism. In this paper we propose an academic experience regarding the introduction of STM programming in concurrency courses by using the Clojure language as the common vehicle for teaching Concurrent Programming. Java, the most popular and extended programming language for teaching concurrency, becomes a second language in our course, and thus our students can take advantage of Clojure API which is defined in Java in order to simplify the development of programming, lectures and assignments.

Design and implementation of communication patterns using parallel objects

Within an environment of parallel objects, an approach of structured parallel programming with the paradigm of object-orientation is presented here. The proposal includes a programming method based on high level parallel compositions or HLPCs (CPANs in Spanish). C++ classes and CPANs are syntactically alike and differ in concurrency mechanisms. Different parallel programming patterns, synchronisation operations and new constructs like futures have been discussed throughout the paper. To achieve software-reusability, a series of predefined patterns that use object-oriented programming concepts have been presented. Concurrency related constraints on process synchronisation are set by only resorting to maxpar, mutex, sync primitives in the application code. By means of the method application, the implementation of commonly used parallel communication patterns is explained to finally present a library of classes for C++ applications that use POSIX threads.

Checking Critical Software Systems: A Formal Proposal

As a contribution to the specification and verification of critical software systems, this article presents a formal proposal for compositional verification, which uses model checking technique and integrates a modelling infrastructure that propitiates the target system decomposition into separate components aimed at being individually specified and verified. Our goal with this proposal is to provide an infrastructure for developing and verifying critical software systems by fostering extensibility and modifiability of the software. In this way, validated components can be integrated into large computer programs readily. The compositional verification approach guarantees the correctness of the entire system during its execution. Also, is discussed a practical application of our proposal to a realistic industry project related to mobile phone communication.