An active-architecture approach to COTS integration

Commercial off-the-shelf (COTS) software products are increasingly used as standard components within integrated information systems. This creates challenges since both their developers and source code are not usually available, and the ongoing development of COTS cannot be predicted. The ArchWare Framework approach recognises COTS products as part of the ambient environment of an information system and therefore an important part of development is incorporating COTS as effective system components. This integration of COTS components, and the composition of components, is captured by an active architecture model which changes as the system evolves. Indeed the architecture modelling language used enables it to express the monitoring and evolution of a system. This active architecture model is structured using control system principles. By modelling both integration and evolution it can guide the system’s response to both predicted and emergent changes that arise from the use of COTS products.Publisher PDFPeer reviewe

Model-Driven Development of Aspect-Oriented Software Architectures

The work presented in this thesis of master is an approach that takes advantage of the Model-Driven Development approach for developing aspect-oriented software architectures. A complete MDD support for the PRISMA approach is defined by providing code generation, verification and reusability properties.Pérez Benedí, J. (2007). Model-Driven Development of Aspect-Oriented Software Architectures. http://hdl.handle.net/10251/12451Archivo delegad

Adapting Component-based User Interfaces at Runtime using Observers

Model-driven engineering (MDE) already plays a key role in Human-Computer Interaction for the automatic generation of end-user interfaces from their abstract and platform-independent specifications. Moreover, MDE techniques and tools are proving to be very useful for adapting at runtime the final user interfaces according to the current context properties: platform, user roles, component states, etc. In this paper we propose a mechanism to adapt user interfaces at runtime. These user interfaces will be (re)generated through the dynamic composition of user-interface software components, depending on the observed properties of the environment and of the components’ behaviour.Ministerio de Ciencia e Innovación TIN2010-15588Ministerio de Ciencia e Innovación TRA2009-0309Ministerio de Ciencia e Innovación TIN2008-00889-EMinisterio de Ciencia e Innovación TIN2008-03107Junta de Andalucía TIC-6114Junta de Andalucía P07-TIC-0318

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.Ministerio de Ciencia e Innovación TIN2010-15588Ministerio de Ciencia e Innovación TRA2009-0309Ministerio de Ciencia e Innovación TIN2008-03107Junta de Andalucía TIC-611

Composition and Self-Adaptation of Service-Based Systems with Feature Models

The adoption of mechanisms for reusing software in pervasive systems has not yet become standard practice. This is because the use of pre-existing software requires the selection, composition and adaptation of prefabricated software parts, as well as the management of some complex problems such as guaranteeing high levels of efficiency and safety in critical domains. In addition to the wide variety of services, pervasive systems are composed of many networked heterogeneous devices with embedded software. In this work, we promote the safe reuse of services in service-based systems using two complementary technologies, Service-Oriented Architecture and Software Product Lines. In order to do this, we extend both the service discovery and composition processes defined in the DAMASCo framework, which currently does not deal with the service variability that constitutes pervasive systems. We use feature models to represent the variability and to self-adapt the services during the composition in a safe way taking context changes into consideration. We illustrate our proposal with a case study related to the driving domain of an Intelligent Transportation System, handling the context information of the environment.Work partially supported by the projects TIN2008-05932, TIN2008-01942, TIN2012-35669, TIN2012-34840 and CSD2007-0004 funded by Spanish Ministry of Economy and Competitiveness and FEDER; P09-TIC-05231 and P11-TIC-7659 funded by Andalusian Government; and FP7-317731 funded by EU. Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tec

Evolving Mashup Interfaces using a Distributed Machine Learning and Model Transformation Methodology

Nowadays users access information services at any time and in any place. Providing an intelligent user interface which adapts dynamically to the users’ requirements is essential in information systems. Conventionally, systems are constructed at the design time according to an initial structure and requirements. The effect of the passage of time and changes in users, applications and environment is that the systems cannot always satisfy the user’s requirements. In this paper a methodology is proposed to allow mashup user interfaces to be intelligent and evolve over time by using computational techniques like machine learning over huge amounts of heterogeneous data, known as big data, and model-driven engineering techniques as model transformations. The aim is to generate new ways of adapting the interface to the user’s needs, using information about user’s interaction and the environment

Composing Model Transformations at Runtime: an approach for adapting Component-based User Interfaces

Nowadays, large part of the efforts in software development are focused on achieving systems with an as high as possible level of adaptation. With the traditional technique of model-driven development this can be largely accomplished. The inconvenience of these techniques however, is that the models are usually manipulated at design-time by means of fixed transformation. Furthermore, the transformations that manipulate these models cannot change dynamically according to the current execution context. This paper presents a transformation pattern aimed to adapt architectural models at runtime, this means that these models may change dynamically at runtime. The transformations that produce this model adaptation are not fixed, but dynamically composed by selecting the most appropriate set of rules from those available in a repository. As an example scenario for the application of these transformations, we chose architectural models representing component-based UIs

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

Aspect-Oriented Programming

Aspect-oriented programming is a promising idea that can improve the quality of software by reduce the problem of code tangling and improving the separation of concerns. At ECOOP'97, the first AOP workshop brought together a number of researchers interested in aspect-orientation. At ECOOP'98, during the second AOP workshop the participants reported on progress in some research topics and raised more issues that were further discussed. \ud \ud This year, the ideas and concepts of AOP have been spread and adopted more widely, and, accordingly, the workshop received many submissions covering areas from design and application of aspects to design and implementation of aspect languages