The increasing environmental impact of Information and Communication Technologies (ICTs), particularly the energy consumption associated with serverless applications, necessitates the development of methodologies to optimize energy efficiency. This study addresses the need for energy-aware design and runtime adaptation in serverless architectures. To develop and validate a methodology that integrates energy monitoring into the development and runtime management of serverless applications, thereby enabling significant reductions in energy consumption while maintaining functionality. A new version of FUSPAQ, a framework for the optimisation of serverless applications, was developed. This version incorporates tools like Kepler for real-time energy monitoring and employs an energy-aware orchestration mechanism to dynamically select energy-efficient function configurations. Validation was conducted through a facial recognition case study and benchmark experiments, comparing energy consumption across different scenarios with and without the proposed adaptations. The enhanced FUSPAQ framework successfully integrated energy consumption metrics into the decision-making process for function selection and runtime adaptation. Benchmark tests confirmed the scalability of the solution, with energy-efficient outcomes even in complex applications. The study highlights the potential of integrating energy-aware practices in serverless applications, presenting a scalable and practical approach to reducing their environmental footprint. By leveraging tools like Kepler and frameworks like FUSPAQ, developers can achieve significant energy savings without compromising application performance. This work contributes to the advancement of Green Software Engineering by emphasizing runtime energy adaptation in Function-as-a-Service (FaaS) architectures. • Energy monitoring integrated into serverless application development. • The approach enables runtime energy-efficient self-adaptation for serverless apps. • Validated using a benchmark application that achieves up to 50% energy savings. • Kepler used for accurate energy metrics in containerized serverless functions. • Demonstrated scalability for optimizing energy across complex FaaS systems.

The configuration space of some systems is so large that it cannot be computed. This is the case with the Linux Kernel , which provides more than 18,000 configurable options described across almost 1,700 files in the Kconfig language. As a result, many analyses of these systems rely on sampling their configuration space (e.g., debugging compilation errors, predicting configuration performance, finding the configuration that optimizes specific performance metrics, among others.). The Kernel and other Kconfig -based systems can be sampled pragmatically , using their built-in tool conf to get a sample directly from the Kconfig specification that is approximately random, or idealistically , generating a genuine random sample by first translating the Kconfig files into logic formulas, then using a logic engine to compute the probability that each option value has to appear in a configuration, and finally utilizing these probabilities to generate an authentically random sample. The pros of the idealistic approach are that it ensures the sample is representative of the population, but the cons are that it sets out many challenging problems that have not been solved yet (fundamentally, how to obtain a valid translation into Boolean that covers all the Kconfig language, and how to compute the option value probabilities for very large formulas). This paper introduces a new version of conf called randconfig + , which incorporates a series of improvements that increase the randomness and correctness of pragmatic sampling and also help validate the Boolean translation required for the idealistic approach. randconfig + has been tested on ten versions of the Linux Kernel and twenty additional Kconfig systems. Its compatibility significantly enhances the current landscape, where some systems use a customized conf variant that is maintained independently, while others do not support sampling at all. randconfig + not only offers universal sampling for all Kconfig systems but also simplifies its evolutive maintenance as a single tool rather than an unorganized collection of conf variants.

Cross-tree constraints help to compact feature models by using arbitrary propositional logic formulas, which efficiently capture interdependencies between features. However, the existence of these constraints increases the complexity of reasoning about feature models, whether we use SAT solvers or compile the model to a binary decision diagram for efficient analyses. Although some works have tried to refactor constraints to eliminate them, they deal only with simple constraints (i.e., requires and excludes) or require introducing an additional set of features, increasing the size and complexity of the resulting feature model. This paper presents an approach that eliminates all the cross-tree constraints in regular boolean feature models, including arbitrary constraints in propositional logic formulas. Our approach for removing constraints consists of splitting the semantics of feature models into orthogonal disjoint feature subtrees, which are then analyzed in parallel to alleviate the exponential blow-up in memory of the resulting feature tree . We propose a codification of the constraints and define and analyze different heuristics for constraints ordering to reduce the complexity of identifying the valid disjoint subtrees when removing constraints.

FM Fact Label is a tool for visualizing the characterizations of feature models based on their metadata, structural measures, and analytical metrics. Although there are various metrics available to characterize feature models, there is no standard method to visualize and identify unique properties of feature models. Unlike existing tools, FM Fact Label provides a standalone web-based platform for configurable and interactive visualization, enabling export to various formats. This contribution is significant because it supports the Universal Variability Language (UVL) and enhances the UVL ecosystem by offering a common representation of the results of existing analysis tools.

Software product line engineering aims to systematically generate similar products or services within a given domain to reduce cost and time to market while increasing reuse. Various studies recognize the success of product line engineering in different domains. Software variability have increased over the years in many different domains such as mobile applications, cyber–physical systems or car control systems to just mention a few. However, software product line engineering is not as widely adopted as other software development technologies. In this paper, we present an empirical study conducted through a survey distributed to many software development companies. Our goal is to understand their need of software variability management and the level of knowledge the companies have regarding software product line engineering. The survey was answered by 127 participants from more than a hundred of different software development companies. Our study reveals that most of companies manage a catalog of similar products in a way or another, they mostly document the features of products using text or spreed sheet based documents and more than 66% of companies identify a base product from which they derive other similar products. We also found a correlation between the lack of Software Product Line (SPL) knowledge and the absence of reuse practices. Notably, this is the first study that explore software variability needs regardless of a company’s prior knowledge of SPL. The results encourages further research to understand the reason for the limited knowledge and application of software product line engineering practices, despite the growing demand of variability management.

The Internet of Things is one of the core drivers of variability modelling and requires explicit mechanisms to manage it. A key technology for addressing this variability is product line engineering. This approach uses a reference architecture to establish a well-designed set of assets that fit together, the Software Product Line (SPL). One of the limitations of variability models is they do not provide information about the quality of new products or how they achieve stakeholder requirements. Several approaches tackle this issue by integrating variability models with goal models. The main challenge is conciliating the different variability perspectives to make the joint use of both models possible without the loss of information or alterations to the models' semantics. In this work, we present a framework for analysing and optimising SPL products considering stakeholders' requirements that respects the semantics of both models. The framework is based on Integer Linear Programming (ILP), a field of mathematical programming. Variability and goal models are formalised as a set of linear constraints and are linked using mapping functions. As a proof of concept, we present a tool that takes both models and mapping functions to generate an ILP problem that can be solved using Matlab.

Emergent application domains, such as cyber–physical systems, edge computing or industry 4.0. present a high variability in software and hardware infrastructures. However, no single variability modeling language supports all language extensions required by these application domains (i.e., attributes, group cardinalities, clonables, complex constraints). This limitation is an open challenge that should be tackled by the software engineering field, and specifically by the software product line (SPL) community. A possible solution could be to define a completely new language, but this has a high cost in terms of adoption time and development of new tools. A more viable alternative is the definition of refactoring and specialization rules that allow interoperability between existing variability languages. However, with this approach, these rules cannot be reused across languages because each language uses a different set of modeling concepts and a different concrete syntax. Our approach relies on a modular and extensible metamodel that defines a common abstract syntax for existing variability modeling extensions. We map existing feature modeling languages in the SPL community to our common abstract syntax. Using our abstract syntax, we define refactoring rules at the language construct level that help to achieve interoperability between variability modeling languages.

Real-world Software Product Lines (SPLs) need Numerical Feature Models (NFMs) whose features have not only boolean values that satisfy boolean constraints but also have numeric attributes that satisfy arithmetic constraints. An essential operation on NFMs finds near-optimal performing products, which requires counting the number of SPL products. Typical constraint satisfaction solvers perform poorly on counting and sampling. Nemo (Numbers, features, models) is a tool that supports NFMs by bit-blasting, the technique that encodes arithmetic expressions as boolean clauses. The newest version, Nemo2, translates NFMs to propositional formulas and the Universal Variability Language (UVL). By doing so, products can be counted efficiently by #SAT and Binary Decision Tree solvers, enabling finding near-optimal products. This article evaluates Nemo2 with a large set of synthetic and colossal real-world NFMs, including complex arithmetic constraints and counting and sampling experiments. We empirically demonstrate the viability of Nemo2 when counting and sampling large and complex SPLs.

Emergent application domains (e.g., Edge Computing/Cloud/B5G systems) are complex to be built manually. They are characterised by high variability and are modelled by large Variability Models (VMs), leading to large configuration spaces. Due to the high number of variants present in such systems, it is challenging to find the best-ranked product regarding particular Quality Attributes (QAs) in a short time. Moreover, measuring QAs sometimes is not trivial, requiring a lot of time and resources, as is the case of the energy footprint of software systems — the focus of this paper. Hence, we need a mechanism to analyse how features and their interactions influence energy footprint, but without measuring all configurations. While practical, sampling and predictive techniques base their accuracy on uniform spaces or some initial domain knowledge, which are not always possible to achieve. Indeed, analysing the energy footprint of products in large configuration spaces raises specific requirements that we explore in this work. This paper presents SAVRUS (Smart Analyser of Variability Requirements in Unknown Spaces), an approach for sampling and dynamic statistical learning without relying on initial domain knowledge of large and partially QA-measured spaces. SAVRUS reports the degree to which features and pairwise interactions influence a particular QA, like energy efficiency. We validate and evaluate SAVRUS with a selection of likewise systems, which define large searching spaces containing scattered measurements.

Abstract For the last ten years, software product line (SPL) tool developers have been facing the implementation of different variability requirements and the support of SPL engineering activities demanded by emergent domains. Despite systematic literature reviews identifying the main characteristics of existing tools and the SPL activities they support, these reviews do not always help to understand if such tools provide what complex variability projects demand. This paper presents an empirical research in which we evaluate the degree of maturity of existing SPL tools focusing on their support of variability modeling characteristics and SPL engineering activities required by current application domains. We first identify the characteristics and activities that are essential for the development of SPLs by analyzing a selected sample of case studies chosen from application domains with high variability. Second, we conduct an exploratory study to analyze whether the existing tools support those characteristics and activities. We conclude that, with the current tool support, it is possible to develop a basic SPL approach. But we have also found out that these tools present several limitations when dealing with complex variability requirements demanded by emergent application domains, such as non-Boolean features or large configuration spaces. Additionally, we identify the necessity for an integrated approach with appropriate tool support to completely cover all the activities and phases of SPL engineering. To mitigate this problem, we propose different road map using the existing tools to partially or entirely support SPL engineering activities, from variability modeling to product derivation.

Next-generation mobile networks are expected to flaunt highly (if not fully) automated management. To achieve such a vision, Artificial Intelligence (AI) and Machine Learning (ML) techniques will be key enablers to craft the required intelligence for networking, i.e., Network Intelligence (NI), empowering myriad of orchestrators and controllers across network domains. In this paper, we elaborate on the DAEMON architectural model, which proposes introducing a NI Orchestration layer for the effective end-to-end coordination of NI instances deployed across the whole mobile network infrastructure. Specifically, we first outline requirements and specifications for NI design that stem from data management, control timescales, and network technology characteristics. Then, we build on such analysis to derive initial principles for the design of the NI Orchestration layer, focusing on (i) proposals for the interaction loop between NI instances and the NI Orchestrator, and (ii) a unified representation of NI algorithms based on an extended MAPE-K model. Our work contributes to the definition of the interfaces and operation of a NI Orchestration layer that foster a native integration of NI in mobile network architectures.

Web engineering involves managing a high diversity of artifacts implemented in different languages and with different levels of granularity. Technological companies usually implement variable artifacts of Software Product Lines (SPLs) using annotations, being reluctant to adopt hybrid, often complex, approaches combining composition and annotations despite their benefits. This paper proposes a combined approach to support fine and coarse-grained variability for web artifacts. The proposal allows web developers to continue using annotations to handle fine-grained variability for those artifacts whose variability is very difficult to implement with a composition-based approach, but obtaining the advantages of the composition-based approach for the coarse-grained variable artifacts. A combined approach based on feature modeling that integrates annotations into a generic composition-based approach. We propose the definition of compositional and annotative variation points with custom-defined semantics, which is resolved by a scaffolding-based derivation engine. The approach is evaluated on a real-world web-based SPL by applying a set of variability metrics, as well as discussing its quality criteria in comparison with annotations, compositional, and combined existing approaches. Our approach effectively handles both fine and coarse-grained variability. The mapping between the feature model and the web artifacts promotes the traceability of the features and the uniformity of the variation points regardless of the granularity of the web artifacts. Using well-known techniques of SPLs from an architectural point of view, such as feature modeling, can improve the design and maintenance of variable web artifacts without the need of introducing complex approaches for implementing the underlying variability.

Edge Computing proposes to use the nearby devices in the frontier/Edge of the access network for deploying application tasks of IoT-based systems. However, the functionality of such cyber–physical systems, which is usually distributed in several devices and computers, imposes specific requirements on the infrastructure to run properly. The evolution of an application to meet new user requirements and the high diversity of hardware and software technologies in the IoT/Edge/Cloud can complicate the deployment of continuously evolving applications. The aim of our approach is to apply Multi Layer Feature Models, which capture the variability of applications and the software and hardware infrastructure, to support the deployment in edge-based environments of cyber–physical applications. With this multi-layered approach is possible to support the evolution of application and infrastructure independently. Considering that IoT/Edge/Cloud infrastructures are usually shared by many applications, the deployment process has to assure that there will be enough resources for all of them, informing developers about the feasible alternatives. We provide four modules so that the developer can calculate what is the configuration of minimal set of devices supporting application requirements of the evolved application. In addition, the developer can find what is the application configuration that can be hosted in the current infrastructure. The successive solutions of continuous deployment generated by our approach pursue the reduction of the system energy footprint and/or execution latency.

Industrial Augmented Reality (IAR) is a key enabling technology for Industry 4.0. However, its adoption poses several challenges because it requires the execution of computing-intensive tasks in devices with poor computational resources, which contributes to a faster draining of the device batteries. Proactive self-adaptation techniques could overcome these problems that affect the quality of experience by optimizing computational resources and minimizing user disturbance. In this work, we propose to apply ProDSPL, a proactive Dynamic Software Product Line, for the self-adaptation of IAR applications to satisfy the quality requirements. PRODSPL is compared against MODAGAME, a multi-objective DSPL approach that uses a genetic algorithm to generate quasi-optimal feature model configurations at runtime. The evaluation with randomly generated feature models running on mobile devices shows that PRODSPL gives results closer to the Pareto optimal than MODAGAME.

In order to lower latency and reduce energy consumption, edge computing proposes offloading some computation-intensive tasks usually performed in the cloud onto nearby devices in the frontier/edge of the access networks. However, the current task offloading approaches are often quite simple. They neither consider the high diversity of hardware and software technologies present in edge network devices nor take into account that some tasks may require some specific software and hardware infrastructure to be executed. This article proposes a task offloading process that leans on software product line technologies, which are a very good option to model the variability of software and hardware present in edge environments. First, our approach automates the separation of application tasks, considering the data and operation needs and restrictions among them, and identifying the hardware and software resources required by each task. Second, our approach models and manages separately the infrastructure available for task offloading, as a set of nodes that provide certain hardware and software resources. This separation allows to reason about alternative offloading of tasks with different hardware and software resource requirements, in heterogeneous nodes and minimizing energy consumption. In addition, the offloading process considers alternative implementations of tasks to choose the one that best fits the hardware and software characteristics of the available edge network infrastructure. The experimental results show that our approach reduces the energy consumption in the user node by approximately 41%–62%, and the energy consumption of the devices involved in a task offloading solution by 34%–48%.

Advanced smart home appliances and new models of energy tariffs imposed by energy providers pose new challenges in the automation of home energy management. Users need some assistant tool that helps them to make complex decisions with different goals, depending on the current situation. Multi-agent systems have proved to be a suitable technology to develop self-management systems, able to take the most adequate decision under different context-dependent situations, like the home energy management. The heterogeneity of home appliances and also the changes in the energy policies of providers introduce the necessity of explicitly modeling this variability. But, multi-agent systems lack of mechanisms to effectively deal with the different degrees of variability required by these kinds of systems. Software Product Line technologies, including variability models, has been successfully applied to different domains to explicitly model any kind of variability. We have defined a software product line development process that performs a model driven generation of agents embedded in heterogeneous smart objects with different degrees of self-management. However, once deployed, the home energy assistant system has to be able to evolve to self-adapt its decision making or devices to new requirements. So, in this paper we propose a model driven mechanism to automatically manage the evolution of multi-agent systems distributed among several devices.

Web applications development involves managing a high diversity of files and resources like code, pages or style sheets, implemented in different languages. To deal with the automatic generation of custom-made configurations of web applications, industry usually adopts annotation-based approaches even though the majority of studies encourage the use of composition-based approaches to implement Software Product Lines. Recent work tries to combine both approaches to get the complementary benefits. However, technological companies are reticent to adopt new development paradigms such as feature-oriented programming or aspect-oriented programming. Moreover, it is extremely difficult, or even impossible, to apply these programming models to web applications, mainly because of their multilingual nature, since their development involves multiple types of source code (Java, Groovy, JavaScript), templates (HTML, Markdown, XML), style sheet files (CSS and its variants, such as SCSS), and other files (JSON, YML, shell scripts). We propose to use the Common Variability Language as a composition-based approach and integrate annotations to manage fine grained variability of a Software Product Line for web applications. In this paper, we (i) show that existing composition and annotation-based approaches, including some well-known combinations, are not appropriate to model and implement the variability of web applications; and (ii) present a combined approach that effectively integrates annotations into a composition-based approach for web applications. We implement our approach and show its applicability with an industrial real-world system.

Context: Quality attributes play a critical role in the architecture elicitation phase. Software Sustainability and energy efficiency is becoming a critical quality attribute that can be used as a selection criteria to choose from among different design or implementation alternatives. Energy efficiency usually competes with other non-functional requirements, like for instance, performance. Objective: This paper presents a process that helps developers to automatically generate optimum configurations of functional quality attributes in terms of energy efficiency and performance. Functional quality attributes refer to the behavioral properties that need to be incorporated inside a software architecture to fulfill a particular quality attribute (e.g., encryption and authentication for the security quality attribute, logging for the usability quality attribute). Method: Quality attributes are characterized to identify their design and implementation variants and how the different configurations influence both energy efficiency and performance. A usage model for each characterized quality attribute is defined. The variability of quality attributes, as well as the energy efficiency and performance experiment results, are represented as a constraint satisfaction problem with the goal of formally reasoning about it. Then, a configuration of the selected functional quality attributes is automatically generated, which is optimum with respect to a selected objective function. Results: Software developers can improve the energy efficiency and/or performance of their applications by using our approach to perform a richer analysis of the energy consumption and performance of different alternatives for functional quality attributes. We show quantitative values of the benefits of using our approach and discuss the threats to validity. Conclusions: The process presented in this paper will help software developers to build more energy efficient software, whilst also being aware of how their decisions affect other quality attributes, such as performance.

Abstract Human drivers naturally adapt their behaviour depending on the traffic conditions, such as the current weather and road type. Autonomous vehicles need to do the same, in a way that is both safe and efficient in traffic composed of both conventional and autonomous vehicles. In this paper, we demonstrate the applicability of a reconfigurable vehicle controller agent for autonomous vehicles that adapts the parameters of a used car‐following model at runtime, so as to maintain a high degree of traffic quality (efficiency and safety) under different weather conditions. We follow a dynamic software product line approach to model the variability of the car‐following model parameters, context changes and traffic quality, and generate specific configurations for each particular context. Under realistic conditions, autonomous vehicles have only a very local knowledge of other vehicles' variables. We investigate a distributed model predictive controller agent for autonomous vehicles to estimate their behavioural parameters at runtime, based on their available knowledge of the system. We show that autonomous vehicles with the proposed reconfigurable controller agent lead to behaviour similar to that achieved by human drivers, depending on the context.

Cloud computing is becoming the predominant mechanism to seamlessly deploy applications with special requirements such as massive storage sharing or load balancing, usually provided as services by cloud platforms. A developer can improve the application's delivery and productivity by following a multi tenancy approach, where variants of the same application can be quickly customized to the necessities of each tenant. However, managing the inherent variability existing in multi-tenant applications and, even more importantly, managing the evolution of a multi-tenant application with hundreds of tenants and thousands of different valid architectural configurations can become intractable if performed manually. In this paper we propose a product line architecture approach in which: (1) we use cardinality-based variability models to model each tenant as a clonable feature, (2) we automate the process of evolving the multi- tenant application architecture, and (3) we demonstrate that the implemented process is correct and efficient for a high number of tenants in a reasonable time. We use a running case study in the domain of medical software.

An important problem in Web services composition process is optimal selection of services meeting the user functional requirements (tasks of a workflow) and ensuring a reliable execution of the composition. Therefore, non-functional properties of services such as their transactional behavior as well as their Quality of Service (QoS) must be considered. In this context, a challenging objective is to assist users in integrating on the fly the operations of services to realize their required tasks by further meeting their transactional and QoS preferences. Towards this purpose, we present SPLTQSSS, a Software Product Line based approach for Stateful (conversation-based) Service Selection problem with Transactional and QoS support. SPL-TQSSS considers the set of functionally-equivalent services as part of a service family by modeling their internal operations using Feature Models. Then, SPL-TQSSS chooses the best services, from the service families matching with every task of the workflow, which fit with the user transactional preference and satisfy QoS constraints.

The execution context in which pervasive systems or mobile computing run changes continually. Hence, applications for these systems require support for self-adaptation to the continual context changes. Most of the approaches for self-adaptive systems implement a reconfiguration service that receives as input the list of all possible configurations and the plans to switch between them. In this paper we present an alternative approach for the automatic generation of application configurations and the reconfiguration plans at runtime. With our approach, the generated configurations are optimal as regards different criteria, such as functionality or resource consumption (e.g. battery or memory). This is achieved by: (1) modelling architectural variability at design-time using the Common Variability Language (CVL), and (2) using a genetic algorithm that finds nearly-optimal configurations at run-time using the information provided by the variability model. We also specify a case study and we use it to evaluate our approach, showing that it is efficient and suitable for devices with scarce resources.

In this paper, we combine the Common Variability Language (CVL) and the ATL Transformation Language \nto customize and incorporate a generic security model into any application that requires security. Security \nspans a large set of concerns such as integrity, encryption or authentication, among others, and each concern \nneeds to be incorporated into the base application in a different way and at different points of the application. \nWe propose a set of weaving patterns using model transformations in ATL to automatically weave the security \nconcerns with the base application in an aspect-oriented way. Since different applications require different \nsecurity requirements, the security model needs to be customized before its incorporation into the application. \nWe resolve the variability of the security properties and implement the weaving process in CVL. We use an \ne-voting case study to illustrate our proposal using the CVL approach.

A key factor for the successful adoption of Model-Driven Development (MDD) techniques is the ability to verify models, which can be achieved by model simulation and testing. This is already a reality for UML models, due mainly to the UML action language. However, this action language is purely object-oriented, which implies it needs to be extended to model applications of new software development paradigms, such as aspect-oriented applications. These extensions also require modifying the tools that execute the UML models, which, with the currently available tools, is often not possible. Furthermore, at the current time, there are no tools fully compliant with the UML action language. In order to overcome this limitation, this paper presents Populo, an extensible UML model debugger, which interprets the UML action language, compliant with the standard, and that can be customised for executing profiled (i.e. extended) UML models.

Abstract The increasing complexity of large‐scale distributed applications is driving the Software Engineering community to adopt new software technologies for the development of distributed systems. In this sense, the emergence of component‐based software engineering represents a significant advance towards assembling applications by plugging in pre‐fabricated components. Additionally, the principle of ‘advanced’ separation of concerns is nowadays widely applied to improve modularity, reusability and adaptability of software components. In this way, the aspect‐oriented software development paradigm separates into a new dimension, named aspect, those properties that crosscut the system ‘objects’ or ‘components’, reducing their dependencies. However, the development of software based on the composition of components and aspects is still in its early stages. Part of the reason for this is the lack of well‐defined development processes and tools that help software developers in the use of existing component and aspect‐based approaches. Therefore, the primary aim of this paper is to propose an integrated development process for deriving applications by the assembly of a set of prefabricated components and aspects. This process supports the development of Component‐Aspect Model/Dynamic Aspect‐Oriented Platform (CAM/DAOP) applications, where CAM/DAOP is a new model and platform based on components and aspects. Our intention is to show how, with the support of the integrated development process presented in this paper, it is possible to use CAM/DAOP as an alternative to current distributed platforms. Copyright © 2006 John Wiley & Sons, Ltd.

Component-based software development (CBSD) represents a significant advance towards assembling systems by plugging in independent and (re)usable components. On the other hand, aspect-oriented software development (AOSD) is presently considered as a possible technology to improve the modularity and adaptability of complex and large-scale distributed systems. Both are complementary technologies, so it would be helpful to have models that combine them to take advantage of all their mutual benefits. Thus recent research has tried to combine CBSD and AOSD by considering aspects as reusable parts that can be woven and then attached to the individual components. Our contribution to the integration of these technologies is CAM, a new component and aspect model that defines components and aspects as first-order entities, together with a non-intrusive composition mechanism to plug aspects into components. The underlying infrastructure supporting CAM is the dynamic aspect-oriented platform (DAOP), a component and aspect platform that provides the usual services of distributed applications, as well as a composition mechanism to perform the plugging of software aspects into components at runtime.

Distributed systems are inherently complex, and therefore difficult to design and develop. Experience shows that new technologies - such as components, aspects, and application frameworks - can be effectively used for building distributed applications. However, our experience also shows that most of the applications built in that way are difficult to be re-used, documented, and maintained. Probably, one of the major reasons is the lack of a clear separation between the concepts used at different levels (application domain, application architecture, supporting application platform, programming language, etc.). In this paper we present our experience with a platform we developed for building distributed applications using components and aspects. In particular, we show how many of the (conceptual) problems we hit when trying to document, re-use, and implement it in different contexts can be naturally solved with te adoption of the MDA concepts. In addition, we describe the process we followed for identifying and separating the entities that live in different "models" (in the MDA sense), and the required transformations between them. MDA offers a good framework for specifying different views of our model, and mappings to platform-specific profiles. In this way, we are able to address the particular needs of different stakeholders: from the designer interested in developing new applications following our (component and aspect-based) modeling approach, to the software vendor that wants to implement a propriety version of our supporting middleware framework in CORBA, EJB or .NET.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. Some of the existing proposals try to add protocol information to object interfaces, but most of them fail to do so in a modular way. In this paper we propose an extension of the CORBA IDL that uses a sugared subset of the polyadic /spl pi/-calculus for describing object service protocols, based on the concept of roles. Roles allow the modular specification of the observable behavior of CORBA objects, reducing the complexity of the compatibility tests. Our main aim is the automated checking of protocol interoperability between CORBA objects in open component-based environments, using similar techniques to those used in software architecture description and analysis. In addition, our proposal permits the study of substitutability between CORBA objects, as well as the realization of dynamic compatibility tests during their runtime execution.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. In this paper we propose an extension of the Common Object Request Broker Architecture (CORBA) interface description language (IDL) that uses a sugared subset of the polyadic $\pi$-calculus for describing object service protocols, aimed at the automated checking of protocol interoperability between CORBA objects in open component-based environments. In addition, some advantages and disadvantages of our proposal are discussed, as well as some of the practical limitations encountered when trying to implement and use this sort of IDL extension in open systems.

Abstract Component‐based software has become an important alternative for building applications, especially distributed ones, so it is essential to define new software development processes based on components. Within this trend, we propose a complete framework‐based method which guides application developers in exactly determining application requirements. It also guides how to build them using the compositional framework MultiTEL from the collaborative and multimedia applications domain. Although many multimedia frameworks are available, none of them offer a design methodology for understanding and adapting the framework classes or components to each derived application. By applying an architecture description language (ADL) we are able to document the framework and help designers in: constructing; reusing, and connecting components; extending the framework architecture; and adding components to meet user requirements. Tools for the automatic generation of code from the ADL specifications are also described. Copyright © 2001 John Wiley & Sons, Ltd.