Pedro J. Clemente

Modernization of legacy web applications into rich internet applications

In the last years one of the main concerns of the software industry has been to reengineer their legacy Web Applications (WAs) to take advantage of the benefits introduced by Rich Internet Applications (RIAs), such as enhanced user interaction and network bandwith optimization. However, those reengineering processes have been traditionally performed in an ad-hoc manner, resulting in very expensive and error-prone projects. This situation is partly motivated by the fact that most of the legacy WAs were developed before Model-Driven Development (MDD) approaches became mainstream. Then maintenance activities of those legacy WAs have not been yet incorporated to a MDA development lifecycle. OMG Architecture Driven Modernization (ADM) advocates for applying MDD principles to formalize and standardize those reengineering processes with modernization purposes. In this paper we outline an ADM-based WA-to-RIA modernization process, highlighting the special characteristics of this modernization scenario.

How to deal with non-functional properties in web service development

Web Service technologies offer a successful way for interoperability among web applications. However, current approaches do not propose an acceptable method to decouple non-functional properties from Web Service implementations, leaving as a result a large amount of code scattered and tangled all over the application, thus raising problems at design, implementation, maintenance and evolution. It is the aim of this paper to describe how aspect-oriented techniques allow these properties to be easily modularized and reused. We will also analyse how information about properties can be added in the WSDL file, in order to keep clients informed of the characteristics of the service they are going to use. Finally, we will demonstrate how the client will be able to choose which optional properties have to be applied in his invocation in a transparent way, automatically generating the necessary changes in his code in a modularized and decoupled way.

AspectCCM: an aspect-oriented extension of the CORBA Component Model

Component based software engineering (CBSE) and aspect oriented programming (AOP) are two disciplines of software engineering which have been generating a great deal of interest in recent years. From the CBSE point of view, the building of applications becomes a process of assembling independent and reusable software modules called components. However, the necessary dependency description among components and its latter implementation causes the appearance of crosscutting, a problem that AOP resolves adequately. Aspect orientated programming allows programmers to express in a separate form the different aspects that intervene in an application. These aspects are composed later adequately. This paper analyses the problem of crosscutting that is produced during component development at one of the last component-based development platforms, as is the CORBA Component Model (CCM), and proposes an extension for this platform. This CCM extension has been named AspectCCM.

A model-driven approach for reusing tests in smart home systems

The continuous advances of ubiquitous and pervasive computing have contributed to the successful increase in smart home systems. However, usually these systems are developed at a lower abstraction level very tied to specific technologies. Model-driven approaches have emerged to tackle the design of these systems, improving their reusability and maintainability and decreasing their complexity. Nevertheless, the existing model-driven approaches to develop smart home systems do not cover the whole development process, and testing activities are still relegated to the final programming stages, reducing their reusability for different technologies or platforms. Some approaches have proposed the incorporation of testing activities into the model-driven process. However, the test models defined are very tied to the specific systems and they must be redesigned for every new system to test, reducing thus the reusability of the test behavior. In this setting, this paper presents a process to define reusable tests that may be automatically applied to different smart home systems. The process is integrated into a whole MDD approach that provides support for the modeling of smart home systems at two different abstraction levels, ensuring the reusability of tests also for different smart home platforms.

A model-driven process to modernize legacy web applications based on service oriented architectures

Web applications (WAs) developed by companies are usually adapted to cover new business rules due to continuous changes in the organization requirements. Service Oriented Architectures (SOA) come to the scene to give a solution to these continuous changes providing a way to align business rules with underlying services. This is why there is a current trend to migrate legacy web applications to new SOAs. However, this migration requires the identification, publication and orchestration of the underlying service layer. These are complex tasks usually carried out ad hoc by manually defining and developing the service layer and its coordination. Moreover, these processes are usually performed at a low abstraction level, close to code, hindering reusability and maintainability of the obtained system. Model-Driven techniques aim at tackling the complexity of these processes since models drive the migration from a higher abstraction level. In that sense, this paper presents a Model-Driven systematic and semiautomatic process to modernize legacy WAs to SOAs. It also relies on techniques that are used to identify and classify the services offered by the different WAs of the organization. On the one hand, conceptual representations of the WAs and the service oriented architecture are obtained. On the other hand, the underlying services of the web applications are generated from models so that they may be offered as an interoperable service layer, which may be aligned with the company business rules and orchestrated with external services.

An MDA approach to develop systems based on components and aspects

Model-Driven Development and Aspect Oriented Software Development offer excellent support to modular reasoning, which can be used to develop component-based systems favouring a better software evolution. A development process based on Model Driven Architecture (MDA) to integrate components and aspects is presented in this paper. In order to do this, a UML profile to model systems based on components and aspects is suggested. Then a set of model-to-model transformations at design level including the weaving among components and aspects, allow us to obtain the final system based on UML Profile for the Corba Component Model. The CCM code for the final systems is obtained by a model-to-code transformation. A specific tool (Eclipse plugin) has been developed to support the software development based on Aspect Component Based Software Development (ACBSE).

HAAIS-DSL: DSL to develop home automation and ambient intelligence systems

Domain Specific Language (DSL) is an emergent software engineering discipline that allows software architects to model systems based on the elements of a specific domain. Home Automation (HA) and Ambient Intelligence (AmI) are examples of specific domains and they are considered the key elements in the future of home development. However, software for these domains is usually hand coded based on embedded devices and specific implementation technologies and frameworks. In this paper we present a Model Driven Development (MDD) approach to develop software systems for HA and AmI. A Domain Specific Language has been designed to model the architecture of these kinds of systems. Then, taking as input the architecture models, a set of model transformations allows code and configuration generation for a specific device platform like KNX/EIB (European Installation Bus).

CoordMaude: Simplifying Formal Coordination Specifications of Cooperation Environments

Abstract Developing concurrent applications in cooperative environments is an arduous task. This is mainly due to the fact that it is very difficult to specify the synchronized interaction between the entities composing the system. Using coordination models makes this task easier. The latest trends in this area suggest that to manage the successful implementation of complex systems, coordination models must support some key features regarding the coordination constraints: their separated specification, their unanticipated evolution and their dynamic change. However, supporting these features is not only a technical challenge: it must be also guaranteed that the application of a separately specified coordination pattern to a set of encapsulated entities, or the change of the coordination constraints in an already running software system will not produce semantic errors. This is just the problem focused in this paper. In particular, a method for generating formal interpretable specifications reproducing coordinated environments is presented. The method is based on the Coordinated Roles coordination model and makes use of Maude as a formal language. The benefits obtained are: (i) easy specification using the coordination model syntax, (ii) automatic generation of the corresponding formal specification and (iii) simulation of system behaviour.

Generation of WebML hypertext models from legacy Web Applications

In the last years one of the main concerns of the software industry has been to reengineer their legacy Web Applications (WAs) to take advantage of the benefits introduced by Rich Internet Applications (RIAs). In this context, Model Driven (MD) Web Engineering approaches have been extended with new modeling primitives to obtain the benefits provided by RIA features. However, during the last decade, widespread language-specific Web frameworks have supported actual Web system development. In this paper we present a MD reverse engineering process to obtain a conceptual representation of the navigational concern of a legacy Web application (LWA), as an initial step within a LWA-to-RIA modernization process. WebML is selected as the target MD Web Engineering approach.

Extracting navigational models from struts-based web applications

Nowadays, there is a current trend in software industry to modernize traditional Web Applications (WAs) to Rich Internet Applications (RIAs). In this context, Model Driven (MD) Web Engineering approaches have been extended with new modeling primitives to obtain the benefits provided by RIA features. However, during the last decade, widespread language-specific Web frameworks have supported actual Web system development. In this paper we present a MD modernization process to obtain RIAs from legacy WAs based on such frameworks. MD techniques reduce complexity and improve reusability of the process. Being navigational information of upmost importance for the modernization process of a Web application, the paper is focused on presenting the metamodel defined to extract navigational information from the legacy system, the models obtained and the projection of these models to a particular MD Web Engineering methodology.