Papers by Alessandro Garcia
Electronic Notes in Theoretical Computer Science, 2009
It has been advocated that Aspect-Oriented Programming (AOP) is an effective technique to improve... more It has been advocated that Aspect-Oriented Programming (AOP) is an effective technique to improve software maintainability through explicit support for modularising crosscutting concerns. However, in order to take the advantages of AOP, there is a need for supporting the systematic refactoring of crosscutting concerns to aspects. Existing techniques for aspect-oriented refactoring are too fine-grained and do not take the concern structure into consideration. This paper presents two categories towards a metaphorbased classification of crosscutting concerns driven by their manifested shapes through a system's modular structure. The proposed categories provide an intuitive and fundamental terminology for detecting concernoriented design flaws and identifying refactorings in terms of recurring crosscutting structures. On top of this classification, we define a suite of metaphor-based refactorings to guide the "aspectisation" of each concern category. We evaluate our technique by classifying concerns of 23 design patterns and by proposing refactorings to aspectise them according to observations made in previous empirical studies. Based on our experience, we also determine a catalogue of potential additional categories and heuristics for refactoring of crosscutting concerns.
Anais do XX Simpósio Brasileiro de Engenharia de Software (SBES 2006)
In a previous work, we proposed a framework extension approach based on the use of a new concept,... more In a previous work, we proposed a framework extension approach based on the use of a new concept, called Extension Join Points (EJPs). EJPs enable the framework systematic extension by means of variability and integration aspects. In this paper, we show how EJPs can be implemented using the mechanisms of the AspectJ language. To evaluate the usefulness of the EJPs in the framework extension process, we have used them in the development of three OO frameworks from different domains. As a result of our case studies, we present: (i) an initial categorization of different kinds of contracts between frameworks, EJPs and aspects which can be implemented in AspectJ; and (ii) a set of lessons learned when specifying the EJPs.
ACM SIGSOFT Software Engineering Notes, 2006
Software architects face decisions every day which have a broadly-scoped impact on the software a... more Software architects face decisions every day which have a broadly-scoped impact on the software architecture. These decisions are the core of the architecting process as they typically have implications in a multitude of architectural elements and views. Without an explicit representation and management of those crucial choices, architects cannot properly communicate and reason about them and their crosscutting effects. The result is a number of architectural breakdowns, such as decreased evolvability, time-consuming trade-off analysis, and unmanageable traceability. Aspects are a natural way to capture widely-scoped architectural decisions and promote software architectures with superior modularity.
Proceedings of the 14th International Conference on Modularity, 2015
The progressive insertion of code anomalies in evolving software systems might lead to architectu... more The progressive insertion of code anomalies in evolving software systems might lead to architecture degradation symptoms. Code anomalies are particularly harmful when they contribute to the architecture degradation. Although several approaches have been proposed aiming to detect anomalies in the source code, most of them fail to assist developers when prioritizing code anomalies critical to the architectural design. Blueprints of the architecture design are artifacts often available in industry software projects. However, such blueprints are rarely explored to support the prioritization of code anomalies in terms of their architecture relevance. This paper proposes and evaluates 2 sets of blueprintbased heuristics for supporting the prioritization of critical code anomalies. The prioritization is based on their potential impact on revealing architectural drift problems. The heuristics allow developers prioritizing critical code anomalies by exploiting architectural information provided in the blueprint. The contributions of this paper include: (i) a set of architecture sensitive heuristics to support developers when prioritizing critical code anomalies; (ii) an evaluation of the proposed heuristics in terms of their prioritization accuracy in 3 systems; and (iii) an empirical analysis on how the blueprints' information might enhance the prioritization of critical code anomalies, as opposed to existing heuristics strictly based on source code analysis.
Proceedings of the tenth international conference on Aspect-oriented software development - AOSD '11, 2011
Although aspect-oriented programming (AOP) aims to improve software maintainability, developers c... more Although aspect-oriented programming (AOP) aims to improve software maintainability, developers can unwittingly introduce code smells in their programs. A code smell is any symptom in the source code that possibly indicates a deeper maintainability problem. Even though a few code smells for AOP have been reported in the literature, there is no evidence if and how they occur in evolving software projects. There is also little knowledge on their actual impact on maintenance effort, such as required refactorings or corrective changes in later software releases. This paper presents an exploratory analysis of code smells recurrently observed in a set of evolving aspect-oriented systems. We analyzed instances of code smells previously reported in the literature and newly-revealed ones. Our study involved in total 18 releases of 3 evolving aspect-oriented systems from different domains. The outcome of our evaluation suggests that previously-documented AOP smells might not occur as often as claimed. Our analysis also revealed that: (1) newly-discovered code smells might occur more often than well-known ones, and (2) the former ones seemed to be consistently associated with non-trivial refactorings and corrective changes.
2012 26th Brazilian Symposium on Software Engineering, 2012
The evolution of software product lines (SPLs) is particularly challenging. SPL functionalities, ... more 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.
2012 28th IEEE International Conference on Software Maintenance (ICSM), 2012
Code anomalies are likely to be critical to the systems' maintainability when they are related to... more Code anomalies are likely to be critical to the systems' maintainability when they are related to architectural problems. Many tools have been developed to support the identification of code anomalies. However, those tools are restricted to only analyze source code structure and identify individual anomaly occurrences. These limitations are the main reasons why state-of-art tools are often unable to identify architecturally-relevant code anomalies, i.e. those related to architectural problems. To overcome these shortcomings we propose SCOOP, a tool that includes: (i) architecture-code traces in the analysis of the source code, and (ii) exploits relationships between multiple occurrences of code anomalies to detect the architecturally-relevant ones. Our preliminary evaluation indicated that SCOOP was able to detect anomalous code elements related to 293 out of 368 architectural problems found in 3 software systems.
Lecture Notes in Computer Science, 2006
Several concerns in the development of multi-agent systems (MASs) cannot be represented in a modu... more Several concerns in the development of multi-agent systems (MASs) cannot be represented in a modular fashion. In general, they inherently affect several system modules and cannot be explicitly captured based on existing software engineering abstractions. These crosscutting concerns encompass internal agent properties and systemic properties, such as learning, code mobility, error handling, and context-awareness. In this context, it is important to systematically verify whether emerging development paradigms support improved modularization of the crosscutting concerns relative to MASs. This paper reports some lessons learned based on our experience in using aspect-oriented techniques and methods to address these problems. In the light of these lessons, related work and a set of future research directions are also discussed.
2009 XXIII Brazilian Symposium on Software Engineering, 2009
Resumo-Neste artigo nós propomos uma abordagem integrada para gerenciar variabilidades em especif... more Resumo-Neste artigo nós propomos uma abordagem integrada para gerenciar variabilidades em especificac ¸ões arquiteturais de linhas de produtos de software. Nossa abordagem combina uma linguagem de descric ¸ão arquitetural orientada a aspectos, PL-AspectualACME, com uma linguagem de modelagem de variabilidades, VML4Arch. PL-AspectualACME, também proposta neste artigo, é usada para especificar a descric ¸ão arquitetural geral que consiste na representac ¸ão modular de similaridades e variabilidades arquiteturais. VML4Arch é usada para derivar automaticamente descric ¸ões arquiteturais de produtos específicos através da especificac ¸ão de dependências entre features e as variabilidades que devem ser incluídas nos produtos. Nós ilustramos a aplicac ¸ão da nossa abordagem usando uma linha de produtos de software para aplicac ¸ões de dispositivos móveis.
Proceeding of the 2nd international workshop on Product line approaches in software engineering - PLEASE '11, 2011
The integration of multiple SPLs is increasingly becoming a trend to enable on-demand derivation ... more The integration of multiple SPLs is increasingly becoming a trend to enable on-demand derivation of new products and accelerate their time-to-market. Integration of SPLs often implies the reuse of a previously-implemented feature across other SPLs. The reuse of a SPL feature is only viable if the underlying programming mechanisms enable its smooth composition within the code of other SPLs. If the required modifications are significant, the design of the target SPLs are likely to be destabilized. This paper presents an exploratory study on the integration of three product lines from the board game domain. We investigate how aspectoriented and feature-oriented programming impact on the reuse and stability of those product lines.
Proceedings of the 4th international workshop on Exception handling - WEH '08, 2008
Executable models are increasingly being employed by development teams to implement robust softwa... more Executable models are increasingly being employed by development teams to implement robust software systems. Modern executable models offer powerful composition mechanisms that allow developers to deliver a running system in small increments and in a time-effective fashion. Such models act like code by providing high-level development abstractions and, as a consequence, it is expected that increased software robustness is achieved. However, existing executable models have a number of limitations on the representation of exceptional behaviour. Similarly to exception handling in programming languages, one of the key problems is that the modelling languages and supporting environments do not allow the explicit specification of global exception flows. They require that developers understand the source of an exception, the place where it is handled, and everything in between. As system development evolves, exceptional control flows become less well-understood, with negative consequences for the program maintainability and robustness. In this paper, we claim that such problem can be addressed by an innovative exception handling model which provides abstractions to explicitly describe global views of exceptional control flows. The implementation of our proposed model extends the aspect-oriented language constructs and the control-flow analysis of the Motorola WEAVR with the aim of promoting enhanced robustness and program modularization.
2009 XXIII Brazilian Symposium on Software Engineering, 2009
Most of the exceptions exert a global design impact as they tend to flow through multiple module ... more Most of the exceptions exert a global design impact as they tend to flow through multiple module interfaces of a software system. Exception handling mechanisms in programming languages were originally proposed to improve the robustness and comprehension of error handling code. These mechanisms are traditionally based on the fundamental assumption that global exception flows should be always implicit. However, it has been empirically found that the implementation of global exception handling in real-life software projects tends to exhibit poor quality. This paper presents an exploratory study to assess the benefits and drawbacks of explicit exception flows (or exception channels), as opposed to implicit exception flows. The experiment design involved 15 participants using three alternative mechanisms for exception handling. Our analysis was driven by key indicators of software usability: (i) implementation time, (ii) number of uncaught exceptions, and (iii) number of incorrect answers by the participants.
2012 IEEE 36th Annual Computer Software and Applications Conference, 2012
Lecture Notes in Computer Science, 2013
The importance of model composition in model-centric software development is well recognized by r... more The importance of model composition in model-centric software development is well recognized by researchers and practitioners. However, little is known about the critical factors influencing the effort that developers invest to combine design models, detect and resolve inconsistencies in practice. This paper, therefore, reports on five industrial case studies where the model composition was used to evolve and reconcile large-scale design models. These studies aim at: (1) gathering empirical evidence about the extent of composition effort when realizing different categories of changes, and (2) identifying and analyzing their influential factors. A series of 297 evolution scenarios was performed on the target systems, leading to more than 2 million compositions of model elements. Our findings suggest that: the inconsistency resolution effort is much higher than the upfront effort to apply the composition technique and detect inconsistencies; the developer's reputation significantly influences the resolution of conflicting changes; and the evolutions dominated by additions required less effort.
IEEE Software, 2006
A model curriculum for aspect-oriented software development provides guidelines about fundamental... more A model curriculum for aspect-oriented software development provides guidelines about fundamentals, a common framework, and a step toward developing a body of knowledge.
Abstract. Software composition defines the interaction between two or more modules. Advanced prog... more Abstract. Software composition defines the interaction between two or more modules. Advanced programming techniques, such as aspect-oriented programming and feature-oriented programming, support a wide range of expressive composition mechanisms that ...
Techniques for composing architectural specifications are emerging in order to facilitate softwar... more Techniques for composing architectural specifications are emerging in order to facilitate software architecture evolution. However, there is little empirical understanding on whether such techniques scale when they are used to express different types of architectural changes. This paper presents a first comparative evaluation of two significantly-different composition techniques for architectural descriptions. The first technique is fully based on heuristic composition operators, while the second one demands explicit composition specification. Several releases of a software product line were used in our evaluation, and their designs were expressed with an architectural description language, called ACME. Some metrics were used to compute the number of required modifications, syntactic conflicts, and semantic conflicts in composed (output) models produced with both heuristic and non-heuristic compositions. We observed that, in general, the heuristic composition approach outperformed the non-heuristic one mainly due to the narrow set of composition operators supported by the latter.
Various new modularization techniques, such as aspectoriented (AO) programming, are proposed to i... more Various new modularization techniques, such as aspectoriented (AO) programming, are proposed to improve software stability and modularity, and there is a pressing need to assess tradeoffs of modularization alternatives from highlevel design models instead of source code. We present the following contributions in this context: we first present a technique to automatically transform a UML component diagram into analytical decision models, the augmented constraint network (ACN) and design structure matrix (DSM). Second, we define and formalize a suite of design stability and modularity metrics, based on ACN and DSM modeling. These metrics improve prevailing metrics by taking environmental conditions and option reasoning into consideration. Finally, we evaluate our techniques using eight OO and AO releases of a software product line. We show that these metrics allow us to assess which technique generates a more stable, modular design, given a series of envisioned changes, verified by previous source code analysis.
Proceedings of the 8th ACM international conference on Aspect-oriented software development - AOSD '09, 2009
The lack of architecturally-significant mechanisms for aspectual composition might artificially h... more The lack of architecturally-significant mechanisms for aspectual composition might artificially hinder the specification of stable and reusable design aspects. Current aspect-oriented approaches at the architecture-level tend to mimic programming language join point models while overlooking mainstream architectural concepts such as styles and their semantics. Syntax-based pointcuts are typically used to select join points based on the names of architectural elements, exposing architecture descriptions to pointcut fragility and reusability problems. This paper presents style-based composition, a new flavor of aspect composition at the architectural level based on architectural styles. We propose stylebased join point models and provide a pointcut language that supports the selection of join points based on styleconstrained architectural models. Stability and reusability assessments of the proposed style-based composition model were carried out through three case studies involving different styles. The interplay of style-based pointcuts and some style composition techniques is also discussed.
Uploads
Papers by Alessandro Garcia