Experimentation in software engineering
IEEE Transactions on Software Engineering
Design and analysis in software engineering: the language of case studies and formal experiments
ACM SIGSOFT Software Engineering Notes
Process patterns: building large-scale systems using object technology
Process patterns: building large-scale systems using object technology
The unified software development process
The unified software development process
IEEE Transactions on Software Engineering
Aspect-oriented programming: Introduction
Communications of the ACM
Communications of the ACM
Does aspect-oriented programming work?
Communications of the ACM
Implementing distribution and persistence aspects with aspectJ
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
| Hi-index | 0.00 |
Object-oriented programming languages provide effective means to achieve better reuse and extensibility levels, which increases development productivity. However, the object-oriented paradigm has several limitations, sometimes leading to tangled code and spread code. For example, business code tangled with presentation code or data access code, and distribution, concurrency control, and exception handling code spread over several classes. This decreases readability, and therefore, system maintainability. Some extensions of the object-oriented paradigm try to correct those limitations allowing reuse and maintenance in practical situations where the original paradigm does not offer an adequate support. However, in order to guarantee that those benefits will be achieved by those techniques it is necessary to use them together with an implementation method. Our objective is to adapt and to analyze an object-oriented implementation method to use aspect-oriented programming in order to implement several concerns to a family of object-oriented system. In particular, we are interested in implementing persistence, distribution, and concurrency control aspects. At the moment we are particularly interested to present some results and get feed back about a performed experiment to identify if and when a progressive approach is better than a non-progressive one. In a progressive approach, persistence, distribution, and concurrency control are not initially considered in the implementation activities, but are gradually introduced, preserving the application's functional requirements. This approach helps in dealing with the inherent complexity of the modern applications, through the support to gradual implementations and tests of the intermediate versions of the application.