Open software development platforms, such as GitHub, foster developers’ collaboration in coding tasks through pull requests (PR). PRs serve as a mechanism for code contributions and structured discussions. These discussions often involve developers exchanging messages that contain questions. Despite the importance of questions, existing studies have not gathered insights on what are recurring types of questions in GitHub PR discussions. In this paper, we address this gap by leveraging the well-established 5W2H framework, which consists of seven questions classes. Our goal is to analyze the distribution of these question types within GitHub PRs and assess whether language models, specifically GPT-3.5 and GPT-4o, can accurately classify them. We conducted our study using a dataset derived from nine GitHub projects from the Netflix and Google ecosystems. Our findings reveal that both GPT-3.5 and GPT-4o perform well in identifying What and Who classes, which were the most frequently occurring question types in developers’ discussions. However, both models struggled with less common categories, failing to detect How Much, and showing inconsistencies in classifying Where, When, Why, and How. These findings suggest that improving classification accuracy may require incorporating domain-specific context and refining prompt engineering techniques.

The modernization of monolithic legacy systems with microservices has been a trend in recent years. As part of this modernization, identifying microservice candidates starting from legacy code is challenging, as maintainers may consider many criteria simultaneously. Multi-objective search-based approaches represent a promising state-of-the-art solution to support this decision-making process. However, the rationale to adopt each microservice candidate automatically identified by these approaches is poorly investigated in industrial cases. Furthermore, studies with these approaches have not carefully investigated how maintainers reason and make decisions when designing microservice architectures from legacy systems. To address this gap, we conducted an on-site case study with maintainers of an industrial legacy system to investigate the usefulness of automatically generated microservice architectures. We analyze design decisions pointed out by the maintainers when reasoning about microservice candidates using several criteria at the same time. Our study is the first to assess a search-based approach involving actual maintainers conceiving microservice architectures in an industrial setting. Therefore, firstly, we considered individual evaluation of microservice candidates to understand the rationale for identifying a service. Secondly, we conducted a focus group study with maintainers with the goal of investigating design decisions at an architectural level. The results show that:(i)the automated approach is able to identify useful microservices;(ii)the criteria observed by previous studies are, in fact, considered by maintainers; and(iii)the maintainer profiles, i.e., the preferred granularity for microservice, highly affect design decisions. Finally, we observed the maintainers needed little effort in adjusting the automatically identified microservices to make them adoptable. In addition to indicating a promising potential of search-based approaches to generate microservice architectures, our findings highlight the need for:(i)interactive and/or customizable approaches that enable maintainers to include their preferences during the search process, and(ii)flexible or automated selection of criteria that fits the scenario in which the modernization is taking place.

Microservices are small and autonomous services that communicate through lightweight protocols. Companies have often been adopting microservices to incrementally redesign legacy systems as part of a modernization process. Microservices promote better reuse and customization of existing features while increasing business capabilities, if appropriate design decisions are made. There are some partially-automated approaches supporting the re-design of legacy features into microservices. However, they fail in covering two key aspects: (i) provide an architectural design of the features being redesigned, and (ii) simultaneously support relevant criteria, e.g., feature modularization and decrease of network communication overhead. Also, these two aspects tend to be poorly discussed along industrial case studies. To fulfill these gaps, we propose a redesign strategy to support the re-engineering of features legacy code as microservices. This strategy covers key possibly-conflicting criteria on microservice-based architectures. We employ search-based optimization to deal with such conflicting criteria. The output of the strategy is a set of redesign candidates of legacy features as microservices. We reflect upon the benefits and drawbacks of the proposed strategy through an industrial case study. In particular, we perform an in-depth analysis of the resulting microservice candidates, and a discussion about their potential for customization and reuse. The reflections/discussions are also supported by observations of developers involved in the process.

Embodied agents is a term used to denote intelligent agents, which are a component of devices belonging to the Internet of Things (IoT) domain. Each agent is provided with sensors and actuators to interact with the environment, and with a `controller' that usually contains an artificial neural network (ANN). In previous publications, we introduced three software approaches to design, implement and test IoT embodied agents. In this paper, we propose a reference model based on statecharts that offers abstractions tailored to the development of IoT applications. The model represents embodied agents that are controlled by neural networks. Our model includes the ANN training process, represented as a reconfiguration step such as changing agent features or neural net connections. Our contributions include the identification of the main characteristics of IoT embodied agents, a reference model specification based on statecharts, and an illustrative application of the model to support autonomous street lights. The proposal aims to support the design and implementation of IoT applications by providing high-level design abstractions and models, thus enabling the designer to have a uniform approach to conceiving, designing and explaining such applications.

The expensive maintenance of legacy systems leads companies to migrate such systems to microservice architectures. This migration requires the identification of system's legacy parts to become microservices. However, the successful identification of microservices, which are promising to be adoptable in practice, requires the simultaneous satisfaction of many criteria, such as coupling, cohesion, reuse and communication overhead. Search-based microservice identification has been recently investigated to address this problem. However, state-of-the-art search-based approaches are limited as they only consider one or two criteria (namely cohesion and coupling), possibly not fulfilling the practical needs of developers. To overcome these limitations, we propose toMicroservices, a many-objective search-based approach that considers five criteria, the most cited by practitioners in recent studies. Our approach was evaluated in a real-life industrial legacy system undergoing a microservice migration process. The performance of toMicroservices was quantitatively compared to a baseline. We also gathered qualitative evidence based on developers' perceptions, who judged the adoptability of the recommended microservices. The results show that our approach is both: (i) very similar to the most recent proposed approach on optimizing the traditional criteria of coupling and cohesion, but (ii) much better when taking into account all the five criteria. Finally, most of the microservice candidates were considered adoptable by practitioners.

Refactoring is a widely adopted practice for improving code comprehension and for removing severe structural problems in a project. When refactorings affect the system architecture, they are called architectural refactorings. Unfortunately, developers usually do not know when and how they should apply refactorings to remove architectural problems. Nevertheless, they might be more susceptible to applying architectural refactoring if they rely on code smells and code refactoring -- two concepts that they usually deal with through their routine programming activities. To investigate if smells can serve as indicators of architectural refactoring opportunities, we conducted a retrospective study over the commit history of 50 software projects. We analyzed 52,667 refactored elements to investigate if they had architectural problems that could have been indicated by automatically-detected smells. We considered purely structural refactorings to identify elements that were likely to have architectural problems. We found that the proportion of refactored elements without smells is much lower than those refactored with smells. By analyzing the latter, we concluded that smells can be used as indicators of architectural refactoring opportunities when the affected source code is deteriorated, i.e., the code hosting two or more smells. For example, when God Class or Complex Class appear together with other smells, they are indicators of architectural refactoring opportunities. In general, smells that often co-occurred with other smells (67.53%) are indicators of architectural refactoring opportunities in most cases (88.53% of refactored elements). Our study also enables us to derive a catalog with patterns of smells that indicate refactoring opportunities to remove specific types of architectural problems. These patterns can guide developers and make them more susceptible to apply architectural refactorings.

Innovation depends on the exploitation of market potential with products that are aligned with customer needs. However, building innovative products is becoming gradually more challenging because of increased market volatility, uncertainty, complexity and ambiguity. In our Innovation Lab, inside an e-Procurement Company, we encountered several challenges when implementing an innovation process to develop an initial unstructured data processing Minimum Viable Product (MVP) based on opensource big data tools: (i) raising and prioritizing user demands; (ii) deciding about adequate tools; and (iii) understanding how to promptly set up a viable product. In this paper, we share our open-source innovation experience in bringing novel solutions to an oil company's suppliers. In general, we present and discuss how we have been applying our innovation process to create MVPs, and which technical decision helped us accelerate the MVP development in the presence of a large-scale, unstructured database and open-source big data tools. Overall, we believe the proposed lean-based development process can help practitioners and researchers who want to understand and improve their knowledge about lean products, how to build MVPs, and advance open-source innovation involving big data tools.

Autonomous vehicles (AVs) are vehicles able to sense their environments and guide themselves with little or no human input. AVs have the potential to provide a wide variety of benefits to road traffic, such as improving traffic flow, alleviating traffic congestion and reducing car accidents. However, there are scenarios where AVs require governance systems capable of performing collaborative actions in order to keep traffic flowing smoothly and safely. This paradigm shift will support moving from isolated to collaborative autonomous vehicles. Our goal is to create a collaborative governance-based autonomous vehicle approach using adaptive normative multiagent systems to reduce congestion time. With this collaborative perspective in mind, steps should be taken for AVs to improve their collective mobility while not undermining the `social' goals of vehicle platoons and be able to provide benefits such as reduced congestion, increased travel choice and equity, and reduced pollutant emissions.

Several papers have recently contained reports on applying machine learning (ML) to the automation of software engineering (SE) tasks, such as project management, modeling and development. However, there appear to be no approaches comparing how software engineers fare against machine-learning algorithms as applied to specific software development tasks. Such a comparison is essential to gain insight into which tasks are better performed by humans and which by machine learning and how cooperative work or human-in-the-loop processes can be implemented more effectively. In this paper, we present an empirical study that compares how software engineers and machine-learning algorithms perform and reuse tasks. The empirical study involves the synthesis of the control structure of an autonomous streetlight application.

Agent-based Internet of Things (IoT) applications have recently emerged as applications that can involve sensors, wireless devices, machines and software that can exchange data and be accessed remotely. Such applications have been proposed in several domains including health care, smart cities and agriculture. However, despite their increased adoption, deploying these applications in specific settings has been very challenging because of the complex static and dynamic variability of the physical devices such as sensors and actuators, the software application behavior and the environment in which the application is embedded. In this paper, we propose a modeling approach for IoT analytics based on learning embodied agents (i.e. situated agents). The approach involves: (i) a variability model of IoT embodied agents; (ii) feedback evaluative machine learning; and (iii) reconfiguration of a group of agents in accordance with environmental context. The proposed approach advances the state of the art in that it facilitates the development of Agent-based IoT applications by explicitly capturing their complex and dynamic variabilities and supporting their self-configuration based on an context-aware and machine learning-based approach.

The rapidly changing environments in which companies operate to support the Internet of Things (IoT) and Autonomous Vehicles is challenging traditional Multi-agent System (MAS) approaches. The requirements of these highly dynamic environments gave rise to Adaptive Normative MAS approaches. At the same time, governance is an essential and challenging feature that still needs to be addressed in adaptive normative MAS. Indeed, governance of individual and societal agent behavior in Adaptive Normative MASs is still a vague concept that has not been properly investigated, modeled and implemented. However, governance is fundamental for solving problems involving MAS coordination, organizations and institutions. In this paper, we present our ongoing research towards understanding and improving governance in Adaptive Normative MASs. We also discuss challenges and future directions that will facilitate the development of domain-specific smart IoT systems with governance features.

The prevalence of design problems may cause re-engineering or even discontinuation of the system. Due to missing, informal or outdated design documentation, developers often have to rely on the source code to identify design problems. Therefore, developers have to analyze different symptoms that manifest in several code elements, which may quickly turn into a complex task. Although researchers have been investigating techniques to help developers in identifying design problems, there is little knowledge on how developers actually proceed to identify design problems. In order to tackle this problem, we conducted a multi-trial industrial experiment with professionals from 5 software companies to build a grounded theory. The resulting theory offers explanations on how developers identify design problems in practice. For instance, it reveals the characteristics of symptoms that developers consider helpful. Moreover, developers often combine different types of symptoms to identify a single design problem. This knowledge serves as a basis to further understand the phenomena and advance towards more effective identification techniques.

Testing the autonomy of, and the interaction between, the agents in Multiagent Systems (MAS) is the frontal challenge of traditional software testing approaches.When we study MAS governed by norms -mechanisms created to restrain the behavior of agents -this challenge increases even further.However, agents are autonomous and it is not guaranteed that they will fulfill all norms.Given the fuzzy notion of "test", especially in the context of MAS, in addition to the difficulties of dealing adequately with normative constraints, the overall understanding of how to handle the creation of tests for normative MAS is still vague.This paper proposes a testing tool to build and run MAS test scenarios and it relies on the use of aspect-oriented techniques to monitor the behavior of autonomous agents.We demonstrated our tool with a simulation of a traffic intersection scenario, based on the Brazilian Transit Code.Our experience shows that the tool can be used to build test scenarios that can achieve high fault detection effectiveness.

Nowadays, the challenge of knowledge discovery is to mine massive amounts of data available online.The most widely used approaches to tackle that challenge are based on machine learning techniques.In spite of being very powerful, those techniques require their parameters to be calibrated in order to generate models with better quality.Such calibration processes are time-consuming and rely on the skills of machine learning experts.Within this context, this research presents a framework based on software agents for automating the calibration of machine learning models.This approach integrates concepts from Agent Oriented Software Engineering (AOSE) and Machine Learning (ML).As a proof of concept, we first train a model for the IRIS dataset and then we show how our approach improves the quality of new models generated by our framework.

A common software product line strategy involves plugin-based web systems that support simple and quick incorporation of custom behaviors. As a result, they have been widely adopted to create web-based applications. Indeed, the popularity of ecosystems that support plugin-based development (e.g., WordPress) is largely due to the number of customization options available as community-contributed plugins. However, plugin-related vulnerabilities tend to be recurrent, exploitable and hard to be detected and may lead to severe consequences for the customized product. Hence, there is a need to further understand such vulnerabilities to enable preventing relevant security threats. Therefore, we conducted an exploratory study to characterize vulnerabilities caused by plugins in web-based systems. To this end, we went over WordPress vulnerability bulletins cataloged by the National Vulnerability Database as well as associated patches maintained by the WordPress plugins repository. We identified the main types of vulnerabilities caused by plugins as well as their impact and the size of the patch to fix the vulnerability. Moreover, we identified the most common security-related topics discussed among WordPress developers. We observed that, while plugin-related vulnerabilities may have severe consequences and might remain unnoticed for years before being fixed, they can commonly be mitigated with small and localized changes to the source code. The characterization helps to provide an understanding on how typical plugin-based vulnerabilities manifest themselves in practice. Such information can be helpful to steer future research on plugin-based vulnerability detection and prevention.

Norms exist to avoid and solve conflicts, make agreements, reduce complexity, and in general to achieve a desirable social order.However, norms eventually can be conflicting -for example, when there is a norm that prohibits an agent to perform a particular action and another norm that obligates the same agent to perform the same action at the same period of time.The agent' decision about which norms to fulfill can be defined based on rewards, punishments and agent goals.Sometimes, this balance will not be enough to allow the agent to make the best decision.In this context, this paper introduces an approach that considers the agent's personality traits in order to improve the solving process of normative conflicts.

Data mining has been a hot topic that attracts both database and machine learning researchers.Due to the constant growth of data volume there is an increasing need to obtain knowledge from these large data sets that are very difficult to handle and process with traditional methods.Software agents can play a significant role performing data mining processes in ways that are more efficient.For instance, they can work to perform selection, extraction, preprocessing and integration of data as well as parallel, distributed, or multisource mining.This paper proposes a framework based on multi-agent systems to apply data mining techniques to health data sets.For a first usage scenario, we use a data set for hypothyroidism and run two mining processes in parallel.

Multiagent systems (MASs) have been applied to several application domains, such as e-commerce, unmanned vehicles, and many others.In addition, a set of different techniques has been integrated into multiagent applications.However, few of these applications have been commercially deployed and few of these techniques have been fully exploited by industrial applications.One reason is the lack of procedures guaranteeing that multiagent systems would behave as desired.Most of the existing test approaches only test agents as single individuals and do not provide ways of inspecting the behavior of an agent as part of a group, and the behavior of the whole group of agents.Accordingly, we modeled and developed a publishsubscribe-based architecture to facilitate the implementation of systems to test MASs at the agent and group levels.To illustrate and evaluate the use of the proposed architecture, we developed an MAS-based application and performed functional and performance ad-hoc tests.

Data provenance refers to the historical record of the derivation of the data, allowing the reproduction of experiments, interpretation of results and identification of problems through the analysis of the processes that originated the data.Data provenance contributes to the evaluation of experiments.This paper presents a framework for data provenance using the W3C provenance data model, called PROV-DM.Such framework aims at contributing to, and facilitating, the collection, storage and retrieval of provenance data through a modeling and storage layer based on PROV-DM, yet is compatible with other representations of PROV such as PROV-O.To demonstrate the utilization of the framework, it was used in an IoT application that performs the gas classification to identify diseases.

This paper describes the implementation of an argumentation system used for participatory management of environmental protected areas, more precisely to model the decision of a park manager artificial agent.This implementation is based on a BDI agent architecture, namely the Jason/AgentSpeak framework/language.After introducing the principles of BDI architecture and of argumentation systems, we will detail how we model arguments within the BDI (Belief-Desire-Intention) architecture.Then, we present the argumentation-based model of deliberation and decision by the park manager agent as a case study.We show how our argument-based approach allows to model various cognitive profiles of park managers (more conservationist or more sensitive to social issues), through different knowledge bases.We show examples of decisions produced by the park manager agent and examples of traces of arguments used during deliberation, which could be a base for explaining decisions.Before concluding, we point out future directions, such as using argumentation as a basis for negotiation between various agents.

Data mining is a hot topic that attracts researchers of different areas, such as database, machine learning, and agent-oriented software engineering. As a consequence of the growth of data volume, there is an increasing need to obtain knowledge from these large datasets that are very difficult to handle and process with traditional methods. Software agents can play a significant role performing data mining processes in ways that are more efficient. For instance, they can work to perform selection, extraction, preprocessing, and integration of data as well as parallel, distributed, or multisource mining. This paper proposes a framework based on multiagent systems to apply data mining techniques to health datasets. Last but not least, the usage scenarios that we use are datasets for hypothyroidism and diabetes and we run two different mining processes in parallel in each database.

International audience

Exception handling mechanisms have been introduced into programming languages in an effort to help deal with runtime irregularities. These mechanisms aim to improve code reliability by providing constructs for sectioning code into exception scopes (e.g. Java try blocks) and exception handlers (e.g. Java catch blocks). Whilst exception handling mechanisms have been the focus of much research over the past years, empirical studies have only focused on characterising exception handling code of Java and C# programs. There exists little empirical evidence on how exception handling mechanisms are used to develop software with other programming languages. Moreover, to date there exists no empirical study which has examined the structure of exception scopes across software projects. We address these shortcomings by examining the commonalities and differences of both exception scopes and handlers implemented with a wider range of languages. To this end, we analysed 50 software projects, containing code developed in C++, JavaScript, PHP, Java and C#. More than 9 million lines of code and over 20,000 exceptional code blocks were analysed. Our findings revealed significant differences in the frequency, structure and length of exception scopes and exception handlers across languages. This finding suggests that certain exception handling mechanisms are less explored by programmers using certain programming languages. However, regardless of language, exception handlers remained simplistic and in general only ever one handler was associated with each scope. Finally, our analysis confirms the existing belief that developers often pay little attention to developing exception scoping and handling behaviour.

Norms have become a promising mechanism to ensure that open multi-agent systems (MASs) produce a desirable social outcome.MASs can be defined as societies in which autonomous agents work to achieve both societal and individual goals.Norms regulate the behavior of agents by defining permissions, obligations and prohibitions, as well as encouraging and discouraging the fulfillment of norms through rewards and punishments mechanisms.Once the priority of software agent is the satisfaction of its own desires and goals, each agent must evaluate the effects associated to the fulfillment or violation of one or more norms before choosing which one should be complied.This paper introduces a framework for normative MASs simulation that provides mechanisms for understanding the impact of norms on an agent and the society to which an agent belongs.

Preferences have been widely studied in several areas including computer science, as they play an important role in many computational tasks, such as decision making support, providing recommendations and personalizing applications. Although many approaches consider particular preference representation models to be used as input for algorithms to address these tasks, there is a need for identifying a model that provides adequate constructions for users to express their preferences. In this paper, we propose a preference meta-model that provides various preference constructs, which include end-user expressions. We start by describing an exploratory study of how people express their preferences in natural language, which provides the basis for the meta-model. After describing the meta-model, we evaluate it with two user studies in different domains. The results of this evaluation indicate that the preference statements that can be expressed with the meta-model are adequate for allowing users to indicate their preferences to a computational system.

Explanations play an essential role in decision support and recommender systems as they are directly associated with the acceptance of those systems and the choices they make. Although approaches have been proposed to explain automated decisions based on multi-attribute decision models, there is a lack of evidence that they produce the explanations users need. In response, in this paper we propose an explanation generation technique, which follows user-derived explanation patterns. It receives as input a multi-attribute decision model, which is used together with user-centric principles to make a decision to which an explanation is generated. The technique includes algorithms that select relevant attributes and produce an explanation that justifies an automated choice. An evaluation with a user study demonstrates the effectiveness of our approach.

Model composition plays a central role in many software engineering activities, e.g., evolving design models to add new features. To support these activities, developers usually rely on model composition heuristics. The problem is that the models to-be-composed usually conflict with each other in several ways and such composition heuristics might be unable to properly deal with all emerging conflicts. Hence, the composed model may bear some syntactic and semantic inconsistencies that should be resolved. As a result, the production of the intended model is an error-prone and effort-consuming task. It is often the case that developers end up examining all parts of the output composed model instead of prioritizing the most critical ones, i.e., those that are likely to be inconsistent with the intended model. Unfortunately, little is known about indicators that help developers (1) to identify which model is more likely to exhibit inconsistencies, and (2) to understand which composed models require more effort to be invested. It is often claimed that software systems remaining stable over time tends to have a lower number of defects and require less effort to be fixed than unstable systems. However, little is known about the effects of software stability in the context of model evolution when supported by composition heuristics. This paper, therefore, presents an exploratory study analyzing stability as an indicator of inconsistency rate and resolution effort on model composition activities. Our findings are derived from 180 compositions performed to evolve design models of three software product lines. Our initial results, supported by statistical tests, also indicate which types of changes led to lower inconsistency rate and lower resolution effort.

SUMMARY Establishing explicit mappings between features and their implementation elements in code is one of the critical factors to maintain and evolve software systems successfully. This is especially important when developers have to evolve program families, which have evolved from one single core system to similar but different systems to accommodate various requirements from customers. Many techniques and tools have emerged to assist developers in the feature mapping activity. However, existing techniques and tools for feature mapping are limited as they operate on a single program version individually. Additionally, existing approaches are limited to recover features on demand, that is, developers have to run the tools for each family member version individually. In this paper, we propose a cohesive suite of five mapping heuristics addressing those two limitations. These heuristics explore the evolution history of the family members in order to expand feature mappings in evolving program families. The expansion refers to the action of automatically generating the feature mappings for each family member version by systematically considering its previous change history. The mapping expansion starts from seed mappings and continually tracks the features of the program family, thus eliminating the need of on demand algorithms. Additionally, we present the MapHist tool that provides support to the application of the proposed heuristics. We evaluate the accuracy of our heuristics through two evolving program families from our industrial partners. Copyright © 2013 John Wiley & Sons, Ltd.

Model-Based Testing (MBT) has attracted the attention of many industries and, hence, it has provided several approaches reported in the literature. The Software Engineering Lab (LES) at the Pontifical Catholic University of Rio de Janeiro has worked extensively on coordinating and carrying out tests of large-scale software systems developed (for web and desktop) for different domains (e.g. petroleum, e-commerce, etc). Based on this experience, an LES test group created a new test modeling language called UML Testing Profile for Coordination (UTP-C) to model relevant test data. However, to use the advantages of the new modeling, an appropriate test-modeling tool became necessary. Thus, this paper presents the RSA-MBT, a new plug-in developed for the Rational Software Architecture (RSA) tool, to generate a set of test artifacts from UTP-C diagrams.

A program family might degenerate due to unplanned changes in its implementation, thus hindering the maintenance of family members. This degeneration is often induced by feature code that is changed individually in each member without considering other family members. Hence, as a program family evolves over time, it might no longer be possible to distinguish between common and variable features. One of the imminent activities to address this problem is the history-sensitive recovery of program family's features in the code. This recovery process encompasses the analysis of the evolution history of each family member in order to classify the implementation elements according to their variability nature. In this context, this paper proposes history-sensitive heuristics for the recovery of features in code of degenerate program families. Once the analysis of the family history is carried out, the feature elements are structured as Java project packages; they are intended to separate those elements in terms of their variability degree. The proposed heuristics are supported by a prototype tool called RecFeat. We evaluated the accuracy of the heuristics in the context of 33 versions of 2 industry program families. They presented encouraging results regarding recall measures that ranged from 85% to 100%; whereas the precision measures ranged from 71% to 99%.

Since software product lines (SPLs) increasingly have to satisfy additional requirements, their designs might degenerate over time. The degeneration is caused by various reasons. For instance, the features suddenly start to be realized and they evolved in inconsistent ways across multiple products. In an extreme case, the SPL code is fully or partially replicated and individually changed across several evolving products. In order to regain control of the SPL assets, a key activity is the design recovery of features from existing applications. However, existing techniques for feature analysis are not effective as they tend to explicitly rely on a single project history. They do not take into consideration change histories of features across multiple evolving products of a SPL. This research proposes a novel technique for history-sensitive feature recovery while repairing degenerated SPL designs. Our technique is ought to encompass a set of heuristics for facilitating SPL design recovery. We aim at investigating to what extent exploiting multi-product change histories allow accurate identification of: (i) code elements that contribute to each feature realization; and (ii) variability properties of the feature code. The empirical evaluation of our technique will be based on two industry case studies.

Twenty-first century global change is challenging our use and management of all resources. For a community to adapt and yet maintain and even enhance its economy and quality of life, there is a need for collaborative innovation (CI) and related action among concerned members of the community. This paper outlines the concepts of an approach to CI based on dynamic asset-mapping and its support through a web-based technological framework. Based on real-world experience with the framework, it is clear that CI takes many forms and that it is not possible to build a single set of tools to support CI. Rather a framework and a set of meta-tools is needed which can be used to build tailored systems to fit specific situations that arise when collaboration is to occur.

This paper presents a human-centered vision of unmanned but crewed platforms, combining an onshore collaborative hybrid environment and an intelligent offshore oilfield. Computer science plays a major role in this vision since digital environments are paramount for the job. We discuss the importance of research in the fields of computer graphics, virtual reality and computer supported cooperative work in this context and present the basic technologies needed to accomplish the task. We instantiate our vision appointing the results of some initial experiments using virtual reality in submarine installation operations.

Abstract Recovery‐oriented software is built with the perspective that hardware or software failures and operation mistakes are facts to be coped with, as they are problems that cannot be fully solved while developing real complex applications. Consequently, any software will always have a non‐zero chance of failure. Some of these failures may be caused by defects that may be removed or encapsulated. From the point of view of removing or encapsulating defects, a failure is considered to be trivial, when (i) the required effort to identify and eliminate or encapsulate the causing defect is small, (ii) the risk of making mistakes in these steps is also small and (iii) the consequences of the failure are tolerable. It is highly important to design systems in such a way that most (ideally all) of the failures are trivial. Such systems are called ‘debuggable systems’. In this study, we present the results of systematic applying techniques that focus on creating debuggable software for real embedded applications. Copyright © 2008 John Wiley & Sons, Ltd.

Based on the 3C collaboration model, this article descries the mapping of a variety of collaboration forms onto inter-relationships between communication, coordination and cooperation. In order to investigate how to provide computational support for these three functional collaboration dimensions the analysis shifts from the inter-relationships between these three dimensions to their intra-relationships. Finally, Gestalt psychology principles are used to discuss the suitability of the approach to human perception.

Abstract Mobile agents have come forward as a technique for tackling the complexity of open distributed applications. However, the pervasive nature of code mobility implies that it cannot be modularized using only object‐oriented (OO) concepts. In fact, developers frequently evidence the presence of mobility scattering in their system's modules. Despite these problems, they usually rely on OO application programming interfaces (APIs) offered by the mobility platforms. Such classical API‐oriented designs suffer a number of architectural restrictions, and there is a pressing need for empowering developers with an architectural framework supporting a flexible incorporation of code mobility in the agent applications. This work presents an aspect‐oriented software architecture, called ArchM, ensuring that code mobility has an enhanced modularization and variability in agent systems, and is straightforwardly introduced in otherwise stationary agents. It addresses OO APIs' restrictions and is independent of specific platforms and applications. An ArchM implementation also overcomes fine‐grained problems related to mobility tangling and scattering at the implementation level. The usefulness and usability of ArchM are assessed within the context of two case studies and through its composition with two mobility platforms. Copyright © 2008 John Wiley & Sons, Ltd.

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.

Adoption strategies for Software Product Lines (SPL) frequently involve bootstrapping existing products into a SPL and extending an existing SPL to encompass another product. One way to do that is to use program refactorings. However, the traditional notion of refactoring does not handle appropriately feature models (FM), nor transformations involving multiple instances of the same SPL. For instance, it is not desirable to apply a refactoring into a SPL and reduce its configurability. In this paper, we extend the traditional notion of refactoring to an SPL context. Besides refactoring programs, FMs must also be refactored. We present a set of sound refactorings for FMs. We evaluate this extended refactoring definition for SPL in a real case study in the mobile games domain.

Software is becoming present in every aspect of our lives, pushing us inevitably towards a world of ambient computing systems. Multi-agent systems (MAS) are a prominent technology which facilitates modeling and development of large-scale distributed systems. In recent years, software engineering research has focused on methodologies and techniques for improving MAS design and implementation. However, making large MAS dependable is still an open issue. The Fifth Workshop on Software Engineering for Large-Scale Multi-Agent Systems (SELMAS 2006) aims to bring together academic, industrial and commercial communities interested in agent-oriented software engineering topics to discuss the different technologies being defined and used in the development of dependable MAS.

One of the main promises of aspect-oriented programming (AOP) is to promote improved modularization of crosscutting concerns, thereby enhancing the software stability in the presence of changes. This paper presents a quantitative study that assesses the positive and negative effects of AOP on typical maintenance activities of a Web information system. The study consists of a systematic comparison between the object-oriented and the aspect-oriented versions of the same application in order to assess to what extent each solution provides maintainable software decompositions. Our analysis was driven by fundamental modularity attributes, such as coupling, cohesion, conciseness, and separation of concerns. We have found that the aspect-oriented design has exhibited superior stability and reusability through the changes, as it has resulted in fewer lines of code, improved separation of concerns, weaker coupling, and lower intra-component complexity

This paper presents the AulaNet learning management system, its architecture and the collaboration model that guided its development and that was refined during this process. A case study of an online course indicates the necessity to have an architectural support for collaboration aspects and a collaboration-based engineering approach to groupware development. This approach, groupware engineering, is based on software engineering and on concepts originated in the field of CSCW.

is becoming present in every aspect of our lives, pushing us inevitably towards a world of distributed, context-aware computing systems. SELMAS'05, Software Everywhere - Context-Aware Agents, builds on the success of precedent SELMAS workshops, but with a special emphasis on the impact of the agent technology in the development of large context-aware systems. SELMAS has a track record of bringing together researchers and practitioners with a variety of perspectives in order to engage in lively discussion and debate.

This paper introduces an approach based on the 3C (communication, coordination and cooperation) collaboration model to the development of collaborative systems. The 3C model is studied by means of a detailed analysis of each of its three elements, followed by a case study of a learningware application and the methodology of a web-based course, both designed based on this model. Moreover, this paper describes a component-based system architecture following this 3C approach.

The development of multiagent systems (MAS) is not a trivial task. In addition, with the advances in Internet technologies, MAS are undergoing a transition from closed to open architectures composed of a huge number of autonomous agents, which operate and move across different environments. In fact, openness introduces additional complexity to the system modeling, design and implementation. It also impacts on most quality attributes of MAS, including scalability, interoperability, reliability and adaptability. This paper brings together researchers and practitioners to discuss the current state and future direction of research in software engineering for open MAS. A particular interest is to understand those issues in the agent technology that make it difficult and/or improve the production of large open systems.

Abstract Software engineers of multi‐agent systems (MASs) are faced with different concerns such as autonomy, adaptation, interaction, collaboration, learning, and mobility, which are essentially different from classical concerns addressed in object‐oriented software engineering. MAS developers, however, have relied mostly on object‐oriented design techniques and programming languages, such as Java. This often leads to a poor separation of MAS concerns and in turn to the production of MASs that are difficult to maintain and reuse. This paper discusses software engineering approaches for MASs, and presents a new method for integrating agents into object‐oriented software engineering from an early stage of design. The proposed approach encourages the separate handling of MAS concerns, and provides a disciplined scheme for their composition. Our proposal explores the benefits of aspect‐oriented software development for the incorporation of agents into object‐oriented systems. We also illustrate our aspect‐oriented approach through the Portalware multi‐agent system, a Web‐based environment for the development of e‐commerce portals. Copyright © 2004 John Wiley & Sons, Ltd.

Object-oriented frameworks are currently regarded as a promising technology for reusing designs and implementations. However, developers find there is still a steep learning curve when extracting the design rationale and understanding the framework documentation during framework instantiation. Thus, instantiation is a costly process in terms of time, people, and other resources. These problems raise a number of questions including: "How can we raise the level of abstraction in which the framework instantiation is expressed, reasoned about and implemented?" "How can the same high-level design abstractions that were used to develop the framework be used during framework instantiation instead of using source code as is done currently?" "How can we define extended design abstractions that can allow framework instantiation to be explicitly represented and validated?" We present an approach to framework instantiation based on software processes that addresses these issues. Our main goal is to represent the framework design models in an explicit and declarative way, and support changes to this design based on explicit instantiation tasks based on software processes while maintaining system integrity, invariants, and general constraints. In this way, the framework instantiation can be performed in a valid and controlled way.

The consistency problems in UML models and related software processes can be very complex. First, although UML supports a modeling process that should yield inter and intraconsistent models, the meaning of the UML dependencies and their specializations is not precisely defined and, for this reason, many inconsistencies may appear in their models and processes. Precise definitions would form a basis for methods to detect and analyze consistency problems related to UML dependencies and relationships, as well as problems related to software processes described in UML. In addition, we are using the UML object constraint language (OCL) to describe constraints related to the framework instantiation process. OCL is recognized as a limited language in some aspects for expressing well-formedness rules. We have presented a method (T.C. Oliveira et al., 2004) that works in the case of consistent rules and consistent instantiation processes.

Objects and agents are abstractions that exhibit Points of similarity, but the development of multi-agent systems (MASs) poses other challenges to Software Engineering since software agents are inherently more complex entities. In addition, a large MAS needs to satisfy multiple stringent requirements such as reliability, trustability, security, interoperability, scalability, reusability, and maintainability. This workshop brings together researchers and practitioners to discuss the current state of the art and the future research directions in software engineering for large-scale MASs. A particular interest is to understand those issues in the agent technology that make it difficult and/or improve the production of complex distributed systems.

In this article, we describe a specification model that seeks to couple formal specification methods and agent-oriented software engineering techniques. The objective is to allow faster formal development of flexible and reusable multiagent systems (MAS) with strict requirements of quality and reliability. The specification model is specifically tailored to support highly dynamic and evolutive characteristics of MAS. The agents are formally specified and instantiated by a framework and reuse is achieved by transforming the framework structural model into multiple agents. Agent flexibility, and adaptation capacity is ensured through the use of design patterns and properties such as: encapsulation, high-cohesion, low-coupling and through the definition of a formal XML model. The specification model represented in XML can be transformed into a code block that needs few adjustments, granting the system a high flexibility and trustworthiness. The purpose is to reduce time, effort and costs associated with MAS design and development with high quality requirements and reliability.

Objects and agents are abstractions that exhibit points of similarity, but the development of agent-based software poses other challenges to software engineering since software agents are inherently more complex entities. In addition, a large-scale multi-agent system needs to satisfy multiple stringent requirements such as reliability, security, interoperability, scalability, reusability, and maintainability. This workshop brought together researchers and practitioners to discuss the current state and future direction of research in software engineering for large-scale multi-agent systems. A particular interest was to understand those issues in the agent technology that difficult and/or improve the production of large-scale distributed systems.

Abstract The ‘views’ relationship indicates how an object‐oriented design can be clearly separated into objects and their corresponding interface. This paper uses the concept of ‘views’ in order to achieve full separation between the application and the security policy in the design and implementation. The result is achieved by providing a model for capabilities using ‘views’ that is richer than the traditional capability model. In addition, a distributed access control model is shown to be effective through the use of Secure Object Communication Channels (SOCCs) to allow for secure connections at the abstract object level. This security is applicable in the e‐commerce application domain, bringing security directly to the application abstraction level. Copyright © 2002 John Wiley & Sons, Ltd.

This paper motivates and describes a logic-based approach to specifying and reasoning about interfaces and objects that focuses on separation of concerns issues. The approach is based on the abstract design view (ADV), a software design model for object-oriented systems. The model was originally introduced to characterize, in an informal and practical setting, a clear separation between objects, which we called abstract design objects and their interfaces (ADVs). The objects capture the basic concern, while the interfaces capture special concerns such as user interface, control, timing, and distribution. First, we analyze the ADV design model in order to precisely characterize the interfaces, their associated objects, and the relationship between them. Then, we present one possible approach to formalizing interfaces, objects, and the "views-a" relationship. The central mathematical tools used for this purpose are temporal logic and some tools from the category theory. The formal approach is illustrated by examples that show how the interface and related objects and the views-a relationship can be used in object-oriented specifications. We also show how the theory enables the designer to perform relevant analysis activities while modeling with separation of concerns in mind. The theory can be used to derive dynamic and structural properties of the interface objects and the views-a relationship. In particular, we can use the theory to derive global properties of interfaces that capture special concerns from the local properties of their related objects.

This paper describes an approach to component-based software engineering based on a formal description of design patterns. The architectural design information, captured by design patterns, is made explicit and represented in a declarative way, being packaged into tangible artifacts as building block design components in the development process. These design component descriptions can be instantiated, adapted, assembled, implemented, and maintained. Furthermore, we can use these representations to reason about properties related to the combination of design components. We illustrate the utility of our approach through a case study involving various design patterns.

Visual composition is an interactive development of different applications by the direct manipulation of reusable components. We believe that the visual composition approach deals directly with the complexity of large software systems, making their development easier, more flexible, and easier to be understood. This is accomplished by implementing abstraction, reuse and visualization concepts. The developer becomes a component builder and no longer creates large applications that are hard to maintain and enhance. The user will have the freedom to choose the components he needs to build an application, and to mix and match components from different developers until the desired functionality is achieved. The visual Spider environment allows the creation of different kinds of applications. Copyright © 1999 John Wiley & Sons, Ltd.

We describe a black box approach to software system evolution where viewpoints are used to alter a design without modifying the original system. A viewpoint is a model, possibly incomplete, of a domain from a given perspective. We discuss the views-an operator and its semantics, and then apply the concepts to the NACHOS file system as a case study. We believe the approach can be applied to existing object oriented software systems, and serve as a guide for developing systems which are more easily maintained. This case study is an example of an application of a more general transformational approach to software design and implementation

Abstract In this paper we present a logical framework for evolving software systems in which the critical aspects of large-scale software systems maintenance are treated by an approach which considers that configuration management is essentially concerned with the management of system changes. The basis of this framework is a formal description of transitions that might be made in the soft-ware change process, the purpose of the formalism is to allow deductions to be made about the validity of such transitions. A generalised formal description of software system architectures from the viewpoint of evolving software systems is also provided in the paper. Reasoning about functional aspects of these descriptions is achieved through the interaction of a theorem prover for the proposed metalogic formalism and a theorem prover for reasoning about sequential programs. In our approach the alterations of software descriptions can be viewed as programming-in-the-large transformations which are stated by means of the descriptive/prescriptive (deontic) features of actions.

To be added when journal hard copy located (also figct,tabct & refct) (not provided by typesetter)

The abstract data view (ADV) design model was originally created to specify clearly and formally the separation of the user interface from the application component of a software system, and to provide a systematic design method that is independent of specific application environments. Such a method should lead to a high degree of reuse of designs for both interface and application components. The material presented, extends the concept of ADV's to encompass the general specification of interfaces between application components in the same or different computing environments. This approach to specifying interfaces clearly separates application components from each other, since they do not need to know how they are used, or how they obtain services from other application components. Thus, application components called abstract data objects (ADOs), are designed to minimize knowledge of the environment in which they are used and should be more amenable to reuse.>

Reading and understanding programs is a key activity in software reengineering, development, and maintenance. The ability of people to understand programs is directly related to the ease with which the source code and documentation can be read. Thus, enhancements to the style of presentation should heighten this comprehensibility. We describe methods that use markup languages such as SGML to embed information about the syntax and semantics of a program in the program code, and then show how these can be used to enhance its presentation style. We also briefly discuss the extension of these markup language concepts to text databases, and indicate how they can support various structural views of the code through browsing techniques associated with database queries.>

Abstract Creating new applications by integrating user interface and application components is a relatively new idea which is currently of wide interest. A significant part of this problem is clearly defining the separation between user interface and application components. This paper proposes a new design methodology based on the concept of an abstract data view (ADV), a structuring method which cleanly defines this separation. A number of examples of composite interactive documents, ones which could contain several different user interfaces with entities such as text, calculations, drawings and possibly even multi‐media presentations, illustrate the ADV concept. These examples lead naturally to the introduction of the concept ofhole, a user interface area in a composite interactive document which is managed by an external program, and uses ADVs. Prototypes of a number of systems supporting ADVs and holes are currently running in our laboratory.

PUC (planned user communication) requirements are based on the view that the ideal environment for designing a personalized interface is one which involves the collaboration of the user and an interface designer who knows about the application. The approach used in the design of PUC was to incorporate the interface designer into the environment and invite the user to produce his/her own interface with its assistance. The aim of the approach is to allow the end user to plan his/her future interaction with an application while learning about it.>

Abstract The present paper discusses a method of program construction based on the specification of the data types. The input and output data types and the mapping between them are specified at a high level of abstraction and this non‐procedural specification is used to develop a program schema. The data type and mapping specifications are modified to include a concrete representation of the data and these are used to expand the program schema into a program. A graphical representation for data and program specifications is also introduced and it is shown how this can simplify the techniques and be very useful in program construction. The method is illustrated by developing two programs—the line justifier program described by Gries and the bubblesort.

The present paper discusses some issues in program synthesis by relating the idea of systematic program derivation with the concepts of data type and correctness of data representation. The notion of an incomplete definition of a data type at a high level of abstraction is introduced. The ideas are illustrated through an example previously discussed in the literature by D. Gries.

Abstract This paper describes the Implementation model of a data definition facility for abstract data types, implemented as an extension to PL/1. The facility is based on a modified version of the cluster mechanism for the implementation of types. The proposed version tries to address the issues of efficiency and portability in connection with the goal of systematic programming.