Development Of Reactive Systems Research Articles

On the Semantics of Distributed Reactive Programming: The Cost of Consistency

The reactive programming paradigm aims to simplify the development of reactive systems. It provides abstractions to define time-changing values that are automatically updated by the runtime according to their dependencies. The benefits of reactive programming in distributed settings have been recognized for long. Yet, existing solutions for distributed reactive programming enforce the same semantics as in single processes, introducing communication and synchronization costs that hamper scalability. Establishing suitable abstractions for distributed reactive programming demands for a deeper investigation of the semantics of change propagation. This paper takes a foundational approach and defines precise propagation semantics in terms of consistency guarantees that constrain the order and isolation of value updates. We study the benefits and costs of these consistency guarantees both theoretically and empirically, using case studies and synthetic benchmarks. We show that different applications require different levels of consistency and that manually implementing the required level on a middleware that provides a lower one annuls the abstraction improvements of reactive programming. This motivates a framework that enables the developers to select the best trade-off between consistency and overhead for the problem at hand. To this end, we present DREAM, a distributed reactive programming middleware with flexible consistency guarantees.

A logic for the stepwise development of reactive systems

D↓ is a new dynamic logic combining regular modalities with the binder constructor typical of hybrid logic, which provides a smooth framework for the stepwise development of reactive systems. Actually, the logic is able to capture system properties at different levels of abstraction, from high-level safety and liveness requirements, to constructive specifications representing concrete processes. The paper discusses its semantics, given in terms of reachable transition systems with initial states, its expressive power and a proof system. The methodological framework is in debt to the landmark work of D. Sannella and A. Tarlecki, instantiating the generic concepts of constructor and abstractor implementations by standard operators on reactive components, e.g. relabelling and parallel composition, as constructors, and bisimulation for abstraction.

A family of experiments to evaluate the understandability of TRiStar and i* for modeling teleo-reactive systems

The teleo-reactive approach facilitates reactive system development without losing sight of the system goals. ObjectiveTo introduce TRiStar as an extension of i* notation to specify teleo-reactive systems. To evaluate whether the notational extension is an improvement in terms of effectiveness and efficiency over the original language when it is used to specify teleo-reactive systems. MethodA family of experiments was carried out with final-year engineering students and experienced software development professionals in which the participants were asked to fill in a form designed to evaluate the efficiency and effectiveness of each of the languages. ResultsBoth the statistical results of the experiments, analyzed separately, and the meta-analysis of the experiments as a whole, allow us to conclude that TRiStar notation is more effective and efficient than i* as a requirements specification language for modeling teleo-reactive systems. ConclusionThe extensions made on i* have led to TRiStar definition, a more effective and efficient goal-oriented notation than the original i* language.

Using the Compatibility Analysis of Logical Specifications of Automata to Solve Game Problems

Game models are widely used to solve realizability, synthesis, and verification problems. This article considers an alternative approach to solving these problems on the basis of the concept of compatibility of automata (FSMs) or their logical specifications. The corresponding methods substantially differ from those used in the context of a game. It is shown how to use these methods for the synthesis of a winning strategy in a two-player game that does not relate to the development of reactive systems.

Functional reactive programming with liveness guarantees

Functional Reactive Programming (FRP) is an approach to the development of reactive systems which provides a pure functional interface, but which may be implemented as an abstraction of an imperative event-driven layer. FRP systems typically provide a model of behaviours (total time-indexed values, implemented as pull systems) and event sources (partial time-indexed values, implemented as push systems). In this paper, we investigate a type system for event-driven FRP programs which provide liveness guarantees, that is every input event is guaranteed to generate an output event. We show that FRP can be implemented on top of a model of sets and relations, and that the isomorphism between event sources and behaviours corresponds to the isomorphism between relations and set-valued functions. We then implement sets and relations using a model of continuations using the usual double-negation CPS transform. The implementation of behaviours as pull systems based on futures, and of event sources as push systems based on the observer pattern, thus arises from first principles. We also discuss a Java implementation of the FRP model.

Combining Formal Methods for the Development of Reactive Systems

This article deals with the use of two verification approaches: theorem proving and model checking. We focus on the Event-B method by using its associated theorem proving tool (Click_n_Prove), and on the language TLA + by using its model checker TLC. By considering the limitation of the Event-B method to invariance properties, we propose to apply the language TLA + to verify liveness properties on a software behavior. We extend first the expressivity and the semantics of a B model (called temporal B model ) to deal with the specification of fairness and eventuality properties. Second, we give transformation rules from a temporal B model into a TLA + module. We present in particular, our prototype system called B2TLA + , that we have developed to support this transformation; then we can verify these properties thanks to the model checker TLC on finite state systems. For the verification of infinite-state systems, we propose the use of the predicate diagrams. We illustrate our approach on a case study of a parcel sorting system.

From Teleo-Reactive specifications to architectural components: A model-driven approach

The Teleo-Reactive approach designed by N.J. Nilsson offers a high-level programming model that permits the development of reactive systems, such as robotic vehicles. Teleo-Reactive programs are written in a manner that allows engineers to define the behaviour of the system while taking into account goals and changes in the state of the environment. This article presents a systematic approach that makes it possible to derive architectural models, with structural descriptions and behaviour, from Teleo-Reactive Programs. The development of reactive systems can therefore benefit significantly from a combination of two approaches: (1) the Teleo-Reactive approach, which is oriented towards a description of the system from the standpoint of the goals identified and the state of the environment and (2) the architectural approach, which is oriented towards the design of component-based software, in which decisions are conditioned by the need to reuse already tested solutions. The integration of this work into a development environment that allows code to be generated via model transformations opens up new possibilities in the development of this type of systems. The proposal is validated through a case study that is representative of the domain, and a survey carried out with post-graduate students.

시나리오 기반 명세 모델로부터 반응형 시스템 모델 개발

It is an important and a difficult task to analyze external inputs and interactions between objects for designing and modeling a reactive system consisting of multiple object. Also the reactive system is required huge efforts on confirm it can satisfy requirements under all possible circumstances. In this paper, we build from requirements to a scenario-based specification model using LSC(Live Sequence Chart) extending MSC(Message Sequence Chart) with richer syntax and semantic. Then the reactive system model satisfying all requirements for each object in this system can be automatically created through LTL Synthesis. Finally, we propose a method of reactive system development by iterative process transforming a reactive system model to codes.

Reactive animation: From piecemeal experimentation to reactive biological systems

Over the past decade, multi-level complex behavior and reactive nature of biological systems, has been a focus point for the biomedical community. We have developed a computational approach, termed Reactive Animation (RA) for simulating such complex biological systems. RA is an approach for describing the dynamic characteristics of biological systems based on facts collected from experiments. These data are integrated bottom-up by computational tools and methods for reactive systems development and are simulated concomitantly to a front-end user friendly visualization and reporting systems. Using RA, the experimenter may intervene mid-simulation, suggest new hypotheses for cellular and molecular interactions, apply them to the simulation and observe their resulting outcomes “on-line”. Several RA models have been developed including models of T cell activation, thymocyte development and pancreatic organogenesis, which are describe in the in this review.

Combining formal methods for the development of reactive systems

Combining formal methods for the development of reactive systems

A formal approach for the development of reactive systems

Context This paper deals with the development and verification of liveness properties on reactive systems using the Event-B method. By considering the limitation of the Event-B method to invariance properties, we propose to apply the language TLA + to verify liveness properties on Event-B models. Objective This paper deals with the use of two verification approaches: theorem proving and model-checking, in the construction and verification of safe reactive systems. The theorem prover concerned is part of the Click_n_Prove tool associated to the Event-B method and the model checker is TLC for TLA + models. Method To verify liveness properties on Event-B systems, we extend first the expressivity and the semantics of a B model (called temporal B model) to deal with the specification of fairness and eventuality properties. Second, we propose semantics of the extension over traces, in the same spirit as TLA + does. Third, we give verification rules in the axiomatic way of the Event-B method. Finally, we give transformation rules from a temporal B model into a TLA + module. We present in particular, our prototype system called B2TLA +, that we have developed to support this transformation; then we can verify liveness properties thanks to the model checker TLC on finite state systems. For the verification of infinite-state systems, we propose the use of the predicate diagrams and its associated tool DIXIT. As the B refinement preserves invariance properties through refinement steps, we propose some rules to get the preservation of liveness properties by the B refinement. Results The proposed approach is applied for the development of some reactive systems examples and our prototype system B2TLA + is successfully used to transform a temporal B model into a TLA + module. Conclusion The paper successfully defines an approach for the specification and verification of safety and liveness properties for the development of reactive systems using the Event-B method, the language TLA + and the predicate diagrams with their associated tools. The approach is illustrated on a case study of a parcel sorting system.

A NEW APPROACH TO VERIFY STATECHART SPECIFICATIONS FOR REACTIVE SYSTEMS

The application domain, such as communication networks and embedded controllers for telephony, automobiles, trains and avionics systems, requires very high quality reactive systems, so an important phase in the development of reactive systems is the verification of their conceptual models before implementation. Normally in the requirement analysis phase, system property can be represented as an input and output labeled transition system (IOLTS), which is a transition system labeled by inputs and outputs between the system and the environment. This paper describes an attempt to propose an approach to verify Statechart specifications for reactive systems given IOLTS property specifications. We develop a suitable semantics model — observable semantics, an abstract semantics model only which describes outside observable behavior and suffers from less state explosion problem by reducing infinite or large state spaces to small ones. Then we propose two methods to verify the conformance between a given IOLTS property specification and a Statechart specification: two-phase verification and on-the-fly verification. Compared with two-phase verification, on-the-fly verification needs less storage and computation-time, especially when the target Statechart specification is very large or likely to have many errors.

A compositional semantics of UML-RSDS

This paper provides a semantics for the UML-RSDS (Reactive System Development Support) subset of UML, using the real-time action logic (RAL) formalism. We show how this semantics can be used to resolve some ambiguities and omissions in UML semantics, and to support reasoning about specifications using the B formal method and tools. We use ‘semantic profiles’ to provide precise semantics for different semantic variation points of UML. We also show how RAL can be used to give a semantics to notations for real-time specification in UML. Unlike other approaches to UML semantics, which concentrate on the class diagram notation, our semantic representation has behaviour as a central element, and can be used to define semantics for use cases, state machines and interactions, in addition to class diagrams.

Synchronous structures

Synchronous languages have been designed to ease the development of reactive systems, by providing a methodological framework for assisting system designers from the early stages of requirement specifications to the final stages of code generation or circuit production. Synchronous languages enable a very high-level specification and an extremely modular design of complex reactive systems by structural decomposition of them into elementary processes. We define an order-theoretical model that gives a unified mathematical for-malisation of all the above aspects of the synchronous methodology and characterises the essentials of the synchronous paradigm.

An Object-Oriented Modeling and Simulation Environment for Reactive Systems Development

An environment to support the modeling, analysis, simulation, and development of state transition models, SMOOCHES (State Machines for Object-Oriented Concurrent Hierarchical Engineering Specifications), is presented. SMOOCHES allows the hierarchical construction, analysis, and simulation of state transition models in an object-oriented distributed environment. Statecharts (see Harel 1987b), a powerful mechanism for state transition specification, are fundamental to the development of SMOOCHES. To assist in the specification of hierarchical state transition models for distributed and reactive systems, statecharts are extended by introducing the concept of exit-safe states. SMOOCHES allows the specification of objects in the system with hierarchical state transition models and the derivation of new classes of objects through inheritance. A graphical monitoring system has been developed to represent and simulate the object state life cycles and monitor event generations. The example presented illustrates the modeling and simulation of different state life cycles of an assembly robot.

Developing reactive systems in a VDM framework

This paper studies the detailed development of reactive systems, using an extension of VDM. The extension allows specification and proof of behavioural aspects to be expressed in the VDM framework. This is achieved by using traces of the input/output activities and introducing the notion of external entities whose behaviour is described by a state machine. The major objective of this work is to improve understanding of the practical implications of the specification, design, and symbolic validation of machine-checked reactive systems.

Temporal theories as modularisation units for concurrent system specification

Abstract In this paper, we bring together the use of temporal logic for specifying concurrent systems, in the tradition initiated by A. Pnueli, and the use of tools from category theory as a means for structuring specifications as combinations of theories in the style developed by R. Burstall and J. Goguen. As a result, we obtain a framework in which systems of interconnected components can be described by assembling the specifications of their components around a diagram, using theory morphisms to specify how the components interact. This view of temporal theories as specification units naturally brings modularity to the description and analysis of systems. Moreover, it becomes possible to import into the area of formal development of reactive systems the wide body of specification techniques that have been defined for structuring specifications independently of the underlying logic, and that have been applied with great success in the area of Abstract Data Types. Finally, as a discipline of design, we use the object-oriented paradigm according to which components keep private data and interact by sharing actions, with a view towards providing formal tools for the specification of concurrent objects.