Event-B Patterns and Their Tool Support (original) (raw)

Supporting Reuse of Event-B Developments through Generic Instantiation

Lecture Notes in Computer Science, 2009

It is believed that reusability in formal development should reduce the time and cost of formal modelling within a production environment. Along with the ability to reuse formal models, it is desirable to avoid unnecessary re-proof when reusing models. Event-B is a formal method that allows modelling and refinement of systems. Event-B supports generic developments through the context construct. Nevertheless Event-B lacks the ability to instantiate and reuse generic developments in other formal developments. We propose a way of instantiating generic models and extending the instantiation to a chain of refinements. We define sufficient proof obligations to ensure that the proofs associated to a generic development remain valid in an instantiated development thus avoiding re-proofs.

A basis for feature-oriented modelling in event-B

Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 2010

Feature-oriented modelling is a well-known approach for Software Product Line (SPL) development. It is a widely used method when developing groups of related software. Due to reuse methods, the development of the software product is quicker, less expensive and of higher quality. However, this approach is not common in formal methods development, which is generally high cost and time consuming, yet crucial in the development of critical systems. We present a method to integrate feature-oriented development with the formal specication language Event-B. Our approach allows the user to map a feature from the feature model to an Event-B component, which contains a formal specication of that feature. We also present some patterns, which assist the user in the modelling of Event-B components. We describe a composition process which consists of the user selecting an instance in the feature model and then constructing this instance in Event-B. While composing, the user may also discharge new composition proof obligations in order to ensure the model is consistent. The model is then constructed using a number of composition rules.

Feature-Oriented Modelling Using Event-B

2010

Event-B is a formal method for specification and verification of reactive systems. Its Rodin toolkit provides comprehensive support for modelling, refinement and analysis using theorem proving, animation and model checking. There has always been a need to reuse existing models and their associated proofs when modelling related systems to save time and effort. Software product lines (SPLs) focus on the problem of reuse by providing ways to build software products having commonalities and managing variations within products of ...

Towards an approach for modeling and formalizing SOA design patterns with Event-B

Proceedings of the 28th Annual ACM Symposium on Applied Computing - SAC '13, 2013

This paper introduces a formal architecture-centric approach, which allows first to model message-oriented SOA design patterns with the SoaML standard language, and second to formally specify these patterns at a high level of abstraction using the Event-B method. These two steps are performed before undertaking the effective coding of a design pattern providing correct by construction pattern-based software architectures. We implement our approach under the Rodin platform which we use to prove model consistency.

Towards an Event Modeling Language

Object-oriented programming owes part of its popularity to Booch's notation 2], Rumbaugh's OMT 7], and UML 8]. These notations allow object oriented designs to be expressed graphically and furthermore have enabled the development of case tools for object oriented languages. The lack of a suitable high level graphical notation has been identi ed as one of the factors discouraging the uptake of functional programming and in particular the language Erlang 1]. This paper represents a rst step in designing a graphical modeling language for functional programming that encourages sound programming practices. The initial target language is Erlang but it is hoped that the notation can be extended to other functional languages.

Rodin: an open toolset for modelling and reasoning in Event-B

International Journal on Software Tools for Technology Transfer, 2010

Event-B is a formal method for system-level modelling and analysis. Key features of Event-B are the use of set theory as a modelling notation, the use of refinement to represent systems at different abstraction levels and the use of mathematical proof to verify consistency between refinement levels. In this article we present the Rodin modelling tool that seamlessly integrates modelling and proving. We outline how the Event-B language was designed to facilitate proof and how the tool has been designed to support changes to models while minimising the impact of changes on existing proofs. We outline the important features of the prover architecture and explain how well-definedness is treated. The tool is extensible and configurable so that it can be adapted more easily to different application domains and development methods.

A formal framework to model and validate event-based software architecture

Procedia Computer Science, 2011

Today, distributed systems with loose connections are increasingly developed using event-based architectures. In these architectures, systems are composed of separate components which cooperate dynamically. The communication and cooperation of components in these architectures are done through event passing mechanisms. The main challenge in these architectures is to define a framework to model and validate systems under development. In this paper, we propose a framework using ASMETA (ASM mETA language) for modelling systems through event-based architectures. Validation of the whole system is done through model checking using Bogor. We describe the process of automatically mapping ASM models to BIR -the input language of Bogor-. In the end, we present our experimental results using the proposed approach with different case studies.

Tutorial on advanced design patterns in event processing

Proceedings of the 6th ACM International Conference on Distributed Event-Based Systems - DEBS '12, 2012

We introduce a reference architecture for event processing, as defined by the EPTS reference architecture (RA) working group. An event processing reference architecture allows users to quickly create event processing solutions that adhere to known stakeholder requirements and architectural qualities. The focus in this paper is on the EPTS reference architecture description of the functional view which is supported by a mapping of its functions into design patterns as means to derive and prove these architectural descriptions to be usable solutions for recurring best practice implementations in common CEP languages.

Towards Reuse with "Feature-Oriented Event-B

is a language for the formal specification and verification of reactive systems. The language and its RODIN toolkit represent a leading model-based technology for formal software construction. However, scalability is a major current concern, especially the dimension of reusability. We outline a proposed infrastructure for scalable development with reuse for Event-B. We focus specifically on our agenda for reuse in Software Product Lines, and explain how a form of feature modelling will be central to this programme.

Towards Automated Refinement: Patterns in Event B

2009

Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their insufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by increasing automation of development steps. We introduce a notion of refinement patterns -generic representations of typical correctness-preserving model transformations. Our definition of a refinement pattern contains a description of syntactic model transformations, as well as the pattern applicability conditions and proof obligations for verification of correctness preservation. This establishes a basis for building a tool supporting formal system development via pattern reuse and instantiation. We present a prototype of such a tool and some examples of refinement patterns for automated development in the Event B formalism.