Deploy Repository: No conditions. Results ordered -Date, Title. 2018-01-17T12:23:30ZEPrintshttp://deploy-eprints.ecs.soton.ac.uk/images/sitelogo.gifhttp://deploy-eprints.ecs.soton.ac.uk/2011-10-02T09:59:53Z2011-10-02T09:59:53Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/347This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3472011-10-02T09:59:53ZPatterns for Representing FMEA in Formal Specification of Control SystemsFailure Modes and Effects analysis (FMEA) is a widely used technique for inductive safety analysis. FMEA provides engineers with valuable information about failure modes of system components as well as procedures for error detection and recovery. In this paper we propose an approach
that facilitates representation of FMEA results in formal
Event-B specifications of control systems. We define a number of patterns for representing requirements derived from FMEA in formal system model specified in Event-B. The patterns help the developers to trace the requirements from safety analysis to formal specification. Moreover, they allow them to increase automation of formal system development by refinement. Our approach is illustrated by an example - a sluice control system.Ilya LopatkinIlya.Lopatkin@newcastle.ac.ukAlexei Iliasov"Alexei Iliasov" <Alexei.Iliasov@newcastle.ac.uk>Alexander Romanovskyalexander.romanovsky@ncl.ac.ukYuliya ProkhorovaYuliya.Prokhorova@abo.fiElena TroubitsynaElena.Troubitsyna@abo.fi2012-07-23T09:55:11Z2012-07-23T09:55:11Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/429This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/4292012-07-23T09:55:11ZModelling Control Process and Control Mode with Synchronising Orthogonal State MachinesIn this short paper we describe early work on a case study concerning a power window control unit. We use UML-B state machines to simultaneously model both the cyclic processing schedule and the mode of control behaviour. We find this a useful way to visualise the model, particularly when the state machines are animated via the Pro-B animator. We verify the state machines using the Event-B proof tools. We envisage new developments to the UML-B tool set to improve support for this modelling technique. The motivation for this simple but powerful form of modelling is the immediate benefit and low cost of entry making industrial adoption of formal models more attractive to industry.Colin Snook2011-08-16T09:03:54Z2011-08-16T09:03:54Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/321This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3212011-08-16T09:03:54ZGenerating High-Level Event-B System Models from KAOS Requirements ModelsModel-driven engineering (MDE) generally starts from system design model. In this
paper, we show how MDE can be extended to the requirements level expressed in requirements
models (in KAOS) and be linked with a formal design language (in Event-B). The central idea
is to map Goal-Oriented agents to a hierarchy of Event-B machines. A design process is proposed
to decompose a system level agent/machine into finer grained agent/machines based on
their ability to control specific piece of information. The approach is semi-automated and tool
supported by an Eclipse plug-in connecting the KAOS/Objectiver tool and the Event-B/Rodin
tools. The benefits and limits of the approach on the resulting model quality are highlighted on
a non-trivial example. Alternative approaches developed by others are also discussed.Christophe Ponsardchristophe.ponsard@cetic.beXavier Devroey2011-08-02T10:53:00Z2011-08-02T13:15:03Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/318This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3182011-08-02T10:53:00ZFormal Stepwise Development of Scalable and Reliable Multiagent SystemsThis chapter considers the coordination aspect of large-scale dynamically-reconfigurable multi-agent systems in which agents cooperate to achieve a common goal. The agents reside on distributed nodes and collectively represent a distributed system capable of executing tasks that cannot be effectively executed by an individual node. The two key requirements to be met when designing such a system are scalability and reliability. Scalability ensures that a large number of agents can participate in computation
without overwhelming the system management facilities and thus allows agents to join and leave the system without affecting its performance. Meeting the reliability requirement guarantees that the system has enough redundancy to transparently tolerate a number of node crashes and agent failures, and is therefore free from single points of failures. The Event B formal method is used to validate the design formally and to ensure system scalability and reliability.Denis GrotsevAlexei Iliasov"Alexei Iliasov" <Alexei.Iliasov@newcastle.ac.uk>Alexander Romanovskyalexander.romanovsky@ncl.ac.uk2011-07-21T09:47:15Z2011-07-21T09:57:08Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/316This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3162011-07-21T09:47:15ZFrom Requirements to Development: Methodology and Example The main destination of this paper is the industrial milieu. We are concerned with the difficulties encountered by industrial developers who are willing to apply "new" approaches to software engineering (since they always face the same problem for years: how to develop safe software) but are in fact disappointed by what is proposed to them. We try to characterize what the relevant constraints of industrial software projects are and then propose a simple methodology able to face the real problem. It is based on the usage of Event-B and is
illustrated by means of an industrial project.
Wen SuJean-Raymond AbrialRunlei HuangHuibiao Zhu2011-06-13T17:23:02Z2011-06-13T17:23:02Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/312This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3122011-06-13T17:23:02ZOn Methods for the Formal Specification of Fault Tolerant SystemsThis paper introduces different views for understanding
problems and faults with the goal of defining a method
for the formal specification of systems. The idea of Layered
Fault Tolerant Specification (LFTS) is proposed to make the
method extensible to fault tolerant systems. The principle is layering the specification in different levels, the first one for the normal behavior and the others for the abnormal. The abnormal behavior is described in terms of an Error Injector (EI), which represents a model of the erroneous interference coming from the environment. This structure has been inspired by the notion of idealized fault tolerant component but the combination of LFTS and EI using Rely/Guarantee reasoning to describe their interaction can be considered as a novel contribution. The
progress toward this method and this way to organize fault
tolerant specifications has been made experimenting on case
studies and an example is presented.Manuel Mazzaramanuel.mazzara@newcastle.ac.uk2011-11-14T11:01:13Z2011-11-14T11:01:13Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/352This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3522011-11-14T11:01:13ZProR - Eine Softwareplattform f"\ur Requirements EngineeringGute Werkzeugunterst"\utzung ist ein wichtiger Aspekt im Requirements Engineering. Es gibt zwar ein breites kommerzielles Angebot, aber wenige offene L"\osungen. ProR ist eine OpenSource Software zum Arbeiten mit nat"\urlichsprachigen Anforderungen. Es basiert auf dem Requirements Interchange Format (RIF), womit wir die Interoperabilit"\at mit anderen Werkzeugen gew"\ahrleisten. Wir legen gro\ssen Wert auf die Erweiterbarkeit der Plattform, was wir mit einem Integrations-Plugin f"\ur die formale Event-B-Methode belegen.Michael Jastram2011-06-08T16:03:20Z2011-06-08T16:03:20Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/306This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3062011-06-08T16:03:20ZRequirement Traceability in Topcased with the Requirements Interchange Format (RIF/ReqIF)One important step of the systems engineering process is requirements engineering. Parallel to the development of Topcased, which includes tooling for requirements engineering, a new standard for requirements exchange is emerging at the OMG under the name “ReqIF” (formally called RIF). In our talk we introduce the activities of two research projects and their tool developments, VERDE (Yakindu Requirements) and Deploy (ProR) and discuss possible synergies with Topcased.Michael Jastrammichael@jastram.deAndreas Graf2011-11-14T11:00:48Z2011-11-14T11:00:48Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/354This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3542011-11-14T11:00:48ZRequirements Modeling FrameworkIm August 2011 hat das Requirements Modeling Framework (RMF) als ein neues Eclipse-Projekt das Licht der Welt erblickt. RMF besteht aus einem Kern, der Daten im Requirements Exchange Format (RIF/ReqIf) verarbeiten kann, und einem GUI namens ProR, mit dem sich diese Daten komfortabel bearbeiten lassen. ProR stellt einen Extension Point zur Verf\"{u}gung, der die Integration mit anderen Werkzeugen erm\"{o}glicht.Michael JastramAndreas Graf2011-06-08T16:03:54Z2011-06-08T16:03:54Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/307This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3072011-06-08T16:03:54ZRequirements, Traceability and DSLs in Eclipse with the Requirements Interchange Format (RIF/ReqIF) Requirements engineering (RE) is a crucial aspect in systems development and is the area of ongoing research and process improvement. However, unlike in modelling, there has been no established standard that activities could converge on. In recent years, the emerging Requirements Interchange Format (RIF/ReqIF) gained more and more visibility in industry, and research projects start to investigate these standards. To avoid redundant efforts in implementing the standard, the VERDE and Deploy projects cooperate to provide a stable common basis for RIF/ReqIF that could be leveraged by other research projects too. In this paper, we present an Eclipse-based extensible implementation of a RIF/ReqIF-based requirements editing platform. In addition, we are concerned with two related aspects of RE that take advantage of the common platform. First, how can the quality of requirements be improved by replacing or complementing natural language requirements with formal approaches such as domain specific languages or models. Second, how can we establish robust traceability that links requirements and model constructs and other artefacts of the development process. We present two approaches to traceability and two approaches to modelling. We believe that our research represents a significant contribution to the existing tooling landscape, as it is the first clean-room implementation of the RIF/ReqIF standard. We believe that it will help reduce gaps in often heterogeneous tool chains and inspire new conceptual work and new tools. Michael Jastrammichael@jastram.deAndreas Graf2011-02-24T13:43:40Z2011-02-24T13:43:40Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/296This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2962011-02-24T13:43:40ZStructuring Functional Requirements of Control Systems to Facilitate Refinement-based Formalisation Sanaz YeganefardMichael Butler2010-10-26T06:07:54Z2010-10-26T06:07:54Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/245This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2452010-10-26T06:07:54ZProR, an Open Source Platform for Requirements Engineering based on RIFProper tool support in requirements engineering is important. A number of proprietary solutions are available in the market place, but few open solutions, and none that are widespread at this time. In this paper, we introduce ProR, an open platform for requirements engineering.
The project was initiated by the EU FP7 Project ``Deploy'', which has the goal to make major advances in engineering methods for dependable systems through the deployment of formal engineering methods. Rather than building a project-specific solution, we decided to develop an extensible, general purpose platform.
We based the tool's data model on the Requirements Interchange Format (RIF / ReqIF), a standard driven by the automotive industry. This gives us interoperability with a number of existing tools. The tool is based on the Eclipse Platform and uses the Eclipse Modeling Framework (EMF). We managed to establish a cooperation with the ITEA-Project ``Verde'', which supplied the implementation of the RIF data model.
In this paper, we will introduce the tool, describe its architecture, and present a small case study. ProR is still under development, and we welcome contributors and are very interested in potential users to validate our approach. Please visit www.pror.org for more information, and to download the current development version.Michael Jastrammichael@jastram.de2010-03-08T17:12:38Z2010-04-19T15:06:00Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/209This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2092010-03-08T17:12:38ZEvaluation of a Guideline by Formal Modelling of Cruise Control System in Event-B Sanaz YeganefardMichael ButlerAbdolbaghi Rezazadeh2012-07-23T10:20:34Z2012-07-23T10:20:34Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/431This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/4312012-07-23T10:20:34ZTIMING DIAGRAMS REQUIREMENTS MODELING USING EVENT-B FORMAL METHODS Timing diagrams provide an intuitive graphical specification for time constraints and causal dependencies between a system?s objects. Such a view can provide useful insight during Requirements Engineering (RE). Formal Modeling techniques allow abstract system level models to be explored in revealing detail and provide feedback via verification and validation methods such as proofs of consistency, model checking and animation. Here, we bring these two modelling approaches together. In particular we present techniques to extend a graphical modeling capability for formal modeling into the real-time domain by developing a Timing diagram view for the Event-B formal method and its graphical front-end, UML-B. Translation schemes to Event-B and UML-B are proposed and presented. A case study of a lift system is used to demonstrate the translation in practice.Tossaporn JoochimColin SnookMike PoppletonAndrew Gravell2010-07-08T09:48:34Z2010-07-18T22:51:59Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/236This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2362010-07-08T09:48:34ZAn Approach of Requirements Tracing in Formal Refinement
Formal modeling of computing systems yields models that are intended to be correct with respect to the requirements that have been formalized.
The complexity of typical computing systems can be addressed by formal refinement introducing all the necessary details piecemeal.
We report on preliminary results that we have obtained for tracing informal natural-language requirements into formal models across refinement levels.
The approach uses the WRSPM reference model for requirements modeling, and Event-B for formal modeling and formal refinement.
The combined use of WRSPM and Event-B is facilitated by the rudimentary refinement notion of WRSPM,
which provides the foundation for tracing requirements to formal refinements.
We assume that requirements are evolving, meaning that we have to cope with frequent changes of the requirements model and the formal model.
Our approach is capable of dealing with frequent changes, making use of corresponding techniques already built into the Event-B method.Michael Jastrammichael@jastram.deStefan Hallerstedesth@ecs.soton.ac.ukMichael Leuschelleuschel@cs.uni-duesseldorf.deAryldo G Russo Jragrj@aes.com.br2012-07-23T10:18:12Z2012-07-23T10:18:12Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/430This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/4302012-07-23T10:18:12ZFeature-Oriented Modelling Using Event-BEvent-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 the same family. Feature modelling is a well know technique to manage variability and configure products within the SPLs. We have combined the two approaches to formally specify SPLs using Event-B. This will contribute the concept of formalism to SPLs and re-usability to Event-B. Existing feature modelling notations were adapted and extended to include refinement mechanism of Event-B. An Eclipse-based graphical feature modelling tool has been developed as a plug-in to the Rodin platform. We have modelled the `production cell' case-study in Event-B, an industrial metal processing plant, which has previously been specified in a number of formalisms. We have also highlighted future directions based on our experience with this framework so far. Ali GondalMike PoppletonMichael ButlerColin Snook2010-03-19T10:47:28Z2010-04-19T15:06:00Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/211This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2112010-03-19T10:47:28ZStarting B Specifications from Use CasesThe B method is gaining visibility in formal methods com- munity due to excellent support for refinement. However, the traceability between the requirements and the formal model is still an issue of this method. On the other hand, use cases have become the informal industry standard for mapping functional requirements, describing the system's behavior using natural language. In this paper we show how controlled use cases can be used as a guideline for starting B specifications. In other words, our approach presents how a transaction, which is defined as an atomic part of the use case scenario, can be mapped as a B operation, providing a practical way to establish traceability between functional re- quirements and formal models.Aryldo G Russo Jragrj@aes.com.brThiago de Sousa2009-09-21T10:00:35Z2010-04-19T15:05:57Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/151This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/1512009-09-21T10:00:35ZGoal-Oriented Requirements Engineering in
Action in the Transportation SectorThis report presents the goal-oriented approach to engineer high-quality requirements. Starting from informally structured textual requirements, this report illustrates
some of the benefits of using a goal-oriented approach in terms of guarantee of completeness, consistency, reasoning on the system boundaries, identifying the responsibilities and dealing with potential conflicts. This report
is mainly on semi-formal notations but it also shortly considers the formalization process. It is consistently illustrated on the first simplified pilot problem
developed by the transportation sector during the DEPLOY project and known as "mini-pilot".Renaud Delandtsheerrenaud.delandtsheer@cetic.beChristophe Ponsardchristophe.ponsard@cetic.be2012-07-23T10:58:28Z2012-07-23T10:58:28Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/432This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/4322012-07-23T10:58:28ZFeature composition - towards product lines of Event-B modelsEvent-B is a formal language for modelling reactive systems, based on set theory and first-order logic. The RODIN toolkit provides comprehensive tool support for modelling and renement in Event-B, analysis and verification using animator/model-checkers and theorem provers. We consider the need to support reuse, in particular product line reuse, in such a formal development method. Feature modelling is an established technique for reuse in product lines. We introduce concepts of feature modelling and composition in Event-B to support the reuse of formal models and developments. A prototype feature composition tool has been developed (as a RODIN plug-in) for Event-B, based on the Eclipse Modelling Framework (EMF). Using an MDD philosophy, the tool extends the Event-B language meta-model to a composition meta model, and implements prototype composition patterns for Event-B features. Thus, a required composite model can be constructed by selecting, specializing, and composing input features in a defined way. The tool is the first step towards full feature modelling for product line model reuse for Event-B. We describe future work required to meet this goal.Ali GondalMike PoppletonColin Snook2009-04-20T09:35:14Z2010-04-19T15:05:53Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/91This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/912009-04-20T09:35:14ZFrom Goal-Oriented Requirements to Event-B SpecificationsIn goal-oriented requirements engineering methodologies, goals are structured into refinement
trees from high-level system-wide goals down to fine-grained requirements assigned to specific software/
hardware/human agents that can realise them. Functional goals assigned to software agents
need to be operationalised into specification of services that the agent should provide to realise those
requirements. In this paper, we propose an approach for operationalising requirements into specifications
expressed in the Event-B formalism. Our approach has the benefit of aiding software designers
by bridging the gap between declarative requirements and operational system specifications in a rigorous
manner, enabling powerful correctness proofs and allowing further refinements down to the
implementation level. Our solution is based on verifying that a consistent Event-B machine exhibits
properties corresponding to requirements.Benjamin Azizbenjamin.aziz@stfc.ac.ukAlvaro Arenasalvaro.arenas@stfc.ac.ukJuan Bicarreguijuan.bicarregui@stfc.ac.ukChristophe Ponsardchristophe.ponsard@cetic.bePhilippe Massonetphilippe.massonet@cetic.be2009-04-01T16:20:41Z2009-04-03T08:47:51Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/89This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/892009-04-01T16:20:41ZMethods, Models and Tools for Fault ToleranceMichael ButlerCliff B JonesCliff.Jones@ncl.ac.ukAlexander Romanovskyalexander.romanovsky@ncl.ac.ukElena TroubitsynaElena.Troubitsyna@abo.fi2009-04-01T16:27:01Z2010-04-19T15:05:53Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/90This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/902009-04-01T16:27:01ZStep-wise Development of Resilient Ambient Campus ScenariosThis paper puts forward a new approach to developing resilient ambient applications. In its core is a novel rigorous development method supported by a formal theory that enables us to produce a well-structured step-wise design and to ensure disciplined integration of error
recovery measures into the resulting implementation. The development method, called AgentB, uses the idea of modelling database to support a coherent development of and reasoning about several model views, including the variable, event, role, agent and protocol views. This helps system developers in separating various modelling concerns and makes it easier for future tool developers to design a toolset supporting this development. Fault tolerance is systematically introduced during the development of various model views. The approach is demonstrated through the development of several application scenarios within an ambient campus case study conducted at Newcastle University (UK) as part of the FP6 RODIN project.Alexei Iliasov"Alexei Iliasov" <Alexei.Iliasov@newcastle.ac.uk>Budi AriefAlexander Romanovskyalexander.romanovsky@ncl.ac.uk2008-10-16T20:31:13Z2010-04-19T15:05:50Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/40This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/402008-10-16T20:31:13ZFrom Rigorous Requirements Engineering to Formal System Design of Safety-Critical SystemsChristophe Ponsardchristophe.ponsard@cetic.beGautier Dallonsgautier.dallons@cetic.beMassonet Philippephilippe.massonet@cetic.be2012-07-23T12:15:20Z2012-07-23T12:15:20Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/440This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/4402012-07-23T12:15:20ZRigorous engineering of product-line requirements: a case study in failure managementWe consider the failure detection and management function for engine control systems as an application domain where product line engineering is indicated. The need to develop a generic requirement set - for subsequent system instantiation - is complicated by the addition of the high levels of verification demanded by this safety-critical domain, subject to avionics industry standards. We present our case study experience in this area as a candidate method for the engineering, validation and verification of generic requirements using domain engineering and Formal Methods techniques and tools. For a defined class of systems, the case study produces a generic requirement set in UML and an example system instance. Domain analysis and engineering produce a validated model which is integrated with the formal specification/ verification method B by the use of our UML-B profile. The formal verification both of the generic requirement set, and of a simple system instance, is demonstrated using our U2B, ProB and prototype Requirements Manager tools. This work is a demonstrator for a tool-supported method which will be an output of EU project RODINȏotnoteThis work is conducted in the setting of the EU funded research project: IST 511599 RODIN (Rigorous Open Development Environment for Complex Systems) \texttthttp://rodin.cs.ncl.ac.uk/.. The use of existing and prototype formal verification and support tools is discussed. The method, developed in application to this novel combination of product line, failure management and safety-critical engineering, is evaluated and considered to be applicable to a wide range of domains.Colin SnookMichael PoppletonIan Johnson2010-08-19T10:18:37Z2010-08-26T16:20:06Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/243This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2432010-08-19T10:18:37ZAn Incremental Refinement Approach to a Development of Flash
File System in Event-BKriangsak Damchoomkd06r@ecs.soton.ac.uk2011-03-10T21:29:42Z2011-04-05T15:08:50Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/297This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/2972011-03-10T21:29:42ZDesign, Modelling and Analysis of a Workflow ReconfigurationThis paper describes a case study involving interference be-
tween application activities and reconfiguration activities in an office workflow. We state the requirements on a system implementing the workflow and its reconfiguration, and describe the system's design in BPMN. We then use an asynchronous pi-calculus and Webpi to model the design and to verify whether or not it will meet the requirements. In the process, we evaluate the formalisms for their suitability for the modelling and analysis of dynamic reconfiguration of dependable systems.Manuel MazzaraFaisal AbouzaidNicola DragoniAnirban Bhattacharyya2011-06-28T10:07:11Z2011-06-28T10:07:11Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/313This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/3132011-06-28T10:07:11ZDesign, Modelling and Analysis of a Workflow ReconfigurationThis paper describes a case study involving the reconfiguration of an office workflow. We state the requirements on a system implementing the workflow and its reconfiguration, and describe the system’s design in BPMN. We then use an asynchronous pi-calculus and Webpi to model the design and to verify whether or not it will meet
the requirements. In the process, we evaluate the formalisms for their suitability for the modelling and analysis of dynamic reconfiguration of dependable systems.Manuel Mazzaramanuel.mazzara@newcastle.ac.uk2009-05-26T08:39:21Z2010-04-19T15:05:54Zhttp://deploy-eprints.ecs.soton.ac.uk/id/eprint/104This item is in the repository with the URL: http://deploy-eprints.ecs.soton.ac.uk/id/eprint/1042009-05-26T08:39:21ZMapping Requirements to B modelsFormal methods in systems engineering are gaining traction, at least in some areas. While the formal specification process from abstraction via refinement to implementation is fairly well understood, the traceability between the initial user requirements and the formal model is still unsatisfying. There are some promising attempts (e.g. KAOS) that inspired some of the work done here.
Our objective is to find a practical way to establish traceability between natural language requirements and B models.
We select a number of existing methods and notations for bringing natural language requirements and B specifications together. Specifically, we use UML-B for building a data model; we use invariants (part of the B method) to model safety requirements; and we use temporal expressions (LTL) to model liveness requirements.
In this paper, we show a pragmatic way that may lead to a method for making traceability between natural language requirements and B models easier to understand, maintain and validate.Michael Jastramjastram@cs.uni-duesseldorf.deMichael Leuschelleuschel@cs.uni-duesseldorf.deJens Bendispostobendisposto@cs.uni-duesseldorf.deAryldo G Russo Jragrj@aes.com.br