Manoli Albert

Development of Web Applications from Web Enhanced Conceptual Schemas

This work presents an OO software production method that defines a systematic process for conceptual modelling of web applications. The paper discusses a set of minimum primitives to capture the essentials of dynamic web applications and it discusses how to introduce them in a classical model-centered OO method that provides systematic code generation. Finally, the paper presents some ideas to extend this generation process for developing web solutions taking as an input these web enhanced conceptual schemas.

Implementing UML association, aggregation, and composition: a particular interpretation based on a multidimensional framework

This work presents a code generation process that systematically obtains the implementation of the UML association, aggregation and composition concepts in the context of the OO-Method (an OO automated software production method). A multidimensional framework, which identifies a set of basic properties, allows us to characterize association relationships in the OO conceptual modelling. By applying this framework, we provide a particular interpretation of the UML association, aggregation and composition concepts for the OO-Method. Once we have defined a clear semantics for these concepts, we introduce a code generation strategy that obtains the implementation of these abstractions depending on the value of the framework dimensions. This strategy can be applied to current OO development methods in order to systematize the software production process in model-driven approaches.

Generating operation specifications from UML class diagrams: A model transformation approach

One of the more tedious and complex tasks during the specification of conceptual schemas (CSs) is modeling the operations that define the system behavior. This paper aims to simplify this task by providing a method that automatically generates a set of basic operations that complement the static aspects of the CS and suffice to perform all typical life-cycle create/update/delete changes on the population of the elements of the CS. Our method guarantees that the generated operations are executable, i.e. their executions produce a consistent state wrt the most typical structural constraints that can be defined in CSs (e.g. multiplicity constraints). In particular, our method takes as input a CS expressed as a Unified Modeling Language (UML) class diagram (optionally defined using a profile to enrich the specification of associations) and generates an extended version of the CS that includes all necessary operations to start operating the system. If desired, these basic operations can be later used as building blocks for creating more complex ones. We show the formalization and implementation of our method by means of model-to-model transformations. Our approach is particularly relevant in the context of Model Driven Development approaches.

Model to text transformation in practice: generating code from rich associations specifications

This work presents a model to code transformation where extended UML association specifications are transformed into C# code. In order to define this transformation the work uses a conceptual framework for specifying association relationships that extends the UML proposal. We define a set of transformation rules for generating the C# code. The generated code extends an implementation framework that defines a design structure to implement the association abstraction. The transformation takes as input models those which are specified using the conceptual framework. Transformations have been implemented in the Eclipse environment using the EMF and MOFScript tools.

Automatic generation of basic behavior schemas from UML class diagrams

The specification of a software system must include all relevant static and dynamic aspects of the domain. Dynamic aspects are usually specified by means of a behavioral schema consisting of a set of system operations that the user may execute to update the system state. To be useful, such a set must be complete (i.e. through these operations, users should be able to modify the population of all elements in the class diagram) and executable (i.e. for each operation, there must exist a system state over which the operation can be successfully applied). A manual specification of these operations is an error-prone and time-consuming activity. Therefore, the aim of this paper is to present a strategy for the automatic generation of a basic behavior schema. Operations in the schema are drawn from the static aspects of the domain as defined in the UML class diagram and take into account possible dependencies among them to ensure the completeness and executability of the operations. We believe our approach is especially useful in a Model-Driven Development setting, where the full implementation of the system is derived from its specification. In this context, our approach facilitates the definition of the behavioral specification and ensures its quality obtaining, as a result, an improved code generation phase.

A methodological framework and software infrastructure for the construction of software production methods

The theory of Method Engineering becomes increasingly solid, but very few engineering tools have been developed to support the application of its research results. To overcome this limitation, this paper presents a methodological framework based on Model Driven Engineering techniques. The framework provides a method supported by a software platform for the construction of software production methods. This framework covers from the specification of the software production method to the generation of the CASE tool that supports it. This generation process has been semi-automated through model transformations. The CASE tool and the software platform are based on the Eclipse-based MOSKitt tool. The plugin-based architecture and the integrated modelling tools included in the MOSKitt tool turn it into a suitable software platform to support our proposal. To validate the proposal we have applied the framework to a case study.

Turning Method Engineering Support into Reality

The Situational Method Engineering (SME) discipline emerged two decades ago to face up to the challenge of the in-house definition of software production methods and the construction of the corresponding supporting tools. However, nowadays most of the existent proposals only focus on one of the phases of the SME lifecycle. In order to fill this gap, in this paper we present a methodological framework that equally encompasses two of these phases, which refer to the method design and implementation. In order to support them in an effective manner, we advocate for the use of the Model Driven Development (MDD) paradigm. Applying these ideas, the framework has been defined on top of a MDD infrastructure based on meta-modeling and model transformation techniques. In addition, we provide implementation details of the framework in an Eclipse-based modeling platform, namely MOSKitt.

A Model-Driven Approach for the Design and Implementation of Software Development Methods

The Situational Method Engineering SME discipline emerged two decades ago to address the challenge of the in-house definition of software development methods and the construction of the corresponding supporting tools. Unfortunately, current SME approaches still have limitations that are hindering their adoption by industry. One of these limitations is that most approaches do not properly encompass two phases of the SME lifecycle, which refer to the method design and the method implementation. To address this limitation, this paper demonstrates how Model-Driven Development MDD techniques can contribute to successfully cover both phases. The proposal is illustrated by a real case study that is currently being used at the Valencian Regional Ministry of Infrastructure, Territory and Environment.

The MOSKitt4ME approach: providing process support in a method engineering context

It is commonly agreed that software developments methods must be defined (or adapted) in-house in order to meet the particular needs of the organizations where they are to be applied. To help meet this challenge, Method Engineering (ME) research aims to provide solutions to efficiently deal with the definition and adaptation of methods, and the construction of the supporting software tools. However, while the product part of methods is fully considered by most ME approaches, the specification and enactment of the process part is less well-supported. To fill this gap, this work presents a methodological ME approach and a Computer-Aided Method Engineering (CAME) environment (MOSKitt4ME) that support the design and implementation of the process part of methods in the context of Model-Driven Engineering. The proposal is illustrated by means of a real case study from the Valencian Regional Ministry of Infrastructure, Territory and Environment.

Extracting knowledge from association relationships to build navigational models

We analyze how the semantics of association relationships in OO conceptual modeling can help to build navigational models for Web applications. The work has been developed in the context of OOWS (a model-driven development method for building Web applications). We study some structural and behavioral properties of those conceptual abstractions in order to extract knowledge to be applied in the construction of navigational models. From this study, a set of design rules has been obtained. These rules help the modeler to build navigational models in a systematic way. The results of this work have improved the modeling and code generation processes introduced by OOWS.