Playing MUSIC — building context‐aware and self‐adaptive mobile applications

Although the idea of context‐awareness was introduced almost two decades ago, few mobile software applications are available today that can sense and adapt to their run‐time environment. The development of context‐aware and self‐adaptive applications is complex and few developers have experience in this area. On the basis of several demonstrators built by the joint European research project MUSIC, this paper describes typical context and adaptation features relevant for the development of context‐aware and self‐adaptive mobile applications. We explain how the demonstrators were realised using the open‐source platform MUSIC and present the feedback of the developers of these demonstrators. The main contribution of this paper is to show how the development complexity of context‐aware and self‐adaptive mobile applications can be mastered by using an adaptation framework such as MUSIC. Copyright © 2012 John Wiley & Sons, Ltd.     

Automation of application‐level caching in a seamless way

Meeting performance and scalability requirements while delivering services is a critical issue in web applications. Recently, latency and cost of Internet‐based services are encouraging the use of application‐level caching to continue satisfying users' demands and improve the scalability and availability of origin servers. Application‐level caching, in which developers manually control cached content, has been adopted when traditional forms of caching are insufficient to meet such requirements. Despite its popularity, this level of caching is typically addressed in an ad hoc way, given that it depends on specific details of the application. Furthermore, it forces application developers to reason about a crosscutting concern, which is unrelated to the application business logic. As a result, application‐level caching is a time‐consuming and error‐prone task, becoming a common source of bugs. Among all the issues involved with application‐level caching, the decision of what should be cached must frequently be adjusted to cope with the application evolution and usage, making it a challenging task. In this paper, we introduce an automated caching approach to automatically identify application‐level cache content at runtime by monitoring system execution and adaptively managing caching decisions. Our approach is implemented as a framework that can be seamlessly integrated into new and existing web applications. In addition to the reduction of the effort required from developers to develop a caching solution, an empirical evaluation showed that our approach significantly speeds up and improves hit ratios with improvements ranging from 2.78% to 17.18%.     

Flex‐eWare: a flexible model driven solution for designing and implementing embedded distributed systems

The complexity of modern embedded systems increases as they incorporate new concerns such as distribution and mobility. These new features need to be considered as early as possible in the software development life cycle. Model driven engineering promotes an intensive use of models and is now widely seen as a solution to master the development of complex systems such as embedded ones. Component‐based software engineering is another major trend that gains acceptance in the embedded world because of its properties such as reuse, modularity, and flexibility. This article proposes the Flex‐eWare component model (FCM) for designing and implementing modern embedded systems. The FCM unifies model driven engineering and component‐based software engineering and has been evaluated in several application domains with different requirements: wireless sensor networks, distributed client/server applications, and control systems for electrical devices. This approach highlights a new concept: flexibility points that arise at several stages of the development process, that is, in the model (design phase), in the execution platform, and during the execution itself. This flexibility points are captured with model libraries that can extend the FCM. Copyright © 2011 John Wiley & Sons, Ltd.     

Model‐to‐model and model‐to‐text: looking for the automation of VigilAgent

VigilAgent is a methodology for the development of agent‐oriented monitoring applications that uses agents as the key abstraction elements of the involved models. It has not been developed from scratch, but it reuses fragments from Prometheus and INGENIAS methodologies for modelling tasks and the ICARO framework for implementation purposes. As VigilAgent intends to automate as much as possible the development process, it exploits. Model transformation techniques are one of the key aspects of the model‐driven development approach. A model‐to‐model transformation is used to facilitate the interoperability between Prometheus and INGENIAS methodologies. Also, a model‐to‐text transformation is performed to generate ICARO code from the INGENIAS model. A case study based on access control is used to illustrate the fundamentals of the model‐to‐model and model‐to‐text transformations implemented in VigilAgent.     

Towards a goal‐driven approach to action selection in self‐adaptive software

Self‐adaptive software is a closed‐loop system, since it continuously monitors its context (i.e. environment) and/or self (i.e. software entities) in order to adapt itself properly to changes. We believe that representing adaptation goals explicitly and tracing them at run‐time are helpful in decision making for adaptation. While goal‐driven models are used in requirements engineering, they have not been utilized systematically yet for run‐time adaptation. To address this research gap, this article focuses on the deciding process in self‐adaptive software, and proposes the Goal‐Action‐Attribute Model (GAAM). An action selection mechanism, based on cooperative decision making, is also proposed that uses GAAM to select the appropriate adaptation action(s). The emphasis is on building a light‐weight and scalable run‐time model which needs less design and tuning effort comparing with a typical rule‐based approach. The GAAM and action selection mechanism are evaluated using a set of experiments on a simulated multi‐tier enterprise application, and two sample ordinal and cardinal action preference lists. The evaluation is accomplished based on a systematic design of experiment and a detailed statistical analysis in order to investigate several research questions. The findings are promising, considering the obtained results, and other impacts of the approach on engineering self‐adaptive software. Although, one case study is not enough to generalize the findings, and the proposed mechanism does not always outperform a typical rule‐based approach, less effort, scalability, and flexibility of GAAM are remarkable. Copyright © 2011 John Wiley & Sons, Ltd.     

Using meta‐modeling in design and implementation of component‐based systems: the SOFA case study

To allow efficient and user‐friendly development of a component‐based application, component systems have to provide a rather complex development infrastructure, including a tool for component composition, component repository, and a run‐time infrastructure. In this paper, we present and evaluate benefits of using meta‐modeling during the process of defining a component system and also during creation of the development and run‐time infrastructures. Most of the presented arguments are based on a broad practical experience with designing the component systems SOFA and SOFA 2; the former designed in a classical ad hoc ‘manual’ way, whereas the latter with the help of meta‐modeling. Copyright © 2010 John Wiley & Sons, Ltd.     

An approach for the systematic development of domain‐specific languages

Building tailored software systems for a particular application domain is a complex task. For this reason, domain‐specific languages (DSLs) receive a constantly growing attention in recent years. So far the main focus of DSL research is on case studies and experience reports for the development of individual DSLs, design approaches and implementation techniques for DSLs, and the integration of DSLs with other software development approaches on a technical level. In this paper, we identify and describe the different activities that we conduct when engineering a DSL, and describe how these activities can be combined in order to define a tailored DSL engineering process. Our research results are based on the experiences we gained from multiple different DSL development projects and prototyping experiments. Copyright © 2009 John Wiley & Sons, Ltd.     

A JAVA application framework for scientific software development

This paper presents AIBench (SING group, Ourense, Spain), a JAVA desktop application framework mainly focused on scientific software development, with the goal of improving the productivity of research groups. Following the MVC design pattern, the programmer is able to develop applications using only three types of concepts: operations, data‐typesand views. The framework provides the rest of the functionality present in typical scientific applications, including user parameter requests, logging facilities, multithreading execution, experiment repeatability and graphic user interface generation, among others. The proposed framework is implemented following a plugin‐based architecture, which also allows assembling new applications by the reuse of modules from past development projects. Copyright © 2011 John Wiley & Sons, Ltd.     

Self‐adaptation of service level in distributed systems

Modern distributed systems are diverse and dynamic, and consequently difficult to manage using traditional approaches, which rely on an extensive initial knowledge of the system. On the performance front, these systems often offer multiple opportunities for dynamically degrading or improving service level based on workload intensity, to avoid overload and underload. In this context, we propose a novel approach for building distributed systems capable of autonomously deciding when and how to adapt service level. Our approach limits the knowledge that must be provided manually to a component‐based representation of the system. From this representation, we build and maintain a performance profile, which allows us to (1) identify the most promising adaptations based on workload type and (2) dynamically characterize the intrinsic efficiency of each adaptation based on past attempts. We have successfully implemented and evaluated a prototype of our approach in the context of multi‐tiered application servers. Copyright © 2010 John Wiley & Sons, Ltd.     

A component‐based framework for radio‐astronomical imaging software systems

This paper describes a component‐based framework for radio‐astronomical imaging software systems. We consider optimal re‐use strategies for packages of disparate architectures brought together within a modern component framework. In this practical case study, the legacy codes include both procedural and object‐oriented architectures. We consider also the special requirements on scientific component middleware, with a specific focus on high‐performance computing. We present an example application in this component architecture and outline future development planned for this project. Copyright © 2007 John Wiley & Sons, Ltd.     

Software release management for component‐based software

Software release management is the process through which software is made available to and obtained by its users. Until now, this process has been relatively straightforward. However, the emergence of component‐based software is complicating software release management. Increasingly, software is constructed via the assembly of pre‐existing, independently produced, and independently released components. Both developers and users of such software are affected by these complications. Developers need to accurately document the complex and changing dependencies among the components constituting the software. Users must be involved in locating, retrieving, and assembling components in order to appropriately bring the software into their particular environment. In this paper, we introduce the problem of release management for component‐based software and discuss SRM, a prototype software release management tool we have developed that supports both developers and users in the software release management process. Copyright © 2002 John Wiley & Sons, Ltd.     

A comprehensive peer‐to‐peer characterization model

A peer‐to‐peer (P2P) characterization model is proposed in this paper. The purposes of this model are (a) to describe through abstraction the behavior and capability of P2P computing independent of any specific application, and (b) to lead to a cost model of P2P computing. Our approach is based on abstracting the service driven nature of P2P computing separate and distinct from its implementation. This supports the first purpose. Next, we consider the integration of the two aspects. This supports the second purpose. A secondary contribution of our work is a cost model. The cost model is applied to indexing, discovery and resource utilization services. In addition, the characterization model and cost model are applied to a JXTA‐based P2P application. Copyright © 2006 John Wiley & Sons, Ltd.     

Testing‐based process for component substitutability

Software components have emerged to ease the assembly of software systems. However, updates of systems by substitution or upgrades of components demand careful management due to stability risks of deployed systems. Replacement components must be properly evaluated to identify if they provide the expected behaviour affected by substitution. To address this problem, this paper proposes a substitutability assessment process in which the regular compatibility analysis is complemented with the use of black‐box testing criteria. The purpose is to observe the components' behaviour by analysing their internal functions of data transformation, which fulfils the observability testing metric. The approach is conceptually based on the technique Back‐to‐Back testing. When a component should be replaced, a specific Test Suite TS is built in order to represent its behavioural facets, viz. a Component Behaviour TS. This TS is later exercised on candidate upgrades or replacement components with the purpose of identifying the required compatibility. Automation of the process is supported through the testooj tool, which constrains the conditions and steps of the whole process in order to provide a rigorous and reliable approach. Copyright © 2010 John Wiley & Sons, Ltd.     

A novel model‐driven approach for seamless integration

This research mentions integration problems and describes a novel model‐driven approach that intend to reach a higher degree of interoperability among different software development tools coming from different technological spaces (TSs) by representing data of tools through the models. The proposed concept introduce a way to integrate various software related tools and aim to provide a modular syntax for tool integration that leverage the collaboration of different tools. In this work, the proposed approach has been tested through a case–study by demonstrating a single aspect of the model‐driven tool integration because the model‐driven tool integration has a wide scope and it is difficult to show all aspects of it in one research. It is proved that the model‐driven tool integration is possible based on the proposed concept between different TSs, and the formulation of the proposed approach is provided. As the results indicate, the proposed system integrates selected software‐related tools coming from different TSs and enables them to use each other's capabilities. This work paves the way to contribute for the standardization efforts of the model‐driven tool integration. Finally, further research opportunities are provided. Copyright © 2016 John Wiley & Sons, Ltd.     

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 © 2014 Copyright © 2014 John Wiley & Sons, Ltd.     

Reliable control design for composite‐driven scheme based on delay networked T‐S fuzzy system

This paper is focused on reliable controller design for a composite‐driven scheme of networked control systems via Takagi‐Sugeno fuzzy model with probabilistic actuator fault under time‐varying delay. The proposed scheme is distinguished from the other schemes as mentioned in this paper. Aims of this article are to solve the control problem by considering the H_∞, dissipative, and L₂?L_∞ constraints in a unified way. Firstly, to improve the efficient utilization of bandwidth, the adaptive composite‐driven scheme is introduced. In such a scenario, the channel transmission mechanism can be adjusted between adaptive event‐triggered generator scheme and time‐driven scheme. In this study, the threshold is dependent on a new adaptive law, which can be obtained online rather than a predefined constant. With a constant threshold, it is difficult to get the variation of the system. Secondly, a novel fuzzy Lyapunov‐Krasovskii functional is constructed to design the fuzzy controller, and delay‐dependent conditions for stability and performance analysis of the control system are obtained. Then, LMI‐based conditions for the existence of the desired fuzzy controller are presented. Finally, an inverted pendulum that is controlled through the channel is provided to illustrate the effectiveness of the proposed method.     

An E‐HOIM Based Data‐Driven Adaptive TILC of Nonlinear Discrete‐Time Systems for Non‐Repetitive Terminal Point Tracking

This work proposes a new adaptive terminal iterative learning control approach based on the extended concept of high‐order internal model, or E‐HOIM‐ATILC, for a nonlinear non‐affine discrete‐time system. The objective is to make the system state or output at the endpoint of each operation track a desired target value. The target value varies from one iteration to another. Before proceeding to the data‐driven design of the proposed approach, an iterative dynamical linearization is performed for the unknown nonlinear systems by using the gradient of the nonlinear system with regard to the control input as the iteration‐and‐time‐varying parameter vector of the equivalent linear I/O data model. By virtue of the basic idea of the internal model, the inverse of the parameter vector is approximated by a high‐order internal model. The proposed E‐HOIM‐ATILC does not use measurements of any intermediate points except for the control input and terminal output at the endpoint. Moreover, it is data‐driven and needs merely the terminal I/O measurements. By incorporating additional control knowledge from the known portion of the high order internal model into the learning control law, the control performance of the proposed E‐HOIM‐ATILC is improved. The convergence is shown by rigorous mathematical proof. Simulations through both a batch reactor and a coupled tank system demonstrate the effectiveness of the proposed method.     

An event‐flow model of GUI‐based applications for testing

Graphical user interfaces (GUIs) are by far the most popular means used to interact with today's software. The functional correctness of a GUI is required to ensure the safety, robustness and usability of an entire software system. GUI testing techniques used in practice are resource intensive; model‐based automated techniques are rarely employed. A key reason for the reluctance in the adoption of model‐based solutions proposed by researchers is their limited applicability; moreover, the models are expensive to create. Over the past few years, the present author has been developing different models for various aspects of GUI testing. This paper consolidates all of the models into one scalable event‐flow model and outlines algorithms to semi‐automatically reverse‐engineer the model from an implementation. Earlier work on model‐based test‐case generation, test‐oracle creation, coverage evaluation, and regression testing is recast in terms of this model by defining event‐space exploration strategies (ESESs) and creating an end‐to‐end GUI testing process. Three such ESESs are described: for checking the event‐flow model, test‐case generation, and test‐oracle creation. Two demonstrational scenarios show the application of the model and the three ESESs for experimentation and application in GUI testing. Copyright © 2007 John Wiley & Sons, Ltd.