Ana Gabriela Garis

Translating between Alloy specifications and UML class diagrams annotated with OCL

Model-driven engineering (MDE) is a software engineering approach based on model transformations at different abstraction levels. It prescribes the development of software by successively transforming the models from abstract (specifications) to more concrete ones (code). Alloy is an increasingly popular lightweight formal specification language that supports automatic verification. Unfortunately, its widespread industrial adoption is hampered by the lack of an ecosystem of MDE tools, namely code generators. This paper presents a model transformation from Alloy to UML class diagrams annotated with OCL (UML+OCL) and shows how an existing transformation from UML+OCL to Alloy can be improved to handle dynamic issues. The proposed bidirectional transformation enables a smooth integration of Alloy in the current MDE contexts, by allowing UML+OCL specifications to be transformed to Alloy for validation and verification, to correct and possibly refine them inside Alloy, and to translate them back to UML+OCL for sharing with stakeholders or to reuse current model-driven architecture tools to refine them toward code.

Defining Patterns Using UML Profiles

Sometimes, UML is not enough expressive to describe patterns property. UML profiles allow extending UML syntax and semantic for modeling elements of particular domains. As profiles extend UML vocabulary, and design patterns define for designers a common vocabulary, so it is possible using profile for defining a pattern vocabulary in UML. Profiles can be used for solve particular problems in different domains. This work shows the way for defining design patterns with profile, proposing architecture in levels. It shows how the definition of a profile for a particular pattern is, and how an UML tool can be enough for introduce profile for patterns. It analyzes the advantages of using profiles to define, document, and visualize design patterns.

Translating alloy specifications to UML class diagrams annotated with OCL

Model-Driven Engineering (MDE) is a Software Engineering approach based on model transformations at different abstraction levels. It prescribes the development of software by successively transforming models from abstract (specifications) to more concrete ones (code). Alloy is an increasingly popular lightweight formal specification language that supports automatic verification. Unfortunately, its widespread industrial adoption is hampered by the lack of an ecosystem of MDE tools, namely code generators. This paper presents a model transformation between Alloy and UML Class Diagrams annotated with OCL. The proposed transformation enables current UML-based tools to also be applied to Alloy specifications, thus unleashing its potential for MDE.

Specifying UML protocol state machines in alloy

A UML Protocol State Machine (PSM) is a behavioral diagram for the specification of the external behavior of a class, interface or component. PSMs have been used in the software development process for different purposes, such as requirements analysis and testing. However, like other UML diagrams, they are often difficult to validate and verify, specially when combined with other artifacts, such as Object Constraint Language (OCL) specifications. This drawback can be overcome by application of an off-the-shelf formal method, namely one supporting automatic validation and verification. Among those, we have the increasingly popular Alloy, based on a simple relational flavor of first-order logic. This paper presents a model transformation from PSMs, optionally complemented with OCL specifications, to Alloy. Not only it enables automatic verification and validation of PSMs, but also a smooth integration of Alloy in current software development practices.

Model Checking LTL Formulae in RAISE with FDR

The Raise Specification Language (RSL) is a modeling language which supports various specification styles. To apply model checking to RSL concurrent descriptions, we translate RSL specifications into the input language CSPM of FDR. FDR is the model checker for the process algebra CSP. First, we define a syntactic and semantic translation from the concurrent applicative subset of RSL to CSPM, and show that this translation is a strong bisimulation which preserves properties such as traces and deadlock. Consequently, results obtained by refinement checks in FDR are sound for the original RSL descriptions. Second, RSL uses Linear Temporal Logic (LTL) to specify desired properties, but FDR does not support LTL. LTL formulas may be translated to CSP test processes in order to check them with FDR. We build a tool which automates the translation of RSL specifications into CSPM and translates LTL formulas to CSP processes, enabling the model checking of LTL formulas over RSL descriptions with FDR.

Validación de Patrones de Diseño de Comportamiento a través de Perfiles UML: Observer, un caso de estudio

Resumen. Los patrones de diseño describen soluciones a problemas recurrentes en la ingeniería de software, proporcionando un importante instrumento para la reutilización de software. En particular, los Patrones de Diseño de Comportamiento (según la clasificación Gof), abordan la especificación de las características dinámicas. Tanto los perfiles UML (por sus siglas en inglés, Unified Modeling Language) como el lenguaje OCL (por sus siglas en inglés, Object Constraint Language) se pueden utilizar como mecanismos para la formalización de los patrones de diseño de comportamiento. El presente trabajo presenta un enfoque para la validación de patrones de comportamiento haciendo uso de perfiles UML y lenguajes OCL, en diagramas estáticos y dinámicos UML.

Defining OCL constraints for the Proxy Design Pattern Profile

Profiles allow extend UML vocabulary and the design patterns define a common vocabulary for software designers, therefore it is possible to use profile to define a pattern vocabulary in UML. If profiles are used to represent patterns then it is not required to define a special notation neither a particular CASE tool for patterns (UML tool is used). Three mechanisms are in the profiles: stereotypes, tag values and constraints. Stereotypes extend the UML vocabulary and it is possible to associate to it tag values and constraints. When these elements are introduced in models; patterns can be clearly visualized, software developers improve communication and establish a common vocabulary. Also profiles allow add information to the model to transform it to other models. OCL (Object Constraint Language) constraints are semantic restrictions added to UML elements. This work shows a way in which OCL constraints are used to define semantic restrictions over stereotypes included in a profile of pattern. The definition of OCL constraints for proxy design pattern is shown as an example of our proposal. An interaction between users and UML tool is proposed for solving the loss generality when OCL constrains are imposed.