Elder Cirilo

JAT: A Test Automation Framework for Multi-Agent Systems

Automated tests have been widely used as a supporting mechanism during software development and maintenance activities. It improves the confidence on software releases as it seeks to uncover regression bugs, and serves as a live documentation which is very useful when evolving systems. Concerning multi agent systems (MASs), some characteristics such as agent autonomy and asynchronous message-based interaction bring a degree of non-determinism which presents new testing challenges. This paper proposes JAT, a framework for building and running MASs test scenarios, which relies on the use of aspect-oriented techniques to monitor the autonomous agents during tests and control the test input of asynchronous test cases. The tool has been developed on top of JADE, a widely used agent platform implemented in Java. We have used JAT on testing 3 different MASs. Our experience shows that JAT can be used to build test scenarios which can achieve high fault-detection effectiveness.

Extending web-based applications to incorporate autonomous behavior

Web applications are popular nowadays due to the ubiquity of the client and also because user experience is becoming each time more interactive. However, several tasks of these applications can be automated. Agent-oriented software engineering has emerged as a new software engineering paradigm to allow the development of applications that present autonomous behavior. In this work, we present two case studies of web-based systems, on which we added autonomous behavior by means of software agents. We also discuss some design and implementation issues found on the development of those systems and propose an architectural pattern as a consequence of our case studies.

Mapping features to aspects: a model-based generative approach

Handling the various derivations of an aspect-oriented software family architecture can be a daunting and costly task if explicit support is not systematically provided throughout early and late development stages. Aspect-oriented software development (AOSD) has been recently explored as a technique that enables software product line customization. However, the application of AOSD has been limited to modularize specific crosscutting features encountered in the implementation of software product-line architectures or frameworks. Only a few works have investigated the development of product derivation approaches for AOSD. This paper presents a model-based generative approach to mapping features to aspects across different artifacts of a product line. Our main aim is to enable the smooth and systematic derivation of aspect-oriented software family architecture. Our approach is complementary to a set of previously-proposed modularization guidelines to implement aspect-oriented frameworks. We present details about the suite of mappings supported by our generative model, illustrate them in heterogeneous case studies, and discuss several implementation issues for its accomplishment.

Automating the product derivation process of multi-agent systems product lines

Agent-oriented software engineering and software product lines are two promising software engineering techniques. Recent research work explores the integration between them to allow reuse and variability management in the context of complex systems. However, the automatic product derivation process is not addressed in the current literature. In this paper, we present our approach to deal with multi-agent systems product lines (MAS-PL) variability management and automatic product derivation. Our approach is implemented as an extension of the GenArch product derivation tool. A case study illustrates how the proposed approach can be used to derive products (instances) from a MAS-PL.

Integrating Component and Product Lines Technologies

In this paper, we explore the integration of product line and component technologies in the context of the product derivation process. In particular, we propose new extensions to our existing model-based product derivation tool, called GenArch, in order to address the new abstractions and mechanisms provided by the Spring and OSGi component models. The GenArch extensions enable the automatic instantiation of product lines and applications - implemented using these component technologies. Moreover, it also enables different levels of customization, from fine-grained configuration of component properties to the automatic selection of components that will compose the final product.

Assessment of product derivation tools in the evolution of software product lines: an empirical study

Product derivation approaches automate the customization process of software product lines. Over the last years, many tools have been proposed aiming at synthesize and generate products from a set of reusable assets. These tools adopt different techniques and strategies to implement and automate the product derivation activities. In this paper, we analyzed six modern product derivation tools (Captor, CIDE, GenArch, MSVCM, pure::variants, XVCL) in the context of evolution scenarios of a software product line. Our study has adopted several metrics to analyze the modularity, complexity and stability of product derivation artifacts related to configuration knowledge along different releases of a mobile product line. The preliminary results of our study have shown that approaches with a dedicated model or file to represent the CK specification can bring several benefits to the modularization and stability of a software product line.

A survey on the implementation of agent oriented specifications

Agent literature has shown a big concern on the production of multi-agent system specifications. Nevertheless, there has not been a similar effort in surveying the different ways an agent oriented specification can be transformed into the actual implementation. This survey intends to cover this gap by pointing at concrete representative works of different implementation approaches.

Configurable Software Product Lines – Supporting Heterogeneous Configuration Knowledge

Although different types of enterprise information systems have been built as configurable software product lines, the growing heterogeneity and diversity in system development approaches makes it difficult to specify the configuration knowledge. In this paper we examine the deficiencies of current approaches to the specification of configuration knowledge, and as a solution propose the notion of Domain Knowledge Modeling Languages (DKMLs). We also present GenArch+, an extensible tool that supports the creation and composition of DKMLs. We illustrate and evaluate the use of DKMLs in four different product lines. Our quantitative and qualitative assessment suggests that the use of DMKLs brings improvements for heterogeneous configuration knowledge specification.

Analysing the Impact of Feature Dependency Implementation on Product Line Stability: An Exploratory Study

The evolution of software product lines (SPLs) is particularly challenging. SPL functionalities, usually decomposed into features, naturally depend among them. As the SPL evolves, the implementation of each feature dependency might increasingly affect more code elements. Therefore, as the complexity of feature dependency implementation grows up through code evolution, it is likely to negatively impact on the SPL stability. Stability refers to the amount of changes between SPL releases and it is directly influenced by the complexity of feature dependency implementation. In this context, a number of emerging programming techniques can be used to keep the complexity of feature dependency code under control. Nevertheless, there is a lack of studies analysing the impact of different programming techniques on the stability of feature dependency code in evolving SPLs. This paper presents a first exploratory analysis on the use of programming techniques to implement and evolve feature dependencies. Our analysis was developed in the context of three evolving SPL systems, which are made up of 210 feature dependencies. Our initial findings reveal that two particular types of feature dependency implementation using different programming techniques play a role in the SPL stability.

Configuration knowledge of software product lines: a comprehensibility study

The configuration knowledge is a key element to the success of software product lines, as it defines constraints on how product line variability should be composed to derive products. Even though configuration knowledge specification is a long standing problem in software product line engineering, the impact of different specification techniques on comprehensibility has never been studied. This paper presents an empirical study to evaluate and compare three techniques for configuration knowledge specification. Each of them is centered on diffierent means to express the configuration constraints: annotations, general-purpose modeling, and domain-specific modeling. Our results suggest that: (i) the use of domain-specific abstractions tends to facilitate the comprehension of coarse-grained variability; (ii) the use of general-purpose models imposes certain restrictions on the location and comprehension of the configuration knowledge; and (iii) the correct comprehension of configuration constraints is not associated with individual expertise