Paulo Sérgio Muniz Silva

Transforming an enterprise model into a use case model using existing heuristics

One of the key responsibilities of Requirements Engineering is to refine requirements into specifications. Although there are some approaches for requirements refinement, this task is usually executed manually. Based on Model-Driven Engineering concepts, this study proposes a semi-automatic transformation using an enterprise model as source and a use case model as target. The underlying hypothesis is that using an enterprise model as a source it is possible to represent both the requirements and the domain knowledge that are necessary to obtain specifications. Considering this hypothesis, this study discusses the proposed transformation and a set of heuristics - found in the analysis of existing studies - using an example, executed with support of a tool.

Automatic Verification of Safety Rules for a Subway Control Software

This paper proposes the introduction of an automatic verification phase for a subway control software development process in which bounded model checking (BMC) and induction proof would be used to anticipate error discovery and increase the quality of the final product. We report the tests we developed for some safety rules of two actual sections of a subway track and the results we achieved. We conclude that the technique seems feasible for the problem domain, but the issue requires extensive research to allow an exact understanding of which requirements the use of the BMC meets, and actual benefits this approach might bring to the project.

An Adaptive Framework for the Design of Software Specification Languages

Software has been specified as domain theories. A useful strategy for building specifications is the incremental extension of an initial theory, in which increments add new terms and notions not considered in previous extensions. Given an increment, the corresponding theory is stated in a corresponding specification language. The next increment — or extension of the theory — typically requires a related language extension, which has been specified in a variety of ways, e.g. meta-computations, rewriting systems, etc. Adaptive devices naturally support such scheme, whose instances should reflect the impact of extension variations on the specification language. This paper describes an adaptive framework for the design of a class of software specification languages supporting the incremental process of elaborating software specifications.

Transforming an enterprise model into a use case model in business process systems

Abstract One of the responsibilities of requirements engineering is to transform stakeholder requirements into system and software requirements. For enterprise systems, this transformation must consider the enterprise context where the system will be deployed. Although there are some approaches for detailing stakeholder requirements, some of them even considering the enterprise context, this task is executed manually. Based on model-driven engineering concepts, this study proposes a semi-automatic transformation from an enterprise model to a use case model. The enterprise model is used as a source of information about the stakeholder requirements and domain knowledge, while the use case model is used as software requirements model. This study presents the source and target metamodels, a set of transformation rules, and a tool to support the transformation. An experiment analyzes the use of the proposed transformation to investigate its benefits and if it can be used in practice, from the point of view of students in the context of a requirements refinement. The results indicate that the approach can be used in practice, as it did not influence the quality of the generated use cases. However, the empirical analysis does not indicate benefits of using the transformation, even if the qualitative results were positive.

A proposal for extending UML-B to support a conceptual model

UML-B is a development process framework for Event-B based on a “UML-like” graphical formal notation that provides support for object-oriented modelling concepts, in particular, for class and state machine diagrams. However, this methodology has a gap for mapping requirements to formal specifications. To overcome this issue, we present a proposal for extending UML-B to support a conceptual model to provide an easier starting point for the actual development process. More precisely, we propose two diagrams to facilitate the passing from requirements to the initial formal model: a first one to represent system behavior based on UML 2 interaction overview diagram (IOD) and a second one for system structure based on boundary-control-entity stereotyped class diagram (BCE). We show how to translate the former into an Event-B specification and explain how to link the latter to the original UML-B using a simple ATM example as proof of concept.

A prescriptive technique for V&V of simulation models when no real-life data are available

Verification and validation (V&V) is a key process to guarantee that any model represents adequately a given system. Although no one can guarantee a 100% valid model, it is possible to increase model confidence by the utilization of V&V techniques. There are many V&V techniques which have a descriptive nature (they tell us what to do but not how to do it). There are also prescriptive techniques, that tell us how to do it, but in simulation practice they are underused. The main goal of this paper is based on Kleijnen (1999) procedure. It is to propose a prescriptive V&V technique that is simple enough for practical application and, because of its procedural nature, it could be easily built into any simulation software, thus enabling the automation of the V&V process. This approach was also applied to some test problems confirming its feasibility

Mapping the WRSPM Model to Model-Driven Architecture Models

Model-Driven Architecture (MDA) is a framework for software development focusing on models and model transformation. One of its models is the computation independent model, which describes the system environment and requirements. Representing this model and transforming it into a platform independent model typically involves Requirements Engineering approaches and diagrams. However, it is not clear how Requirements Engineering concepts are related to MDA models. To improve the understanding of MDA and to define which artifacts are expected from a Requirements Engineering perspective, this paper proposes mapping a requirements reference model, the WRSPM model, and Model-Driven Architecture models.

Early Verification of Computer Systems Temporal Properties

In early moments of computer systems development, computer engineers typically draw interaction diagrams, occasionally annotated with timing constraints, to reason about the specification of the system behavior. One of the most popular of these diagrams is the Message Sequence Chart (MSC). However, not always does the intended behavior described by MSCs correspond to their actual behavior. To help the formal verification of their actual behavior, i.e. their temporal properties, this paper describes an interpretation of basic timed MSCs in a temporal framework that formally represents, in a unified model, both the qualitative and the metric temporal information conveyed in these intuitive diagrams. The framework solves the verification problems in polynomial time and lays the foundation of an automatic tool.