Javier Criado

A Model Transformation Approach for Automatic Composition of COTS User Interfaces in Web-Based Information Systems

Globalization of the information and the Knowledge Society requires the modernization of Web-based Information Systems (WIS) into evolutive and adaptable user interfaces. Today, WIS user interfaces are built following traditional development paradigms. This article is inspired on a Model-Driven Development (MDD) perspective to produce runtime automatic composition of user interfaces from model and metamodel representations of widgets-type COTS interface components architectures and model transformation.

Toward the adaptation of component-based architectures by model transformation: behind smart user interfaces

Graphical user interfaces are not always developed for remaining static. There are GUIs with the need of implementing some variability mechanisms. Component‐based GUIs are an ideal target for incorporating this kind of operations, because they can adapt their functionality at run‐time when their structure is updated by adding or removing components or by modifying the relationships between them. Mashup user interfaces are a good example of this type of GUI, and they allow to combine services through the assembly of graphical components. We intend to adapt component‐based user interfaces for obtaining smart user interfaces. With this goal, our proposal attempts to adapt abstract component‐based architectures by using model transformation. Our aim is to generate at run‐time a dynamic model transformation, because the rules describing their behavior are not pre‐set but are selected from a repository depending on the context. The proposal describes an adaptation schema based on model transformation providing a solution to this dynamic transformation. Context information is processed to select at run‐time a rule subset from a repository. Selected rules are used to generate, through a higher‐order transformation, the dynamic model transformation. This approach has been tested through a case study which applies different repositories to the same architecture and context. Moreover, a web tool has been developed for validation and demonstration of its applicability. The novelty of our proposal arises from the adaptation schema that creates a non pre‐set transformation, which enables the dynamic adaptation of component‐based architectures. Copyright

User Interface Composition with COTS-UI and Trading Approaches: Application for Web-Based Environmental Information Systems

Due to the globalization of the information and knowledge society on the Internet, modern Web-based Information Systems (WIS) must be flexible and prepared to be easily accessible and manageable in real-time. In recent times it has received a special interest the globalization of information through a common vocabulary (i.e., ontologies), and the standardized way in which information is retrieved on the Web (i.e., powerful search engines, and intelligent software agents). These same principles of globalization and standardization should also be valid for the user interfaces of the WIS, but they are built on traditional development paradigms. In this paper we present an approach to reduce the gap of globalization/standardization in the generation of WIS user interfaces by using a real-time “bottom-up” composition perspective with COTS-interface components (type interface widgets) and trading services.

Runtime adaptation of architectural models: an approach for adapting user interfaces

Traditional techniques of model-driven development usually concern with the production of non-executable models. These models are usually manipulated at design-time by means of fixed model transformations. However, in some situations, models need to be transformed at runtime. Moreover, the transformations handling these models could be provided with a dynamic behavior enabling the adaptation to the current execution context and requirements. In this vein, this paper defines a transformation pattern designed for flexible model transformation that can be dynamically composed by selecting the appropriate transformation rules from a rule repository, which is also represented by a model. The rules in the repository are updated at each step of adaptation to improve later rule selection. We chose the domain of user interfaces, specified as component-based architectural models, as our case study.

An MDE Approach for Runtime Monitoring and Adapting Component-Based Systems: Application to WIMP User Interface Architectures

In certain systems, software must be adapted at runtime to the requirements and changes occurring in the context. A strategy to achieve this goal is to model such systems as software architectures making use of the Component-based Software Engineering (CBSE). Thus, the system can be adapted through the reconfiguration of the software architectures. In this paper we present a schema for the adaptation of software architectures at runtime based on the system context observation. The software system is defined by means of architectural models at two levels: abstract and concrete. We use a trading process to regenerate concrete architectural models from their abstract definitions and a component repository. We also use Model-Driven Engineering (MDE) techniques to transform at runtime such models in order to achieve the system adaptation to the monitored context by using observers. This article describes a case study of component-based user interfaces to illustrate our approach.

A cloud service for COTS component-based architectures

Software architecture management, especially in component-based web user interfaces is important to enhance their run-time accessibility, dynamics and management. The cloud offers some excellent mechanisms for this kind of systems, since software can be managed remotely, easy availability of the resources is ensured and mass storage is possible. This article presents an infrastructure solution, based on the use of web services and cloud computing, for managing COTS-based architectures. Cloud services for deploying component-based architecturesComponent-based architectures for building user interfaces at run-timeComponents and interfaces, models, and COTSget-as-a-serviceAn infrastructure model based on a three-tier architecture to deploy user interfacesIntegration of CBSE, MDE and cloud computing technologies

Resolving Platform Specific Models at Runtime Using an MDE-Based Trading Approach

Dynamic service composition provides versatility and flexibility features for those component-based software systems which need to self-adapt themselves at runtime. For this purpose, services must be located in repositories from which they will be selected to compose the final software architecture. Modern component-based software engineering and model-driven engineering techniques are being used in this field to design the repositories and the other elements (such as component specifications), and to implement the processes which manage them at runtime. In this article, we present an approach for the runtime generation of Platform Specific Models (PSMs) from abstract definitions contained in their corresponding Platform Independent Models (PIMs). The process of generating the PSM models is inspired by the selection processes of Commercial Off-The-Shelf (COTS) components, but incorporating a heuristic for ranking the architectural configurations. This trading process has been applied in the domain of component-based graphical user interfaces that need to be reconfigured at runtime.

Enabling the Reuse of Stored Model Transformations Through Annotations

With the increasing adoption of MDE, model transformations, one of its core concepts together with metamodeling, stand out as a valuable asset. Therefore, a mechanism to annotate and store existing model transformations appears as a critical need for their efficient exploitation and reuse. Unfortunately, although several reuse mechanisms have been proposed for software artifacts in general and models in particular, none of them is specially tailored to the domain of model transformations. In order to fill this gap, we present here such a mechanism. Our approach is composed by two elements 1 a new DSL specially conceived for describing model transformations in terms of their functional and non-functional properties 2 a semi-automatic process for annotating and querying repositories of model transformations using as criteria the properties of our DSL. We validate the feasibility of our approach through a prototype implementation that integrates our approach in a GitHub repository.

Open-Environmental Ontology Modeling

Current open information systems need formal semantic definitions to describe and handle information which is dealt within different interaction environments such as human-to-human, human-to-computer, and computer-to-computer interactions. This paper provides a semantic definition of the knowledge used by environmental management information systems. We describe an ontological model in UML class diagrams and present a formalization of the ontology in first-oder logic and encoded in description logic. A model transformation approach is also used to map the UML class diagram elements into web ontology language. A running example is presented to explain the ontological knowledge modeling of EMIS SOLERES cartography and satellite information.

Semantic Matching of Components at Run-Time in Distributed Environments

Software factories are a key element in Component-Based Software Engineering due to the common space provided for software reuse through repositories of components. These repositories can be developed by third parties in order to be inspected and used by different organizations, and they can also be distributed in different locations. Therefore, there is a need for a trading service that manages all available components. In this paper, we describe a matching process based on syntactic and semantic information of software components. This matching operation is part of a trading service which is in charge of generating configurations of components from architectural definitions. With this aim, the proposed matching allows us to evaluate and score the possible configurations, thus guiding a search process to build the architectural solution which best fulfills an input definition.