Search

Critical embedded systems development is a complex and highly sensitive task. Model-driven engineering (MDE) intends to bridge the gaps between the different parts of this process: high-level requirements, design, implementation and verification, by promoting formalization of the various process artefacts as models. This paper focuses on the rigorous and flexible model-based specification and implementation of a part of the requirement language of an embedded code generator. It relies on the use of OCL integrated in a textual specification language as a means to formally specify graphical modeling languages such as Simulink and Scicos and their extensible sophisticated block libraries.

International audience; The specification of Modeling and Analysis of Real-time and Embedded Systems (MARTE) is an extension of UML in the domain of Real-Time and Embedded Systems. However, unified modeling of continuous and discrete variables in MARTE is still an unsolved problem for hybrid real-time system development. In this paper we propose an extended statechart, Hybrid MARTE statechart, for Modeling and Analyzing of Hybrid Real-time and Embedded systems. In Hybrid MARTE Statecharts, we unify the logical time and the chronometric time variables. The improvement of MARTE statechart is based on hybrid automata. Formal syntax and semantics of Hybrid MARTE statecharts is given based on labeled transition systems. At the end of this paper, a case study is given to show how to model the behavior of a Train Control System with Hybrid MARTE statecharts.

In this paper we present the specification and preliminary assessment of Casanova, a newly designed computer language which integrates knowledge about many areas of game development with the aim of simplifying the process of engineering a game. Casanova is designed as a fully-fledged language, as an extension language to F#, but also as a pervasive design pattern for game development.

How to implement software architecture to code according to formal specification is an important link within software development, for the quality of code has tremendous influence to the software quality. This paper we focus on finding out the inner relations and the transform mechanisms between object-Z specification and Java code, and propose some basic transform principles and general mechanisms. Further more, case study is used in illustrating and designing of the transform mechanisms.

In this thesis we specify the x86 instruction set architecture (ISA) by developing an abstract machine that models the behaviour of a modern computer with multiple x86 processors. Our model enables reasoning about low-level system software by providing formal interpretation of thousand pages of the processor vendor documentation written in informal prose. We show how to reduce the problem of ISA formalization to two simpler problems: memory model specification and instruction semantics specification. We solve the former problem by extending the classical Total Store Ordering memory model with caches, translation-lookaside buffers, memory fences, locks, and other features of the x86 processor. For the latter problem we design a new domain-specific language which makes instruction semantics specification readable and compact. In dieser Arbeit spezifizieren wir den x86-Befehlssatz durch die Definition einer abstrakten Maschine, die das Verhalten eines modernen Computers mit mehreren x86-Prozessoren modeliert. Unser Modell bietet eine formale Interpretation der Prozessorherstellerdokumentationen, die über Tausend Seiten von informellen Spezifikationen enthalten. Wir zeigen, wie das Problem der Befehlssatz-Formalisierung in zwei einfachere Probleme zerlegt werden kann: Spezifikation von dem Speichermodell und spezifikation von der Maschinenbefehlsemantik. Wir lösen das erste Problem durch die Erweiterung des klassischen “Total Store Ordering” Speichermodells mit Caches, Translation-Lookaside Buffers, Memory Fences und Locks. Um die Maschinenbefehlsemantikspezifikation lesbar und kompakt zu machen, entwerfen wir ein neue domänenspezifische Sprache.

The challenges of pervasive and mobile computing environments, which are highly dynamic and unpredictable, have motivated the development of self-adaptive software systems. Although noteworthy successes have been achieved on many fronts, the construction of such systems remains significantly more challenging than traditional systems. We argue this is partially because researchers and practitioners have been struggling with the lack of a precise vocabulary for describing and reasoning about the key architectural characteristics of self-adaptive systems. Further exacerbating the situation is the fact that existing frameworks and guidelines do not provide an encompassing perspective of the different types of concerns in this setting. In this article, we present a comprehensive reference model, entitled FOrmal Reference Model for Self-adaptation (FORMS), that targets both issues. FORMS provides rigor in the manner such systems can be described and reasoned about. It consists of a small number of formally specified modeling elements that correspond to the key concerns in the design of self-adaptive software systems, and a set of relationships that guide their composition. We demonstrate FORMS's ability to precisely describe and reason about the architectural characteristics of distributed self-adaptive software systems through its application to several existing systems. FORMS's expressive power gives it a potential for documenting reusable architectural solutions (e.g., architectural patterns) to commonly encountered problems in this area. © 2012 ACM. ispartof: ACM Transactions on Autonomous and Adaptive Systems vol:7 issue:1 pages:1-61 status: published

Formal methods aim to build correct software by eliminating both requirements and design flaws. Still, specification languages have a somewhat bad reputation in the software engineering community for being too heavy and difficult to use. This is mainly due to the use of complex mathematical notations often requiring experts in the field. We rely on our experience to show that writing formal specifications can be easier if a specification language is used as a high-level programming language, where the distinction between a specification language and a programming language is somewhat blurred. The Autonomic System Specification Language (ASSL) is a declarative specification language for autonomic systems with well-defined semantics. It implements modern concepts and constructs such as inheritance, modularity, type system, and parameterization. Specifications written in ASSL present a view of the system under consideration, where specification and design are intertwined.

We present an approach to the formal specification and automatic analysis of business processes under authorization constraints based on the action language $\cal{C}$. The use of $\cal{C}$ allows for a natural and concise modeling of the business process and the associated security policy and for the automatic analysis of the resulting specification by using the Causal Calculator (CCALC). Our approach improves upon previous work by greatly simplifying the specification step while retaining the ability to perform a fully automatic analysis. To illustrate the effectiveness of the approach we describe its application to a version of a business process taken from the banking domain and use CCALC to determine resource allocation plans complying with the security policy.

In this work, an improvement of the traditional design methodology is proposed. The major change is the use of semi-formal specification for the implementation and the establishment of properties for the formal verification. From semi-formal specification, assertions were written using Property Specification Language (PSL) for an alignment circuit. Finally, a set of properties for the verification of this module were established and proved using two verification tools. Our statistics proved that, considerable design time was saved, and the number of versions was low.

This short communication is a response to [MuS93] investigating their ACS system specification. The main point in this paper is that executing specifications can be used as a feasible way of validating them. It is essential to have tool support which enables one to write a generally not executable specification, and then prototype (parts of) it directly in the specification language, without translating it into some other prototyping language.

Aslan is an easy to use, widely available, formal specification language suitable for use in software engineering classes. An Aslan specification consists of assertions about the initial states of a system, critical correctness requirements, and transitions from one system state to another. Aslan allows specifiers to define formally a sequence of increasingly more detailed levels of abstraction. The Aslan Language Processor (ALP) is a compiler taking formal specifications written in Aslan and producing first‐order predicate calculus assertions. The proof of these assertions ensures that the system being specified meets its critical correctness criteria. This article describes the Aslan language and its use in an undergraduate software engineering course.

Formal methods are mathematically-based techniques for specifying, developing and verifying a component or system, in order to increase the confidence regarding to the reliability and robustness of the target. Formal methods can be used at different levels with different techniques, and one approach is to use model-oriented formal languages such as VDM languages in writing specifications. During model development, we can test executable specifications in VDM-SL and VDM++. In a lightweight formal approach, we test formal specifications to increase our confidence as we do in implementing software codes with conventional programming languages. While the specific level of rigor depends on the aim of the project, millions of tests may be conducted in developing highly reliable mission-critical software in a light-weight formal approach. In this paper, we introduce our approach to supporting large volume of testing for executable formal specifications using Hadoop, an implementation of MapReduce programming model. We are able to automatically distribute interpretation of specifications in VDM languages by using Hadoop. We also apply a property-based data-driven testing tool, Quick Check, over MapReduce so that specification can be checked with thousands of tests by using formally described pre/post conditions and invariant functions. As an advanced property-based data-driven testing approach, we also discuss model-based testing. We observed scalable performance in testing large amount of data for executable specifications in our approaches.

This paper presents a formal specification of Mondex, an electronic purse, using SAM. Mondex is the first pilot project for the 6th Grand Challenge to develop an integrated, automated toolset that developers can use to establish the correctness of software. Several research groups around the world have applied different formal methods in specifying and analyzing the Mondex smart card since 2006. Our specification is unique, which uses a software architecture model integrating high level Petri nets and temporal logic; thus contributes to the world wide effort in tackling one of the grand challenges in computer sciences.

Model checking (Clarke et al. 1999; Holzmann 2003b; Lamport 2002a) is a flexible and powerful technique for verifying systems formally with automated tools. In principle, it makes this task easy for the user: given a formal system description and certain conditions to be satisfied, the automated checker either confirms that the system satisfies the conditions, or provides a counterexample.

The model checker Uppaal is used to formally model and analyze parts of Zeroconf, a protocol for dynamic configuration of IPv4 link-local addresses that has been defined in RFC 3927 of the IETF. Our goal has been to construct a model that (a) is easy to understand by engineers, (b) comes as close as possible to the informal text (for each transition in the model there should be a corresponding piece of text in the RFC), and (c) may serve as a basis for formal verification. Our modeling efforts revealed several errors (or at least ambiguities) in the RFC that no one else spotted before. We present two proofs of the mutual exclusion property for Zeroconf (for an arbitrary number of hosts and IP addresses): a manual, operational proof, and a proof that combines model checking with the application of a new abstraction relation that is compositional with respect to committed locations. The model checking problem has been solved using Uppaal and the abstractions have been checked by hand.

The automatic generation of formal specifications from requirements suppresses the complexity of formal models manual creation and reveals the immediate benefits of its usage, such as the possibility to carry out refinements, and property verification, which contributes to project cost reduction and quality improvement. This paper proposes a Controlled Natural Language (CNL), a subset of English, used to write use case specifications according to a template. From these use cases a complete strategy and tools enable the generation of process algebraic formal models in the CSP notation. We define templates that represent requirements at different levels of abstraction, capturing different views of the system behavior. Moreover, a refinement notion is defined to connect the generated CSP models through an event mapping relation between abstract and concrete models. This notion is further applied to detail use case specifications and to automate its execution.

UML has been the de facto specification language for software design, using the object-oriented approach in particular. However, components in UML are mostly presented as graphical diagrams that are informal and often lead to different interpretations. Although formal methods exist for UML specification, most of which are semi-formal or rely on another high-level language to describe the UML components. In this paper, we give a formal specification for the core UML, the class and state diagrams using the basic predicate logic and set notations. The goal is to provide a precise definition for object-oriented software.

The goal of our work is to analyse and develop the integration of client-oriented requirements engineering techniques with formal methods. In particular, we integrate the requirements baseline with the RAISE method. We proposed a three-step process to derive an initial formal specification of a domain, starting from two models of the requirements baseline: the language extended lexicon and the scenario model. In this paper, we focus on the derivation of functions. We present heuristics to identify and model the functions of a formal specification written in the RAISE specification language, using natural language descriptions provided by the scenario model and the language extended lexicon.

The goal of the research on which the paper is based was to specify formally a persistent object management system and to implement a part of the specification in the form of a prototype. The prototype is called the persistent object storage manager (POSM). The prototype was implemented in C++ using the IBM OS/2 operating system. POSM is formally specified in the paper. The data model used in POSM is rigorously defined using the Z notation. The operations of POSM and its state space are also specified in Z notation. Example schemas for the operations of the node management component of the prototype are presented. Z notation is justified in the paper and the benefits of using Z in the research are discussed.

A tutorial-like overview on formal methods for the specification of reactive systems is given. State transition systems such as ATNs, statecharts, and SDL are discussed. Petri nets and logic-based languages are introduced as alternatives; examples show their respective applicability. Programming-oriented approaches such as ESTEREL, CSP, or CCS are depicted. Finally, the different principles are compared.

VESAR is a tool for the specification and verification of distributed systems described in the ISO Estelle language. The originality of VESAR relies in its powerful simulation and verification capabilities: it supports interactive and random simulation techniques as well as formal verification based either on reachability analysis or “on the fly” methods. The principles of the tool are described, illustrated with examples, and performance measurements are given.

This paper presents a design technique for digital circuits at register-transfer level (RTL). The two most important notions within the design trajectory are the formal specification of the circuit and the formal verification of an implementation, that a designer comes up with, against this specification. A mathematical description formalism is presented that can be used to describe both the specification and the implementation of RTL circuits and, furthermore, to formally verify the implementation against the specification. As an example, the design of an n-th order infinite impulse response (IIR) filter is presented. It is shown that several different implementations are possible and that the trade-off between speed and chip area can be made very precisely.

It is shown how design time testing can be used in conjunction with formal specification. Emphasis is placed on the benefits of using an executable specification language OBJ, of having a design controlled by requirements specification, and of adherence to the regularity and uniformity hypotheses in dynamic validation. It is shown that such an approach offers positive benefits by providing early design validation and a controlled, disciplined design process. >

Agents interact in the context of a society to exchange knowledge, to cooperate and to coordinate their activities. A standard approach is to describe these interactions as conversations specified by means of interaction protocols (IPs). The set of conversations in which an agent can participate defines its communication interface. Therefore, the standardised sets of IPs that specify these conversations can be viewed as Agent Interface Definitions (AID), just as procedure and function definitions make up programming interfaces (API) in other programming paradigms. This paper presents the abstract syntax and semantics of ACSL: a new formal specification language that can clearly and precisely describe these interfaces so that they can be consumed both by designers and programmers (generally using CASE tools) and automatically by actual agents during interaction. This language fills a gap in the development of agent interface definition languages (AIDL). The paper focuses particularly on the newest features of the language, like (1) protocol composition, (2) protocol exceptions related to the reception of out-of-sequence messages or timeout expirations, (3) compensation protocols that adapt the classical concept of transaction to the autonomy and rationality of agents and, finally, (4) specification of message correlation and causality.

It is well accepted that formal specifications can be useful bases for software testing; some pioneering papers come back to the seventies. Given a specification and a system under test, any testing activity is, explicitly or not, based on a satisfaction relation (often called conformance relation): does the system under test satisfy the specification? Tests are derived from the specification on the basis of the satisfaction relation, and often on the basis of some additional knowledge of the system under test and of its operational environment called testability hypothesis. The verdict about the success or not of a test execution depends on the observations that can be made on the system under test, and it is based on the satisfaction relation.

Mondex, an electronic purse, is the first pilot project of the software verification Grand Challenge to establish the correctness of software. Several research groups around the world have applied different formal methods in specifying and analyzing the Mondex since 2006. In this paper, we present a method to analyze the Sam specification of Mondex using model checking. Our specification uses Sam that integrates high level Petri nets and temporal logic. Our analysis method translates the SAM Mondex specification into a behavior preserving PROMELA program and uses SPIN to model check the resulting PROMELA program. Our results and experiences are discussed, which contributes to the world wide effort in developing a verified software repository.

This paper presents, to the best of our knowledge, the first formal specification of the application security model defined by the Mobile Information Device Profile 2.0 for Java 2 Micro Edition. The specification, which has been formalized in Coq, provides an abstract representation of the state of a device and the security-related events that allows to reason about the security properties of the platform where the model is deployed. We state and sketch the proof of some desirable properties of the security model. Although the abstract specification is not executable, we describe a refinement methodology that leads to an executable prototype.

The Java security package allows a programmer to add security features to Java applications. Although the package provides a complex application programming interface (API), its informal description, e.g., Javadoc comments, is often ambiguous or imprecise. Nonetheless, the security of an application can be compromised if the package is used without a concrete understanding of the precise behavior of the API classes and interfaces, which can be attained via formal specification. In this paper, we present our experiences in formally specifying the Java security package in JML, a formal behavior interface specification language for Java. We illustrate portions of our JML specifications and discuss the lessons that we learned, from this specification effort, about specification patterns and the effectiveness of JML. Our specifications are not only a precise document for the API but also provide a foundation for formally reasoning and verifying the security aspects of applications. We believe that our specification techniques and patterns can be used to specify other Java packages and frameworks.

This chapter introduces our approaches to formal specification of the structural and behavioral aspects of Design patterns. We investigate the logic-based formalisms in our specification methods and demonstrate the applications of these methods in examples. Our formal specifications methods not only help for rigorous, precise, and unambiguous descriptions of Design patterns, but also allow us to verify the consistencies of Design pattern applications and compositions.

In this paper we present the AgentComponent (AC) approach under formal aspects. A multi agent system (MAS) is composed of AC instances, where each AC instance consists of a knowledge base, storing the beliefs, of slots, storing the communication partners, of a set of ontologies, and of so-called ProcessComponents (PC) representing the behaviours of an AC instance. An AC is a generic component that can be reused (instantiated ACs) and parametrized by customizing the communication partners (slots), the ontologies, the knowledge and the behaviours of an AC instance. The focus of this paper is to introduce the basic AC approach and to define a formal specification using the Object Constraint Language (OCL) for this approach. In the first part we present an informal description of the AC approach and show how to construct a component-based MAS by a simple example. The second part of this paper presents a metamodel for the AC approach and provides a formal specification for the services of the generic AC.

The requirements capture of complex systems requires powerful mechanisms for specifying system state, structure and interactive behaviors. Integrated formal specification languages are well suited for presenting more complete and coherent requirement models for complex systems. Given an integrated model, one can project it into multiple views for specialized analysis. Message Sequence Charts (MSCs) is a popular graphical notation for presenting interactive viewpoints of a system. In this paper, we investigate the semantic based transformation from an integrated formal specification language TCOZ to MSCs. An automated tool has also been developed for generating MSCs from TCOZ models. Furthermore, by inserting operation constraints (as assertions) into the generated MSCs, system testing requirements can be obtained.

A formal definition of the data dictionary for an extended entity-relationship data model is described. Extensions should allow greater semantic expressiveness and more precise modelling, while retaining ease of use, intuitiveness and flexibility. Basic concepts of the model are formally defined using the Z notation, and an enhanced graphical notation is also proposed. Furthermore, a simple transformation of the extended ER schema to a relational one is formally described as well.

The task of software production is to build software systems which are to fulfil certain requirements. For years the approach has been to build up by trial and error a program which, having satisfied carefully prepared test data, offers a plausible solution to the problem. But is it correct? Even for toy examples this is not obvious. In particular, it is often not even clear whether the original problem has been fully understood. The reason for this dilemma is that the transition from the informal problem statement to the final program is too big to be intellectually managable. To master these problems, we advocate a software development method where the whole process is split into smaller steps by introducing formal specifications for (parts of) the problem and then stepwisely deriving efficient programs by correctness-preserving transformations.

Formal specifications of software components are critical to software development. Several types of formal or semi-formal methods are commonly used for software specification, such as specification languages, graphic diagrams, algebraic descriptions, and stream functions. Each of these methods addresses the specification problem from a different view point and has its own strengthens and weaknesses. In this paper, we use the stream function approach to formally specify a particular software component, bounded buffer. Based on the specification, a state transition machine is built as an implementation of the bounded queue.

Logical representation of an expressive human-computer ensemble system by N∑-labeled calculus together with experimental results are presented.

Specifying and analyzing timing properties is a critical but error-prone aspect of developing many modern software systems. In this paper, we propose a new specification language and analysis framework for expressing and analyzing timing behaviors of complex software systems. Our framework has the following significant benefits: a) it is expressive, b) it supports trace analysis and simulation of timing behaviors, c) allows for verification of properties of specification, and d) checks for common usage errors of timing constructs. The language constructs for timing were chosen to be very flexible, suitable for expressing different kinds of timing behaviors, and are inspired from timing constructs used in previous languages like SDL. We define the formal semantics of our language using a real-time rewrite theory. Since real-time rewrite theories are executable in Real-Time Maude, our framework supports trace analysis and simulation of timing behavior for specifications. Furthermore, the timed model checker for Real-Time Maude can be readily used for analyzing and verifying various real-time properties of the specifications. Finally, to prevent misuses of timing constructs that can be made possible due to their flexibility, we develop abstract interpretation based static analysis tools that check for common usage errors. We believe that our framework, with the above benefits, provides a significant step forward in facilitating the use of formal tools for specification and analysis of timing behaviors in software development.

Software patterns are recognized as an ideal documentation of expert knowledge in software design and development. However, its formal model and rigorous semantics have never been generalized and matured. The traditional UML specification and some formal specification attempts cannot capture the essence of generic patterns precisely, understandably, and essentially. A generic model of patterns is presented in this paper using Real-Time Process Algebra (RTPA). The formal model of patterns are more readable and highly generic, which can be used as the meta model to denote any design patterns deductively, and can be translated into code in programming languages by supporting tools. This work reveals that a pattern is a highly complicated and dynamic structure of software design encapsulation, because of its complex and flexible internal associations between multiple abstract classes and instantiations. The generic model of patterns is not only applicable to existing patterns' description and comprehension, but also useful for future patterns' identification and formalization.

This paper presents a formal specification of the Assurance Point (AP) web service composition model. The AP model provides a flexible way of checking constraints and responding to execution errors in service composition. An AP is a combined logical and physical checkpoint, providing an execution milestone that stores critical data and interacts with integration rules (IRs) to alter program flow and to invoke different forms of recovery depending on the execution status. In this paper, the execution and recovery semantics of assurance points have been fully defined in the context of if-else, parallel, and loop control structures. The activities and complex control structures of the AP model have been formalized and tested in the Yet Another Workflow Language (YAWL) engine. By doing so, the correctness of the execution and recovery semantics in the AP model has been verified, demonstrating that YAWL nets of the AP model satisfy the soundness property. Different from existing web service composition models, the AP model presented by this research provides multiple levels of protection against service execution failure with a combination of forward and backward recovery techniques.

This paper reports a formal specification language SLABS for developing multi-agent systems. One of the most appealing features of agent technology is its natural way to modularise complex systems in terms of multiple interacting autonomous components. This feature is supported by the language facility castes in the formal specification language SLABS for modular and composable specification of multi-agent systems.

An exercise in formal specification and design of an asynchronous controller that leads to the CMOS implementation is presented. In this paper we focus on the formal specification of the controller by using communication sequential process, a tool based on Hoare's CSP. We also present the procedure, based on Martin's synthesis method, used to formally derive the preliminary design of the asynchronous traffic light controller. The formal specification and circuit implementation are formally verified with a verification tool package STTools, capable of model checking and simulating programs.

A technique is proposed for semiformal specification. The authors distinguish two stages of formalization: data modeling and specification of operations. For each stage, the system provides a distinct tool. It consists of a graphical component called the MER diagram and a textual component called the KFD. Through an example, the authors present a knowledge assisted transformation process that can generate a formal specification from the given semiformal specification. The formal specification language chosen is VDM. The MER diagrams and KFDs form an input to the transformation described. >

Automatic generation of test cases from formal specification is a very promising way both to give a rationale for deciding the scope of testing and to reduce the time for test design and coding. In order to achieve this purpose, formal specification-based methods must solve the problem of executable test script generation from abstract test cases and automatic verdict assignment. This question requires calculating oracles, mapping between the abstract and concrete representations and monitoring test execution. In this paper, we present an effective use in the testing process of automatically generated test suites on an industrial application of Java Card Transaction Mechanism. Abstract test cases are synthesized from a B formal specification using a boundary value approach. From the abstract test cases, executable scripts are generated using execution context pattern and representation mappings. This is fully supported by a tool-set, called BZ-Testing-Tools. On the basis of this Java Card case study, we describe the difficulties that arose and present some generic solutions embedded in the BZ-Testing-Tools environment.

This paper describes a new idea of rapid protocol implementation starting from its formal specification, namely to generate Unix STREAMS modules. We have exercised this idea using Estelle formal specification technique. The generator was written for Linux system. The paper demonstrates how the semantic problems were resolved and gives some conclusions from generations we have performed.

The LOTOS constraint-oriented style allows the design of well-structured, implementation-independent specifications of distributed systems. As an example, we provide a small, didactically-oriented specification of a simple telephone service. The design of the specification is based on three types of constraints, i.e. global constraints, end-to-end constraints and local constraints. The structure of the specification, as well as its design method, are described in some detail. We conclude with a discussion of the specification debugging method.

OWL-S is one of the leading standards for the description of Web services on the Semantic Web. However its composite process specification is lack of precise mathematic semantic which leads the process specification described in OWL-S is only a semi-formal one, and canpsilat do reasoning and formal analysis in this part. This paper proposes a formal framework for enriching composite process description with rewriting logic that facilitates compositional reasoning about services in OWL-S composite process model. The technique is based on Maude language, a rewriting logic based methodology in which formal modeling and analysis can be used from the earliest phases of system design to uncover many errors and inconsistencies in composition, and to reach high assurance for critical components with runtime verification of OWL-S composite process specification.

ISBN: 978-1-60558-231-3; International audience; We describe an enhanced generic model for Networks-on-Chip (NoCs), implemented in the executable logic of the ACL2 theorem prover. The model is meant for serving as a formal reference for the specification, validation, and simulation at the initial design phase. Instantiated on a specific NoC, the model may be used for formal proofs and for simulation. The methodology is illustrated on HERMES.

This paper is an overview of a generic formal description allowing to encode multi-modal interactive systems, their behaviors and properties.

This paper outlines a Case Study of the application of one approach to the Formal Specification of Parallel Object Oriented Systems to a Process Modelling language. The purpose was to both check whether such an approach was feasible and useful and also to give insight into the ongoing design of such Process Modelling Languages.