Kyriakos Anastasakis

UML2Alloy: a challenging model transformation

Alloy is a formal language, which has been applied to modelling of systems in a wide range of application domains. It is supported by Alloy Analyzer, a tool, which allows fully automated analysis. As a result, creating Alloy code from a UML model provides the opportunity to exploit analysis capabilities of the Alloy Analyzer to discover possible design flaws at early stages of the software development. Our research makes use of model based techniques for the automated transformation of UML class diagrams with OCL constraints to Alloy code. The paper demonstrates challenging aspects of the model transformation, which originate in fundamental differences between UML and Alloy. We shall discuss some of the differences and illustrate their implications on the model transformation process. The presented approach is explained via an example of a secure e-business system.

On challenges of model transformation from UML to Alloy

The Unified Modeling Language (UML) is the de facto language used in the industry for software specifications. Once an application has been specified, Model Driven Architecture (MDA) techniques can be applied to generate code from such specifications. Since implementing a system based on a faulty design requires additional cost and effort, it is important to analyse the UML models at earlier stages of the software development lifecycle. This paper focuses on utilizing MDA techniques to deal with the analysis of UML models and identify design faults within a specification. Specifically, we show how UML models can be automatically transformed into Alloy which, in turn, can be automatically analysed by the Alloy Analyzer. The proposed approach relies on MDA techniques to transform UML models to Alloy. This paper reports on the challenges of the model transformation from UML class diagrams and OCL to Alloy. Those issues are caused by fundamental differences in the design philosophy of UML and Alloy. To facilitate better the representation of Alloy concepts in the UML, the paper draws on the lessons learnt and presents a UML profile for Alloy.

An aspect-oriented methodology for designing secure applications

We propose a methodology, based on aspect-oriented modeling (AOM), for incorporating security mechanisms in an application. The functionality of the application is described using the primary model and the attacks are specified using aspects. The attack aspect is composed with the primary model to obtain the misuse model. The misuse model describes how much the application can be compromised. If the results are unacceptable, then some security mechanism must be incorporated into the application. The security mechanism, modeled as security aspect, is composed with the primary model to obtain the security-treated model. The security-treated model is analyzed to give assurance that it is resilient to the attack.

From UML to Alloy and back again

Model Transformations can be used to bridge the gap between design and analysis technical spaces by creating tools that allow a model produced by a designer to be transformed to a model suitable for conducting automated analysis. Such model transformations aim at allowing the designer to benefit from the capabilities provided by analysis tools and languages. If the designer who is not a formal method expert is to benefit from such tools, the outcome of the analysis should also be transformed to the language used in the design domain. This paper presents a study involving UML2Alloy, a tool for transforming UML models in form of UML class diagrams which are augmented with OCL constraints, to Alloy. The conversion allows analysis of UML models via Alloy, to identify consistencies in those UML models. We present a method of automatically creating a model transformation based on the original UML2Alloy transformation. The new transformation converts Alloy instances into the UML equivalent object diagram. The current technique is presented with the help of an example, along with a prototype implementation using the QVT standard.

Ensuring spatio-temporal access control for real-world applications

Traditional access control models, such as Role-Based Access Control (RBAC), do not take into account contextual information, such as location and time, for making access decisions. Consequently, they are inadequate for specifying the access control needs of many complex real-world applications, such as the Dengue Decision Support (DDS) that we discuss in this paper. We need to ensure that such applications are adequately protected using emerging access control models. This requires us to represent the application and its access control requirements in a formal specification language. We choose the Unified Modeling Language (UML) for this purpose, since UML is becoming the defacto specification language in the software industry. We need to analyze this formal specification to get assurance that the application is adequately protected. Manual analysis is error-prone and tedious. Thus, we need automated tools for verification of UML models. Towards this end, we propose that the UML models be converted to Alloy. Alloy is based on first-order logic, has a software infrastructure that supports automated analysis, and has been used for the verification of real-world applications. We show how to convert the UML models to Alloy and verify the resulting model using the Alloy Analyzer which has embedded SAT-solvers. The results from the Alloy Analyzer will help uncover the flaws in the specification and help us refine the application and its access control requirements.

MDA and analysis of web applications

Enterprise systems are mission critical. As a result, ensuring their correctness is of primary concern. This paper aids to the analysis of Web applications, focusing on the aspects related to the interaction of business logic and Web browsers. The method adopted is based on the Model Driven Architecture. First, the Platform Independent Model of Web applications is refined to create a new model called Abstract Description of Interaction (ADI). An ADI is a UML class diagram annotated with OCL statements to represent an abstraction of the interaction between the thin client and the business logic. Secondly, the ADI model is automatically transferred to an Alloy model and analysed using the Alloy Analyser.

From UML to alloy and back again

Model transformations can be used to bridge the gap between design and analysis technical spaces by creating tools that allow a model produced by a designer to be transformed to a model suitable for conducting automated analysis. Such model transformations aim at allowing the designer to benefit from the capabilities provided by analysis tools and languages. If the designer who is not a formal method expert is to benefit from such tools, the outcome of the analysis should also be transformed to the language used in the design domain. This paper presents a study involving UML2Alloy, a tool for transforming UML models in form of UML Class Diagrams which are augmented with OCL constraints, to Alloy. The conversion allows analysis of UML models via Alloy, to identify consistencies in those UML models. We present a method of automatically creating a model transformation based on the original UML2Alloy transformation. The new transformation converts Alloy instances into the UML equivalent Object Diagram. The current technique is presented with the help of an example, along with a prototype implementation using the QVT standard.

On a chain of transformations for generating alloy from NL constraints

Multi-Paradigm Modelling uses models from multiple domains to leverage the tools, techniques and expertise provided by each of the individual domains. Recent advances in model transformation technology allow automated production of one model from another to improve the application of multi-paradigm techniques. Systems development starts with the requirements gathering phase, which usually comprises of a textual description of the system requirements provided in Natural Language (NL). It is therefore evident that there is a clear scope for incorporating NL Processing techniques in Multi-Paradigm Modeling. However, using NLP methods pushes the boundaries of Multi-Paradigm Modeling to an extreme; indeed NLs are inherently ambiguous and open to interpretation. In this paper, we propose a novel approach based on standards (such as SBVR) that can cope with syntactic and semantic ambiguities in NL specifications and can map them to formal languages such as Alloy. The tool implementing our approach is currently the only available tool for translating NL specifications to formal languages such as Alloy, etc.