Daniel Riesco

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.

Transformation of BPMN subprocesses based in SPEM using QVT

The workflow automate the business process of a organization. Software process engineering metamodel (SPEM) is a standard as a specification of any software development process. In particular, the software development processes are business process. This work proposes a solution to automate the management of activities of a software development process specified by SPEM. The SPEM activities are transformed in subprocesses of the standard BPMN. The transformation is done by the language query/views/ transformations (QVT). The SPEM, BPMN and QVT have been standardized by Object Management Group (OMG). The target (BPMN) subprocess definition is turned into a specification in a standard language to put in action the workflow processes, such as business process execution language for web services (BPEL4WS) and XML process definition language (XPDL). In this way, the specification of subprocesses of software development process will executed by Workflow engine. The engine automates any software development process specified by SPEM through its transformation into BPMN subprocesses.

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.

Metrics applied to Aspect Oriented Design using UML profiles

The aspect oriented design (AOD) surges from the continuous search of improving the software systems development. The AOD is a methodology that emerges from the aspect oriented programming (AOP), which intents to improve the concerns of the components in software programming; this methodology is based on existing technologies like object oriented (OO). Calculate the resources, is an activity that can improve the software development, because of this there are a big amount of investigation made on metrics. There is a great quantity of works about metrics applied to OO design but a few about metrics applied to AOD. Softwares metrics are ways of qualify the software designs. The application of metrics is essential to qualify the effectiveness of AOD. AOD is a methodology based OO therefore we can applied some metrics traditionally for OO design. This paper shows the definition of the C&K metrics applied to AOD using UML profiles.

A language for behavioural modelling of architectural patterns

The complexity of interactions governing the coordination of loosely-coupled services, which forms the core of current software, brought behavioural issues up to the front of architectural concerns. This paper takes such a challenge seriously by lifting typical behaviour modelling techniques to the specification of both types and instances of architectural patterns in which the later ones are connected by ports that behave according to a water flow metaphor. A specific language is introduced for this purpose as well as a translator to mCRL2 so that the simulation and analysis techniques available in the corresponding toolset can be used to reason about (the behavioural layer of) software architectures. The approach is illustrated in a few examples.

Integrating OCL expressions into RSL specifications

In this work, we go a step further in the integration of the RAISE specification language (RSL) and the unified modeling language (UML). On the basis of our previous work -where we showed how to derive an initial formal specification in RSL from a UML class diagram-we propose here the use of set of rules to transform object constraint language (OCL) expressions into RSL expressions. Class diagrams can be enhanced with annotated OCL invariants and the corresponding formalizations in RSL can be obtained. Property verification of the model described by the UML class diagram and OCL invariants can now take place on the derived RSL specification by using reasoning techniques supported by the RAISE method.

Metrics for evaluation of workflow models: An experiment for validation

Due to the dynamism of business, it is very important to support continuous improvement and automation of business processes. The Workflow Management Systems WMS is one of the most significant technologies for such automation. Likewise, the quality of business process models is essential to facilitate understandability and adaptability of models to the constant changes experienced by the processes they represent. Therefore, it is fundamental to have tools to choose from several modeling alternatives, the most appropriate to the business needs. It is also essential to have tools to measure the quality of these models. Therefore, we propose a set of metrics for measuring the quality of workflow models based on their adaptability and understandability. In addition, we introduce the results of the first practical validation of the metrics through a comparative experiment of two Workflow modeling languages: YAWL Vs UML Activity Diagrams 2.0.

An ATL transformation from natural language requirements models to business models of a MDA project

MDA is a software development framework where the core is a set of automatic transformations of models. One of these models, the CIM (Computer Independent Model), is used to define the business process model. Though a complete automatic construction of the CIM is not possible, we have proposed the integration of some natural language requirements models and we have defined a strategy to derive a CIM from these models. In this paper, we present an ATL transformation that implements this strategy to obtain a UML class diagram representing a preliminary CIM from requirements models. This transformation fits with MDA approach.

Transformations from SPEM work sequences to BPMN sequence flows for the automation of software development process

Generally, different companies use distinct software development process. Due to it, OMG has specified an architecture to can define a software development process. This architecture uses a metamodel which is able to be abstracted from particular characteristics and to give the possibility of defining the different software development processes. The Software Process Engineering Metamodel (SPEM) is a metamodel used for describing a concrete software development process. Also, the OMG specify a standardized language to model business processes. This language is called Business Process Modeling Notation (BPMN). In this paper, a formalization of transformations between SPEM and BPMN is specified. The transformations are done using the language of formal specification RSL. One time that we obtain a BPMN specification, it is possible to generate XPDL code or BPEL code. The workflow technology can use this code and execute the process. It allows automate the business process, but in this case, the process is a software development process. Consider that workflow technologies automate, totally or partially, the business processes enabling an interaction between men and machines, under an established set of procedural rules. Such technologies use standard languages, like BPEL or XPDL, to specify the business process which is executed in a workflow engine. The BPMN allows to generate BPEL or XPDL codes. Therefore, if we specify a software development process using SPEM, we will automate this process using the workflow technology due to transformations between SPEM and BPMN done in this paper.