RAISE Specification Language Research Articles

Stepwise development and model checking of adistributed interlocking system using RAISE

Abstract This paper considers the challenge of designing and verifying control protocols for geographically distributed railway interlocking systems. It describes how this challenge can be tackled by stepwise development and model checking of state transition system models in a new extension of the RAISE Specification Language. Railway interlocking systems are reconfigurable systems which can be configured by supplying data describing the network to be controlled and other details. Therefore, such systems are natural candidates for being modelled by generic state transition systems, which abstract away from the concrete configuration at the time of modelling, and can later be instantiated with concrete data. For a real-world case study, a generic state transition system is developed in steps, starting with an abstract model of the essential system behaviour and incrementally adding details and restrictions. The stepwise development method allows different variants of the control protocol to be explored. The generic models are instantiated with concrete configuration data, after which desired properties, in particular safety properties, of the system models are verified using model checking.

Model checking RAISE applicative specifications

AbstractEnsuring the correctness of a given software component has become a crucial aspect in software engineering and model checking provides an almost fully automatic way of achieving this goal. Due to the scalability problems of the model checking technique, it has become popular to apply it at early stages in the development process, when the size of the model is much smaller than the final code. Properties proved in this way can be shown to hold at the implementation level provided that the final code refines the original specification. In this paper we focus on the main issues for adding model checking functionality to the RAISE specification language (RSL) and present the semantic foundations of our current approach for doing so. We also describe a way to use model checking to verify RAISE confidence conditions, ensuring the soundness and completeness of the results checked in this way. We then present the most interesting details of the implementation of a tool that follows the described approach. Finally, we illustrate the application of the technique with two case studies: a Digital Multiplexed Radio Telephone System and the Mondex electronic purse.

Integrating formal methods with domain analysis

The use of formal methods should help to achieve a high degree of confidence that a system will conform to its specification, enhancing in consequence software quality and reliability. However, a general acceptance of formal methods among software engineers is still some way off because formal methods are usually only accessible to specialists and they do not have developed in depth strategies for the first stages of development. This is also valid to Domain Analysis, because its first stage is to capture the knowledge of a particular domain, making necessary to have a model comprehensible by software engineers and domain experts. In order to address this problem and take advantage of formal methods, we suggest integrating the phase reusable Domain Analysis into the RAISE Method, combining Domain Analysis notions with a formal language in the early steps of software development process. In this paper, we present a set of heuristics to fruitfully use knowledge represented in a Domain Analysis model to derive a formal specification in the RAISE Specification Language.

Formal description and test cases generation of protocols based on input/output sequence

How to use RAISE Specification Language(RSL) to describe protocols was discussed.Description model was input/output sequence based,in which protocols actions were divided into input actions and output actions.All those actions would be elements of describtion.The core of description was central process.A new method to generate testing cases based on formal description using RSL was also discussed.The method was a kind of recursion procedure.Testing cases produced by the method were sound and exhaustive.The research provides a new direction for the protocol formal description and testing.

Formal specification of a query expression generator using RSL

We design a query generator to convert queries expressed in more user-friendly terms to terms (attributes) that change in line with the underlying database structures of an organisation. These latter terms are generated with the aid of a type structure defined over the database structures and perhaps may be optimised for efficient database access. Formal methods are used for the specification of the query generator which is not the usual practice in the specification of query generators. We use RSL, the RAISE Specification Language, to formally specify our generator. From the specification, an implementation of our generator is generated in C++ using a command within the RSL project support environment that translates RSL to C++. The preliminary results with our generator show that it holds promise as a stand-alone tool as well. (Botswana Journal of Technology: 2002 11(2): 9-17)

Towards a denotational semantics of timed RSL using duration calculus

The Timed RAISE Specification Language (Timed RSL) is an extension of RAISE Specification Language by adding time constructors for specifying real-time applications. Duration Calculus (DC) is a real-time interval logic, which can be used to specify and reason about timing and logical constraints on duration properties of Boolean states in a dynamic system. This paper gives a denotational semantics to a subset of Timed RSL expressions, using Duration Calculus extended with super-dense chop modality and notations to capture time point properties of piecewise continuous states of arbitrary types. Using this semantics, the paper presents a proof rule for verifying Timed RSL iterative expressions and implements the rule to prove the satisfaction by a sample Timed RSL specification of its real-time requirements.

The NDB database specified in the RAISE specification language

Abstract This paper answers a challenge designed to test the modularization features of specification languages. The RAISE Specification Language (RSL) is shown to have the power necessary to meet the challenge. Basic features of RSL, particularly those useful for the problem, are introduced. Two solutions to the problem are exhibited. The first follows the structure of the challenge problem very closely and is model-based in style. The second shows how RSL may be written in an algebraic style. An example of a proof of implementation is also given.

The RAISE language, method and tools

Abstract This paper presents the RAISE 1 software development method, its associated specification language, and the tools supporting it. The RAISE method enables the stepwise development of both sequential and concurrent software from abstract specification through design to implementation. All stages of RAISE software development are expressed in the wide-spectrum RAISE specification language. The RAISE tools form an integrated tool environment supporting both language and method. The paper surveys RAISE and furthermore, more detailed presentations of major RAISE results are provided. The subjects of these are (a) an example of the use of the RAISE method and language, and (b) a presentation of the mathematical semantics of the RAISE specification language.