In this document, a controlled experiment on aspect-oriented programming that was performed in the context of my bachelor thesis is described and evaluated. The experiment was designed to make the overall performance of software developers using object-orientation and aspect-orientation on a number of tasks comparable. The primary focus of the experiment laid on whether aspect-orientation has a positive impact on the development time when comparing its performance with the performance of the object-oriented approach on the same task.
Table of Contents
1. Introduction
2. Motivation and Problem Description
3. Experiment Background
3.1. A short summary on Empiricism and Experimentation
3.1.1. What is meant by Empiricism?
3.1.2. Research and Experimentation methods
3.1.2.1. Case Studies or Benchmarks
3.1.2.2. Field Studies
3.1.2.3. Controlled Experiments
3.1.2.4. Polls
3.1.2.5. Meta-Studies
3.1.3. Empirical research in Software Engineering – Specifics and Dangers
3.2. Aspect-Oriented Programming
3.2.1. Aspect-Orientation in General
3.2.2. AspectJ – a short Introduction
4. The Experiment
4.1. Experiment Buildup
4.1.1. The planned Course of the Experiment
4.1.2. The Questionnaire
4.1.3. The Hard- and Software used in the Experiment
4.1.3.1. The Application used for Editing
4.1.3.2. The Development Environment and Hardware
4.1.4. The Tasks
4.1.4.1. Task1: The Logging Task
4.1.4.2. Task2: The Parameter Null Task
4.1.4.3. Task3: The Synchronization Task
4.1.4.4. Task4: The Check Player Argument Task
4.1.4.5. Task5: The Notify Observers Task
4.1.4.6. Task6: The Observers Null Check Task
4.1.4.7. Task7: The Refresh Constraint Task
4.1.4.8. Task8: The Label Value Check Task
4.1.4.9. Task9: The Current Level Check Task
4.2. Implementation of the Experiment
5. Experiment Analysis and Results
5.1. Data Processing and Preparation
5.2. Data analysis and presentation
5.2.1. The Logging Task
5.2.2. The Parameter Null Task
5.2.3. The Synchronization Task
5.2.4. The Player Check Task
5.2.5. The Notify Observers Task
5.2.6. The Observers Null Task
5.2.7. The Refresh Constraint Task
5.2.8. The Label Value Check Task
5.2.9. The Level Check Task
5.2.10. Results of the Development Times and Descriptive Statistics
5.2.11. Statistical Tests on the Results
5.2.12. Doing a Break-Even Analysis
5.2.13. Participant Grouping
6. Discussion
6.1. Thoughts on Validity
6.1.1. Internal Validity
6.1.2. External Validity
6.2. General Discussion
7. Related Work
8. Conclusion
9. Appendix
9.1. The questionnaire
9.2. The aspect-oriented task descriptions
9.3. The object-oriented task descriptions
10. References
Research Objectives and Key Topics
This bachelor thesis conducts a controlled experiment to evaluate whether aspect-oriented programming (AOP) using AspectJ significantly reduces software development time compared to traditional object-oriented (OO) programming in Java, specifically when dealing with redundant code and crosscutting concerns.
- Empirical evaluation of development time for redundant code tasks.
- Comparison between standard object-oriented Java and aspect-oriented AspectJ.
- Break-even analysis to determine the efficiency threshold of AOP.
- Impact of participant experience and skill levels on development performance.
- Analysis of code modularization and complexity trade-offs in AOP.
Excerpt from the Book
4.1.4.1. Task1: The Logging Task
The first (and also the largest) task of the study was to add a logging-feature to the application, where each method (but no constructors) had to be supplemented with a call to the logger at the beginning of the method. For this, a corresponding logger-interface was provided which expected the name of the class where the method was declared in, the method name, the return type, an array of its actual parameter instances and an array of type String with the formal parameter names.
The consumed time by this task consists of the time for navigating to the right position in the code and writing the corresponding piece of code. Typically, developers do this via copy and paste, where they copy a previous logger-call and then copy the corresponding data into it. The object-oriented solution to this task was a very repetitive procedure, as the log statement had to be written or copied and modified for every method, making up 110 statements to create altogether.
Summary of Chapters
1. Introduction: Outlines the premise that development time is a critical factor and introduces the experiment aimed at comparing OO and AOP approaches.
2. Motivation and Problem Description: Argues for the necessity of empirical research in software engineering to validate assumptions about programming paradigms.
3. Experiment Background: Provides theoretical context on empirical research methods and introduces basic concepts of Aspect-Oriented Programming and AspectJ.
4. The Experiment: Details the experimental setup, including the target labyrinth game application, the nine programming tasks, and the participant environment.
5. Experiment Analysis and Results: Presents the raw data and statistical analysis, including regression models, break-even analysis, and participant groupings.
6. Discussion: Evaluates the validity of the results, discussing threats to internal and external validity and the general implications of the study.
7. Related Work: Summarizes previous empirical studies on AOP, exception handling, and middleware to place this work within existing literature.
8. Conclusion: Summarizes findings, noting that AOP may be beneficial for larger, redundant tasks while potentially adding overhead for smaller, simpler ones.
Keywords
Aspect-Oriented Programming, AOP, AspectJ, Software Development Time, Empirical Software Engineering, Controlled Experiment, Code Redundancy, Crosscutting Concerns, Java, Object-Oriented Programming, Performance Measurement, Software Metrics, Break-even Analysis, Developer Productivity, Empirical Study
Frequently Asked Questions
What is the core purpose of this study?
The study aims to measure and compare the impact of aspect-oriented programming (AspectJ) versus object-oriented programming (Java) on development time when implementing redundant code features.
What are the primary themes investigated?
The themes include the efficacy of AOP in handling crosscutting concerns, the measurement of developer productivity through empirical experiments, and the determination of when AOP becomes more efficient than standard OO practices.
What is the main research question?
The research seeks to identify if aspect-orientation provides a measurable advantage in development time for redundant tasks and whether a break-even point exists based on task complexity.
Which methodology was applied?
A controlled experiment was conducted where 20 participants performed nine tasks using both object-oriented and aspect-oriented approaches, with progress logged and statistically analyzed.
What does the main body cover?
It describes the experiment buildup, detailed task descriptions (like logging, null checks, synchronization), data processing methods, and comprehensive statistical test results.
What are the essential keywords?
The work is characterized by terms like AOP, AspectJ, Code Redundancy, Empirical Research, Software Development, and Break-even Analysis.
Does AOP significantly save time?
The study indicates that for small, simple tasks, AOP often incurs higher development time, while for larger tasks involving substantial redundant code, it may offer performance advantages.
Why are there statistical tables for specific tasks?
These tables display regression equations and coefficients of determination (R²) to demonstrate the correlation between time spent and the progress (number of successes) of participants.
What is the "break-even analysis" in this context?
It represents the calculated point at which the initial investment of learning and implementing an aspect equals the time saved by replacing redundant code.
- Arbeit zitieren
- Sebastian Kleinschmager (Autor:in), 2009, A Controlled Experiment for Measuring the Impact of Aspect-Oriented Programming on Software Development Time, München, GRIN Verlag, https://www.hausarbeiten.de/document/199337
