Revealing Mistakes in Concern Mapping Tasks: An Experimental Evaluation

Nunes, Camila; Garcia, Alessandro; Figueiredo, Eduardo; Lucena, Carlos José Pereira de

doi:10.1109/csmr.2011.16

Cited by 7 publications

(11 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In the former case, programmers fail to assign code elements to the concern that should actually be later refactored. Nunes et al [25] highlighted that the inability to identify the concern code is one of the most problematic steps for concern refactoring. We empirically confirm their results.…”

Section: Resultsmentioning

confidence: 99%

“…The synergy between these two mistakes and dedicated implementation elements could be due to the concern mapping task, i.e., the developer fails to assign dedicated elements to a concern. In fact, Nunes et al [25] have pointed out that not assigning a dedicated implementation element to a concern is a common mistake when developers perform concern mapping. Therefore, it is not a surprise that developers make the same mistake when refactoring a crosscutting concern to aspects.…”

Section: Dedicated Implementation Elementsmentioning

confidence: 99%

“…Such false negatives may lead to mistakes like Incomplete Refactoring or even Incorrect Implementation Logic herein described. Nunes et al [25] characterized a set of recurring concern mapping mistakes made by software developers. Amongst the causes that led to mistakes in the mapping tasks, Nunes et al highlight the crosscutting nature -i.e., spreading or tangling -of several concerns they analyzed.…”

Section: Related Workmentioning

confidence: 99%

“…Investigations of concern identification and code smells: Recent studies [12,25] investigated mistakes in the projection of concerns on code -a key task in concern refactoring. For instance, Figueiredo et al [12] noticed that programmers are conservative when projecting concerns, i.e.…”

Section: Related Workmentioning

confidence: 99%

See 3 more Smart Citations

Avoiding Code Pitfalls in Aspect-Oriented Programming

Alves

Figueiredo

Ferrari

2014

Programming Languages

Self Cite

View full text Add to dashboard Cite

Abstract. Aspect-Oriented Programming (AOP) is a maturing technique that requires a good comprehension of which types of mistakes programmers make during the development of applications. Unfortunately, the lack of such knowledge seems to represent one of the reasons for the cautious adoption of AOP in real software development projects. Based on a series of experiments, this paper reports a catalogue of code pitfalls that are likely to lead programmers to make mistakes in AOP. Each experiment required the aspectization (i.e. refactoring) of a crosscutting concern in one object-oriented application. Six rounds of the experiment provided us with the data of 80 aspect-oriented (AO) implementations where three crosscutting concerns were aspectized in three applications. We developed a prototype tool to warn programmers of the code pitfalls during refactoring activities.

show abstract

Section: Resultsmentioning

confidence: 99%

Section: Dedicated Implementation Elementsmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Avoiding Code Pitfalls in Aspect-Oriented Programming

Alves

Figueiredo

Ferrari

2014

Programming Languages

Self Cite

View full text Add to dashboard Cite

show abstract

“…Therefore, they represent real world comprehension scenarios. We also considered these tasks because they may lead to potential mistakes performed by developers during the feature comprehension tasks [32]. Additionally, these tasks were selected based on their different levels of difficulty.…”

Section: Task Designmentioning

confidence: 99%

On the proactive and interactive visualization for feature evolution comprehension: An industrial investigation

Novais

Nunes

Lima

et al. 2012

2012 34th International Conference on Software Engineering (ICSE)

Self Cite

View full text Add to dashboard Cite

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.

show abstract

Heuristic expansion of feature mappings in evolving program families

et al. 2013

Self Cite

View full text Add to dashboard Cite

SUMMARYEstablishing 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.

show abstract

Revealing Mistakes in Concern Mapping Tasks: An Experimental Evaluation

Cited by 7 publications

References 30 publications

Avoiding Code Pitfalls in Aspect-Oriented Programming

Avoiding Code Pitfalls in Aspect-Oriented Programming

On the proactive and interactive visualization for feature evolution comprehension: An industrial investigation

Heuristic expansion of feature mappings in evolving program families

Contact Info

Product

Resources

About