Alessandro Garcia

Federal University of Rio de Janeiro, Rio de Janeiro, Rio de Janeiro, Brazil

Are you Alessandro Garcia?

Claim your profile

Publications (150)12.77 Total impact

  • [Show abstract] [Hide abstract]
    ABSTRACT: As software systems are maintained, their architecture often de-grades through the processes of architectural drift and erosion. These processes are often intertwined and the same modules in the code become the locus of both drift and erosion symptoms. Thus, architects should elaborate architecture rules for detecting occur-rences of both degradation symptoms. While the specification of such rules is time-consuming, they are similar across software projects adhering to similar architecture decompositions. Unfortu-nately, existing anti-degradation techniques are limited as they focus only on detecting either drift or erosion symptoms. They also do not support the reuse of recurring anti-degradation rules. In this context, the contribution of this paper is twofold. First, it presents TamDera, a domain-specific language for: (i) specifying rule-based strategies to detect both erosion and drift symptoms, and (ii) promoting the hierarchical and compositional reuse of design rules across multiple projects. The language was designed with usual concepts from programming languages in mind such as, inheritance and modularization. Second, we evaluated to what extent developers would benefit from the definition and reuse of hybrid rules. Our study involved 21 versions pertaining to 5 software projects, and more than 600 rules. On average 45% of classes that had drift symptoms in first versions presented inter-related erosion problems in latter versions or vice-versa. Also, up to 72% of all the TamDera rules in a project are from a pre-defined library of reusable rules. They were responsible for detecting on average of 73% of the inter-related degradation symptoms across the projects.
    Proceedings of the 13th international conference on Modularity; 04/2014
  • Source
    Kleinner Farias, Alessandro Garcia, Jon Whittle
    [Show abstract] [Hide abstract]
    ABSTRACT: Model composition is a common operation used in many software development activities---for example, reconciling models developed in parallel by different development teams, or merging models of new features with existing model artifacts. Unfortunately, both commercial and academic model composition tools suffer from the composition conflict problem. That is, models to-be-composed may conflict with each other and these conflicts must be resolved. In practice, detecting and resolving conflicts is a highly-intensive manual activity. In this paper, we investigate whether aspect-orientation reduces conflict resolution effort as improved modularization may better localize conflicts. The main goal of the paper is to conduct an exploratory study to analyze the impact of aspects on conflict resolution. In particular, model compositions are used to express the evolution of architectural models along six releases of a software product line. Well-known composition algorithms, such as override, merge and union, are applied and compared on both AO and non-AO models in terms of their conflict rate and effort to solve the identified conflicts. Our findings identify specific scenarios where aspect-orientation properties, such as obliviousness and quantification, result in a lower (or higher) composition effort.
  • [Show abstract] [Hide abstract]
    ABSTRACT: This paper proposes an initial quality model for model composition effort, which serves as a frame of reference to developers and researchers to plan and perform qualitative and quantitative investigations, as well as replicate and reproduce empirical studies. A series of empirical studies supports the proposed quality model, including five industrial case studies, two controlled experiments, three quasi-experiments, interviews and seven observational studies. Moreover, these studies have systematically demonstrated the real benefits of using a frame of reference to enable learning about model composition effort from experimentation.
    SAC '14 Proceedings of the 29th Annual ACM Symposium on Applied Computing; 03/2014
  • Software and Systems Modeling 01/2014; · 1.25 Impact Factor
  • Camila Nunes, Alessandro Garcia, Carlos Lucena, Jaejoon Lee
    [Show abstract] [Hide abstract]
    ABSTRACT: 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.
    Software Practice and Experience 05/2013; · 1.01 Impact Factor
  • Alessandro Garcia
    Journal of Systems and Software 04/2013; 86(4):869–871. · 1.14 Impact Factor
  • [Show abstract] [Hide abstract]
    ABSTRACT: A considerable part of software design is dedicated for the composition of two or more modules. The implication is that changes made later in the implementation often require some reasoning about module composition properties. However, these properties are often not explicitly specified in design artefacts. Moreover, they cannot be easily inferred from the source code either. As a result, implicit composition properties may represent a major source of software maintenance complexity. This fact is particularly true with the advent of post object-oriented techniques, which are increasingly providing advanced mechanisms to enable flexible module composition. However, there is little empirical knowledge on how design models with explicitly-specified composition properties can improve software maintenance tasks. This paper reports an experiment that analyses the impact of design models enriched with composition properties on system maintenance. Explicit composition modelling was achieved in the experiment through a conservative approach, i.e., a specific set of additional UML stereotypes dedicated to model composition properties. The experiment involved 28 participants, who were asked to realize four maintenance tasks using UML design models with different levels of module composition details. Our findings suggested that explicit composition modelling contributed to better results in the realization of program change tasks, regardless of the developers' expertise. Users of composition-enhanced models consistently yielded better results when compared to users of plain UML models. The use of explicit composition specification also led to an average increase of 44.7% in the quality of changes produced by the participants
    Proceedings of the 12th annual international conference on Aspect-oriented software development; 03/2013
  • [Show abstract] [Hide abstract]
    ABSTRACT: Checking a software's structural dependencies is a line of research on methods and tools for analyzing, modeling and checking the conformance of source code w.r.t. specifications of its intended static structure. Existing approaches have focused on the correctness of the specification, the impact of the approaches on software quality and the expressiveness of the modeling languages. However, large specifications become unmaintainable in the event of evolution without the means to modularize such specifications. We present Vespucci, a novel approach and tool that partitions a specification of the expected and allowed dependencies into a set of cohesive slices. This facilitates modular reasoning and helps individual maintenance of each slice. Our approach is suited for modeling high-level as well as detailed low-level decisions related to the static structure and combines both in a single modeling formalism. To evaluate our approach we conducted an extensive study spanning nine years of the evolution of the architecture of the object-relational mapping framework Hibernate.
    Proceedings of the 12th annual international conference on Aspect-oriented software development; 03/2013
  • [Show abstract] [Hide abstract]
    ABSTRACT: When reflecting upon driving system requirements such as security and availability, software architects often face decisions that have a broadly scoped impact on the software architecture. These decisions are the core of the architecting process because they typically have implications intertwined in a multitude of architectural elements and across multiple views. Without a modular representation and management of those crucial choices, architects cannot properly communicate, assess and reason about their crosscutting effects. The result is a number of architectural breakdowns, such as misinformed architectural evaluation, time‐consuming trade‐off analysis and unmanageable traceability. This paper presents an architectural documentation approach in which aspects are exploited as a natural way to capture widely‐scoped design decisions in a modular fashion. The approach consists of a simple high‐level notation to describe crosscutting decisions, and a supplementary language that allows architects to formally define how such architectural decisions affect the final architectural decomposition according to different views. On the basis of two case studies, we have systematically assessed to what extent our approach: (i) supports the description of heterogeneous forms of crosscutting architecture decisions, (ii) improves the support for architecture modularity analysis, and (iii) enhances upstream and downstream traceability of crosscutting architectural decisions. Copyright © 2012 John Wiley & Sons, Ltd.
    Software Practice and Experience 01/2013; 43(3). · 1.01 Impact Factor
  • [Show abstract] [Hide abstract]
    ABSTRACT: The lack of empirical knowledge about the effects of model composition techniques on developers' effort is the key impairment for their widespread adoption in practice. This problem applies to both existing categories of model composition techniques, i.e. specification-based (e.g. Epsilon) and heuristic-based (e.g. IBM RSA) techniques. This paper reports on a controlled experiment that investigates the effort to: (1) apply both categories of model composition techniques, and (2) detect and resolve inconsistencies in the output composed models. The techniques are investigated in 144 evolution scenarios, where 2304 compositions of elements of class diagrams were produced. The results suggest that: (1) the employed heuristic-based techniques require less effort to produce the intended model than the chosen specification-based technique, (2) the correctness of the output composed models generated by the techniques is not significantly different, and (3) the use of manual heuristics for model composition outperforms their automated counterparts.
    Proceedings of the 15th international conference on Model Driven Engineering Languages and Systems; 09/2012
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Cohesion has been avidly recognized as a key property of software modularity. Ideally, a software module is considered to be cohesive if it represents an abstraction of a single concern of the software. Modules with several concerns may be harder to understand because developers must mentally separate the source code related to each concern. Also, modules implementing several concerns are more likely to undergo changes as much as distinct development tasks may target its different concerns. The most well-known cohesion metrics are defined in terms of the syntactical structure of a module, and as a consequence fail to capture the amount of concerns realized by the module. In this context, we investigated the potential of a new metric, called Lack of Concern-based Cohesion. This metric explicitly counts the number of concerns realized by each module. We compared this metric with other five structural cohesion metrics by applying them over six open source software systems. We studied how those metrics are associated with module changes by mining over 16,000 repository revisions. Our results pointed out that the concern-based metric captured a cohesion dimension that is not reflected by structural metrics, and, as a consequence, adds to the association of cohesion and change-proneness.
    20th IEEE International Conference on Program Comprehension; 06/2012
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: As software systems are maintained, their architecture modularity often degrades through architectural erosion and drift. More directly, however, the modularity of software implementations degrades through the introduction of code anomalies, informally known as code smells. A number of strategies have been developed for supporting the automatic identification of implementation anomalies when only the source code is available. However, it is still unknown how reliable these strategies are when revealing code anomalies related to erosion and drift processes. In this paper, we present an exploratory analysis that investigates to what extent the automatically-detected code anomalies are related to problems that occur with an evolving system's architecture. We analyzed code anomaly occurrences in 38 versions of 5 applications using existing detection strategies. The outcome of our evaluation suggests that many of the code anomalies detected by the employed strategies were not related to architectural problems. Even worse, over 50% of the anomalies not observed by the employed techniques (false negatives) were found to be correlated with architectural problems.
    03/2012;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Maintainability has become one of the most essential attributes of software quality, as software maintenance has shown to be one of the most costly and time-consuming tasks of software development. Many studies reveal that maintainability is not often a major consideration in requirements and design stages and that software maintenance costs may be reduced by a more controlled design early in the software life cycle. Several factors have been identified as harmful for software maintainability, such as lack of upfront consideration of proper modularity choices. In that sense, the presence of crosscutting concerns is one of these factors that possibly exert negative effects on software maintainability. However, to date there is little or no knowledge about how characteristics of crosscutting concerns, observable in early artifacts, are correlated with maintainability. This paper introduces an empirical analysis about the correlation between crosscutting properties and two ISO/IEC 9126 maintainability attributes, namely changeability and stability. This correlation is based on the utilization of a set of concern metrics that allows the quantification of crosscutting, scattering and tangling in early development stages. The correlation provides evidence that the presence of certain crosscutting properties negatively affects changeability and stability. Our study confirms that a change in a crosscutting concern is more difficult to be accomplished and that artifacts addressing crosscutting concerns are found to be less stable later as the system evolves. Moreover, our empirical analysis reveals that crosscutting properties introduce non-syntactic dependencies between software artifacts which cannot be easily detected without the use of concern metrics. The whole analysis is performed on software product lines, where maintainability properties are of upmost importance not only for individual products but also for the core architecture of the product line.
    Information & Software Technology. 01/2012; 54:212-238.
  • [Show abstract] [Hide abstract]
    ABSTRACT: A considerable part of software systems is comprised of functions that support the main modules, such as array or string manipulation and basic math computation. These auxiliary functions are usually considered less complex, and thus tend to receive less attention from developers. However, failures in these functions might propagate to more critical modules, thereby affecting the system's overall reliability. Given the complementary role of auxiliary functions, a question that arises is whether agile practices, such as pair programming and test-first programming, can improve their correctness without affecting time-to-market. This paper presents an empirical assessment comparing the application of these agile practices with more traditional approaches. Our study comprises independent experiments of pair versus solo programming, and test-first versus test-last programming. The first study involved 85 novice programmers who applied both traditional and agile approaches in the development of six auxiliary functions within three different domains. Our results suggest that the agile practices might bring benefits in this context. In particular, pair programmers delivered correct implementations much more often, and test-first programming encouraged the production of larger and higher coverage test sets. On the downside, the main experiment showed that both practices significantly increase total development time. A replication of the test-first experiment with professional developers shows similar results.
    Proceedings - International Conference on Software Engineering 01/2012;
  • Source
    Camila Nunes, Alessandro Garcia, Carlos Lucena, Jaejoon Lee
    [Show abstract] [Hide abstract]
    ABSTRACT: 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%.
    01/2012;
  • Source
    Kleinner Farias, Alessandro Garcia, Carlos Lucena
    [Show abstract] [Hide abstract]
    ABSTRACT: Design models represent modular realizations of stakeholders' concerns and communicate the design decisions to be implemented by developers. Unfortunately, they often suffer from inconsistency problems. Aspect-oriented modeling (AOM) aims at promoting better modularity. However, there is no empirical knowledge about its impact on the inconsistency detection effort. To address this gap, this work investigates the effects of AOM on: (1) the developers' effort to detect inconsistencies; (2) the inconsistency detection rate; and (3) the interpretation of design models in the presence of inconsistencies. A controlled experiment was conducted with 26 subjects and involved the analysis of 520 models. The results, supported by statistical tests, show that the effort of detecting inconsistencies is 20 percent lower in AO models than in their OO counterparts. On the other hand, the inconsistency detection rate and the number of misinterpretations are 43 and 37 percent higher in AO models than in OO models, respectively.
    01/2012: pages 219-234; , ISBN: 9783642336652
  • Eiji Adachi Barbosa, Alessandro Garcia, Mira Mezini
    [Show abstract] [Hide abstract]
    ABSTRACT: Even though exception handling mechanisms are part of most mainstream programming languages, software developers still struggle to implement proper exception handling code. In particular, they fail in implementing effective handler actions. This position paper discusses our ongoing work on implementing and assessing a recommendation system for recommending code fragments implementing exception handling code. These fragments are not meant to be reused asis. Instead, they are meant to be used by the developers as examples of how to possibly handle their exceptions. The goal of the proposed recommendation system is to assist the learning process of software developers by providing concrete examples of exception handling code.
    01/2012;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Program comprehension is a key activity through maintenance and evolution of large-scale software systems. The understanding of a program often requires the evolution analysis of individual functionalities, so-called features. The comprehension of evolving features is not trivial as their implementations are often tangled and scattered through many modules. Even worse, existing techniques are limited in providing developers with direct means for visualizing the evolution of features' code. This work presents a proactive and interactive visualization strategy to enable feature evolution analysis. It proactively identifies code elements of evolving features and provides multiple views to present their structure under different perspectives. The novel visualization strategy was compared to a lightweight visualization strategy based on a tree-structure. We ran a controlled experiment with industry developers, who performed feature evolution comprehension tasks on an industrial-strength software. The results showed that the use of the proposed strategy presented significant gains in terms of correctness and execution time for feature evolution comprehension tasks.
    Proceedings - International Conference on Software Engineering 01/2012;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Empirical studies have stressed that aspect-oriented decompositions can cause non-obvious flaws in the modularity of certain design concerns. Without proper design evaluation mechanisms, the identification of these flaws can become counter-productive and impractical. Nowadays, modularity assessment is mostly supported by metric-based heuristics rooted at conventional attributes, such as module cohesion and coupling. However, such conventional module-driven assessment cannot be tailored to the design concerns. This paper proposes and systematically evaluates a representative suite of concern-sensitive heuristic rules. The accuracy of the heuristics is assessed through their application to six systems. The analysis was based on the heuristics support for: (i) addressing the shortcomings of conventional metrics-based assessments, (ii) reducing the manifestation of false positives and false negatives, and (iii) finding the presence of design flaws relative to both classes and aspects.
    Journal of Systems and Software. 01/2012; 85:227-243.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Software architecture degradation is a longstanding problem in software engineering. Previous studies have shown that certain code anomalies - or patterns of code anomalies - are likely to be harmful to architecture design, although their identification is far from trivial. This study presents a system for not only detecting architecturally-relevant code anomalies, but also helping developers to prioritize their removal by ranking them. We detect code anomaly patterns based on static analysis that also exploit architecture information.
    01/2012;

Publication Stats

1k Citations
12.77 Total Impact Points

Institutions

  • 2009–2013
    • Federal University of Rio de Janeiro
      Rio de Janeiro, Rio de Janeiro, Brazil
    • University of Malaga
      • Departamento de Lenguajes y Ciencias de la Computación
      Málaga, Andalusia, Spain
  • 2012
    • University of Southern California
      Los Angeles, California, United States
  • 2010–2012
    • Tecgraf / PUC-Rio
      Rio de Janeiro, Rio de Janeiro, Brazil
  • 2011
    • University of Campinas
      • Instituto de Computação (IC)
      Campinas, Estado de Sao Paulo, Brazil
  • 2002–2010
    • Pontifícia Universidade Católica do Rio de Janeiro
      • Department of Informatics (INF)
      Rio de Janeiro, Rio de Janeiro, Brazil
  • 2007
    • Federal University of Pernambuco
      • Center of Informatics (CIn)
      Recife, Estado de Pernambuco, Brazil
  • 1970–2007
    • Lancaster University
      • School of Computing and Communications
      Lancaster, England, United Kingdom