Search

Explains context-aware Abstract State Machines (ASMs). It shows how the ASM parameterization mechanism permits a) to gently manage a rather general form of partitioning of states and distributed computations, and b) to effectively separate the descriptions of system and of environment features. Numerous programming patterns, communication patterns, and some common control flow schemes are modeled to illustrate the power of ASM parameterization.

Illustrates the usage of Abstract State Machines (ASMs) in the area of business process modeling (BPM). A commercially used web service modeling pattern (Virtual Provider) is defined. A BPM-specific class of ASM net diagrams is introduced and shown to support IBM’s Guard-State-Milestone approach and the central communication concept of the Subject-Oriented BPM method. The focus is on showing how ASM refinements offer a seamless integratation of data-oriented (textual) and control-flow oriented (graphical) modeling means.

(Introduction) explains why modeling cannot be achieved by programming alone. It describes the role of models for a) building reliable software-intensive systems, and for b) intellectually managing their complexity. It explains the two fundamental conceptual features - abstraction and refinement - by which Abstract State Machines (ASMs), a pseudo-code form of models with a rigorously defined behavior, permit to realize this role. (Introduction) explains why modeling cannot be achieved by programming alone. It describes the role of models for a) building reliable software-intensive systems, and for b) intellectually managing their complexity. It explains the two fundamental conceptual features - abstraction and refinement - by which Abstract State Machines (ASMs), a pseudo-code form of models with a rigorously defined behavior, permit to realize this role.

Provides a detailed mathematical definition of the syntax and the semantics of basic and concurrent Abstract State Machines (ASMs).

Defines a high-level model for the CoreASM interpreter, a tool which has been developed for the computer execution of Abstract State Machine (ASM) models. Also a debugger to debug CoreASM models is specified. Both definitions are given by basic ASM models.

Introduces stepwise the seven basic constructs used to model single-agent systems by Abstract State Machines (ASMs). It starts from scratch and is focussed on the central role of the ASM abstraction and refinement concept. Via small control system examples, it is explained how to use those constructs a) to build abstract models for such systems, and b) to refine them in a controllable manner to executable code. It is illustrated how ASMs support reliable requirements capture, controlled reuse of models, integration of data and control features, separation of normal behavior from error handling, and componentwise construction.

Extends the language of single-agent Abstract State Machines (ASMs) for modeling concurrent and/or communicating processes. It explains how to pass from synchronous to asynchronous process models and illustrates the role of model validation for concurrent systems (exploiting the executability of ASMs). Monitoring of asynchronous process networks is used as example for the application of communicating ASMs as modeling instrument.

Modelling business processes in general is a complex endeavour, as many different aspects such as the control flow, the management of data, event and message handling, actors and interaction, exception handling, etc. have to be taken into account, all of which require different models. This paper focuses on the horizontal integration of models for control flow, message flow, event handling, interaction, actors, data and exception handling. The method is based on Abstract State Machines (ASMs), which are used to formally define the semantics of each of the individual models. Throughout the process rigorous quality assurance methods will be applied.

The Function Blocks Architecture of the IEC 61499 standard is an executable component model for distributed embedded control systems combining block-diagrams and state machines. The standard aims at the portability of control applications that is however hampered by ambiguities in its execution semantics descriptions. In recent years several execution models have been implemented in different software tools that generate mutually incompatible code.

This paper gives an overview over the development of a formally verified file system for flash memory. We describe our approach that is based on Abstract State Machines and incremental modular refinement. Some of the important intermediate levels and the features they introduce are given. We report on the verification challenges addressed so far, and point to open problems and future work. We furthermore draw preliminary conclusions on the methodology and the required tool support.

With the paradigm of aspect orientation, a developer is able to separate the code of so-called cross-cutting concerns from the rest of the program logic. This possibility is useful for formal specifications, too. For example, security aspects can be separated from the rest of the specification. Another use case for aspect orientation in specifications is the extension of specifications without touching the original ones. The definition of formal semantics for UML profiles without changing the original UML specification is an example for this application. This paper describes the implementation of the aspect oriented approach in Abstract State Machines. We introduce an aspect language with its syntax and formal semantics. It allows for specifying pointcuts where an original specification is augmented with aspect specification. Besides the general overview of this language extension, some ASM specific features of the realization are depicted in detail.

We describe and formalize a compositional, contract-based submachine refinement for a variant of Abstract State Machines. We motivate the approach by models of the Flash file system case study, where it is infeasible to refine a complete machine as a whole.

We describe WebASM, a web-based environment that embeds the CoreASM execution engine in a web page. WebASM provides several advantages to specification writers: 1 complex behaviour expressed via ASM can be made visible by using the full power of the web-based presentation layer; 2 ASM specifications can be edited and run interactively via any web browser; 3 the full CoreASM environment is made available via zero-install deployment, thus eliminating a major barrier to the adoption of the language. In this paper, we briefly outline the technicalities of the approach, present an example, and survey possible applications of WebASM.

Situation Analysis is critical for dynamic decision-making in responding to real-world situations. The complex and intricate nature of situation analysis processes calls for evolutionary modeling and formal engineering methods that facilitate experimental validation of abstract mathematical descriptions to link the essential design aspects with rapid prototyping in early development phases. For the transition from abstract concepts and requirements to precise specifications to high level design of situation analysis systems, we derive here a generic ASM ground model as a framework for defining the precise meaning of fundamental situation analysis concepts applicable to different application domain models.

This paper shows how to use multi-agent Abstract State Machines to specify self-adaptive behavior in a decentralized adaptation control system. A traffic monitoring system is taken as case study.

We define a programming language independent transaction controller and an operator which when applied to concurrent programs with shared locations turns their behavior with respect to some abstract termination criterion into a transactional behavior. We prove the correctness property that concurrent runs under the transaction controller are serialisable. We specify the transaction controller TaCtl and the operator TA in terms of Abstract State Machines. This makes TaCtl applicable to a wide range of programs and in particular provides the possibility to use it as a plug-in when specifying concurrent system components in terms of Abstract State Machines.

In our former work we have given a high-level formal model of a cloud service architecture in terms of a novel formal method approach which combines the advantages of the mathematically well-founded software engineering method called abstract state machines and of the calculus of mobile agents called ambient calculus. This paper presents an extension for this cloud model which enables client-to-client interaction in an almost direct way, so that the involvement of cloud services is transparent to the users. The discussed solution for transparent use of services is a kind of switching service, where registered cloud users communicate with each other, and the only role the cloud plays is to switch resources from one client to another. We also show in an example at the end of this paper how our novel client-to-client interaction mechanism can be utilized for the development of the anonymously accessible cloud services.

The Abstract State Machine (ASM) formalism has proved an effective and durable foundation for the formal semantics of SDL. The distributed ASMs that underpin the SDL semantics are defined in terms of agents that execute ASM programs concurrently, acting on partial views of a global state. The discrete identities of successive global states are ensured by allowing input from the external world only between steps, and by having all agents refer to an external global time. But distributed systems comprising independent agents do not have a natural global time. Nor do they have natural global states. This paper takes well-known concepts from relativity and applies them to ASMs. The spacetime in which an ASM exists and moves is defined, and some properties that must be preserved by transformations of the frame of reference of an ASM are identified. Practical implications of this approach are explored through reservation and web service examples.

Traditional S-BPM successfully focuses on standardized business processes which are performed according to a fixed predefined process model. Yet a substantial share of business processes is difficult to predict with exceptions to the core processes occurring frequently.

Developing complex critical software should require proper validation with regards to requirements as well as showing a high level of certainty on correctness of the resulting system. While formal methods (FM) have a large potential to address these two challenges, their current Industry adoption is still hampered by a number of hurdles of technical and organizational natures. Furthermore, many misconceptions (myths) about FM remain deeply anchored in Industry. To help to bring down these hurdles and myths, this paper presents evidence that FM can be successfully used in Industry. The evidence repository follows two strategy to present its content. First, a company-specific approach is used where success stories describe how a given company deployed FM in one or several of its development projects. Second, a more general approach identifies general questions of interest (FAQ) to many companies in various Industry sectors. Success stories and FAQs are made available using a public collaborative wiki-based website open to external contributions ( http://www.fm4industry.org ).

This chapter introduces the four-year DEPLOY (Industrial Deployment of Advanced System Engineering Methods for High Productivity and Dependability) project to overview the context in which industrial deployment was conducted and explain how it was organised and managed.

In this paper we focus on filling the gap between the formal Business Process Model and Notation (BPMN) Abstract State Machine (ASM) ground model[1, 3] and a Workflow Interpreter (WI) implementation. For that purpose we use an execution context concept and notification concept, a refinement of triggers (event definitions)[4].

In this paper, we present a high-level definition of a formal method in terms of ambient abstract state machine rules which makes it possible to describe formal models of mobile computing systems and complex service oriented architectures in two abstraction layers.

The aim of the uCepCortex project is to develop an exocortex based on Ubiquitous Complex Event Processing as an Artificial Cognitive System and to investigate how to enhance human cognitive abilities, manage assistive robots, and their cooperation with humans via an exocortex system. In order to develop applications based on these artefacts the requirements of these applications have to be defined in a technology independent manner. This means an abstract model of the planned application has to be described. In this article we describe a notion of model which supports the specification of autonomous agents and their interaction by events. This notion has a precise semantics which is defined by Abstract State Machines (ASM). Such models can be transformed into executable programs.

The current programming paradigm for data-parallel computations is shifting with the rapidly increasing data growth on the web. It gives programmers more challenges than ever before. In this paper we propose Parallel Abstract State Machines (P-ASMs) that can empower programmers, no matter how experienced, by providing a well-founded systems engineering method to model data-parallel computations at arbitrary levels of abstraction. Particularly, we focus on discussing how P-ASMs can capture two classes of data-parallel computations that are most important in practice --- ones that are always-consistent and ones that require transactional data consistency.

Test generation techniques based on model checking suffer from the state space explosion problem. However, for a family of systems that can be easily decomposed in sub-systems, we devise a technique to cope with this problem. To model such systems, we introduce the notion of sequential net of Abstract State Machines (ASMs), which represents a system constituted by a set of ASMs such that only one ASM is active at every time. Given a net of ASMs, we first generate a test suite for every ASM in the net, then we combine the tests in order to obtain a test suite for the entire system. We prove that, under some assumptions, the technique preserves coverage of the entire system. We test our approach on a benchmark and we report a web application example for which we are able to generate complete test suites.

The Event-B method is a formal approach for reliable systems specification and verification, being supported by the Rodin platform, which includes mature plugins for theorem-proving, model-checking, or model (de)composition features. In order to complement these techniques with test generation and state model inference from Event-B models, we developed a new feature as a Rodin plugin. Our plugin implements a model-learning approach to iteratively construct an approximate automaton model together with an associated test suite. Test suite optimization is further applied according to different optimization criteria.

In this epilogue chapter, we summarize the book content and we discuss how the methods and notations presented in the book could be adopted, possibly in combination, to derive potentially original solutions for the problem of specifying, modeling, and analyzing complex computerized systems. We support our conclusive remarks by means of a hypothetical case study inspired by the management of an autonomous vehicle. Finally, we outline possible future developments in terms of unifying frameworks that could integrate the salient features of the approaches discussed in the book.

The Abstract State Machine (ASM) method proposes the concept of ground models for analyzing a target system based on pseudo-code-like descriptions for reasoning about system properties in terms of state machine runs over abstract data structures. This highly iterative process builds on stepwise refinement of ground models that evolve with progressing understanding of functional system requirements. Usually, as complexity increases, reorganization of a model's internal structure helps enhance its flexibility and robustness. While this approach is common practice, the underlying principles are usually left implicit. In this paper, we propose refactoring patterns to restructure abstract machine models with the goal of improving their intelligibility and maintainability.

We introduce the concept of an identity management machine (based on ASM) to mitigate problems regarding identity management in cloud computing. We decompose the client to cloud interaction into three distinct scenarios and introduce a set of ASM rules for each of them. We first consider a direct client to cloud interaction where the identity information stored on the client side is mapped to the identity created on the cloud provider's IdM system. To enhance privacy we then introduce the concept of real, obfuscated and partially obfuscated identities. Finally we take advantage of the increase in standardization in IdM systems defining the rules necessary to support authentication protocols such as OpenID. Our solution makes no supposition regarding the technologies used by the client and the cloud provider. Through abstract functions we allow for a distinct separation between the IdM system of the client and that of the cloud or service provider. Since a user is only required to authenticate once to our system, our solution represents a client centric single sign-on mechanism for the use of cloud services.

We attempt to put the title problem and the Church-Turing thesis into a proper perspective and to clarify some common misconceptions related to Turing's analysis of computation. We examine two approaches to the title problem, one well-known among philosophers and another among logicians.

Modelling and refinement in Event-B provides a scalable support for systematic development of complex service-oriented systems. This is achieved by a gradual transformation of an abstract service specification into its detailed architecture. In this paper we aim at integrating quantitative assessment of essential quality of service attributes into the formal modelling process. We propose an approach to creating and verifying a dynamic service architecture in Event-B. Such an architecture can be augmented with stochastic information and transformed into the corresponding continuous-time Markov chain representation. By relying on probabilistic model-checking techniques, we allow for quantitative evaluation of quality of service at early development stages.