Does aspect-oriented programming increase the development speed for crosscutting code? An empirical study

Hanenberg, Stefan; Kleinschmager, Sebastian; Josupeit-Walter, Manuel

doi:10.1109/esem.2009.5316028

Cited by 37 publications

(24 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In software-engineering experiments, program comprehension is frequently measured, for example, for the evaluation of programming-language constructs or software-development tools [3,9,18,22,35]. Program comprehension is an internal cognitive process that we cannot observe directly.…”

Section: Introductionmentioning

confidence: 99%

Measuring and modeling programming experience

et al. 2013

Self Cite

View full text Add to dashboard Cite

Programming experience is an important confounding parameter in controlled experiments regarding program comprehension. In literature, ways to measure or control programming experience vary. Often, researchers neglect it or do not specify how they controlled for it. We set out to find a well-defined understanding of programming experience and a way to measure it. From published comprehension experiments, we extracted questions that assess programming experience. In a controlled experiment, we compare the answers of computer-science students to these questions with their performance in solving program-comprehension tasks. We found that self estimation seems to be a reliable way to measure programming experience. Furthermore, we applied exploratory and confirmatory factor analyses to extract and evaluate a model of programming experience. With our analysis, we initiate a path toward validly and reliably measuring and describing programming experience to better understand and control its influence in program-comprehension experiments.

show abstract

Section: Introductionmentioning

confidence: 99%

Measuring and modeling programming experience

et al. 2013

Self Cite

View full text Add to dashboard Cite

show abstract

“…The average completion time for their AO group was 31% longer than for the OO group, while in our experiment, this difference amounts to 29%. Hanenberg et al (2009) found that the overall development time for cross-cutting concerns using Java was shorter than the development time for such concerns using AspectJ. Nevertheless, for two tasks (logging and null-pointer-checks) subjects using AspectJ performed better.…”

Section: Experiments To Evaluate Maintainability Of Ao Software With mentioning

confidence: 89%

“…In addition, Hanenberg and Unland (2001) and Lopez-Herrejon et al (2006) found that step-wise development is not satisfactorily supported by AspectJ. In particular, concrete aspects cannot be extended, while advices and concrete pointcuts cannot be overridden.…”

Section: Motivationsmentioning

confidence: 99%

See 1 more Smart Citation

An empirical study on the impact of AspectJ on software evolvability

Przybyłek

2017

Empir Software Eng

View full text Add to dashboard Cite

Since its inception in 1996, aspect-oriented programming (AOP) has been believed to reduce the effort required to maintain software systems by replacing cross-cutting code with aspects. However, little convincing empirical evidence exists to support this claim, while several studies suggest that AOP brings new obstacles to maintainability. This paper discusses two controlled experiments conducted to evaluate the impact of AspectJ (the most mature and popular aspect-oriented programming language) versus Java on software evolvability. We consider evolvability as the ease with which a software system can be updated to fulfill new requirements. Since a minor language was compared to the mainstream, the experiments were designed so as to anticipate that the participants were much more experienced in one of the treatments. The first experiment was performed on 35 student subjects who were asked to comprehend either Java or AspectJ implementation of the same system, and perform the corresponding comprehension tasks. Participants of both groups achieved a high rate of correct answers without a statistically significant difference between the groups. Nevertheless, the Java group significantly outperformed the AspectJ group with respect to the average completion time. In the second experiment, 24 student subjects were asked to implement (in a noninvasive way) two extension scenarios to the system that they had already known. Each subject evolved either the Java version using Java or the AspectJ version using AspectJ. We found out that a typical AspectJ programmer needs significantly fewer atomic changes to implement the change scenarios than a typical Java programmer, but we did not observe a significant difference in completion time. The overall result indicates that AspectJ has a different effect on two sub-characteristics of the evolvability: understandability and changeability. While AspectJ decreases the former, it improves one aspect of the latter.Empir Software Eng

show abstract

“…Such functional enhancements in any module of the OS that affect large fractions of the program code, are often called crosscutting concerns. These crosscutting concerns can be handled by the new emerging extension to object oriented paradigm that is Aspect Oriented Programming (AOP) [1]. AOP deals with separation of concern in software development.…”

Section: Introductionmentioning

confidence: 99%

An Aspect Oriented Approach to Introduce Aspects in the Operating System

Arora¹,

Kaur²

2015

IJCA

View full text Add to dashboard Cite

Software systems are very inflexible towards modification of already existing functionalities such as security, dynamic reconfigurability, robustness etc. In such functionalities if need arises for any enhancements then it affects large fractions of the code. Thus results in difficult to implement. Such functional enhancements in any component of the system that affect large fractions of the program code, are often called crosscutting concerns. Such cross-cutting concerns can be solved by the new emerging extension to object oriented paradigm i.e. Aspect Oriented Programming (AOP). The main idea in AOP is the programmer's ability to affect the execution of core code by writing aspects. Aspects are pieces of code that are run before, or after core function for which aspect is written. The quantification part means that programmer can define points in the main program. Aspects should affect the main program by using some definition language that is usually a declarative one. The obliviousness means that the affected code does not need to know anything about aspects.

show abstract

Does aspect-oriented programming increase the development speed for crosscutting code? An empirical study

Abstract: Abstract

Cited by 37 publications

References 19 publications

Measuring and modeling programming experience

Measuring and modeling programming experience

An empirical study on the impact of AspectJ on software evolvability

An Aspect Oriented Approach to Introduce Aspects in the Operating System

Contact Info

Product

Resources

About