Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
Programming heterogeneous transactions for software development environments
ICSE '93 Proceedings of the 15th international conference on Software Engineering
On the criteria to be used in decomposing systems into modules
Communications of the ACM
ACM Transactions on Software Engineering and Methodology (TOSEM)
The Java Language Specification
The Java Language Specification
A Metrics Suite for Object Oriented Design
IEEE Transactions on Software Engineering
Quantifying aspects in middleware platforms
Proceedings of the 2nd international conference on Aspect-oriented software development
ECOOP '01 Proceedings of the 15th European Conference on Object-Oriented Programming
AOP: Does It Make Sense? The Case of Concurrency and Failures
ECOOP '02 Proceedings of the 16th European Conference on Object-Oriented Programming
AspectJ in Action: Practical Aspect-Oriented Programming
AspectJ in Action: Practical Aspect-Oriented Programming
Software Engineering for Multi-Agent Systems II
Software Engineering for Multi-Agent Systems II
Automatic Detection and Masking of Nonatomic Exception Handling
IEEE Transactions on Software Engineering
Summarization of dynamic content in web collections
PKDD '04 Proceedings of the 8th European Conference on Principles and Practice of Knowledge Discovery in Databases
abc: an extensible AspectJ compiler
Proceedings of the 4th international conference on Aspect-oriented software development
Aspect-oriented programming and modular reasoning
Proceedings of the 27th international conference on Software engineering
Classpects: unifying aspect- and object-oriented language design
Proceedings of the 27th international conference on Software engineering
Information hiding interfaces for aspect-oriented design
Proceedings of the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium on Foundations of software engineering
A middleware-transparent approach to developing distributed applications: Research Articles
Software—Practice & Experience
Using Pointcut Delta Analysis to Support Evolution of Aspect-Oriented Software
ICSM '05 Proceedings of the 21st IEEE International Conference on Software Maintenance
Refactoring the Aspectizable Interfaces: An Empirical Assessment
IEEE Transactions on Software Engineering
Modular Software Design with Crosscutting Interfaces
IEEE Software
Composing design patterns: a scalability study of aspect-oriented programming
Proceedings of the 5th international conference on Aspect-oriented software development
Exceptions and side-effects in atomic blocks
Science of Computer Programming - Special issue: Concurrency and synchronization in Java programs
Adding Self-Healing Capabilities into Legacy Object Oriented Application
ICAS '06 Proceedings of the International Conference on Autonomic and Autonomous Systems
Exceptions and aspects: the devil is in the details
Proceedings of the 14th ACM SIGSOFT international symposium on Foundations of software engineering
Bridging Java and AspectJ through explicit join points
Proceedings of the 5th international symposium on Principles and practice of programming in Java
Towards reusable components with aspects: an empirical study on modularity and obliviousness
Proceedings of the 30th international conference on Software engineering
Open modules: modular reasoning about advice
ECOOP'05 Proceedings of the 19th European conference on Object-Oriented Programming
A trace semantics for long-running transactions
CSP'04 Proceedings of the 2004 international conference on Communicating Sequential Processes: the First 25 Years
On the impact of aspectual decompositions on design stability: an empirical study
ECOOP'07 Proceedings of the 21st European conference on Object-Oriented Programming
PicOS tuples: easing event based programming in tiny pervasive systems
Proceedings of the 7th International Workshop on Model-Based Methodologies for Pervasive and Embedded Software
Trading obliviousness for modularity with cooperative aspect-oriented programming
ACM Transactions on Software Engineering and Methodology (TOSEM) - In memoriam, fault detection and localization, formal methods, modeling and design
Hi-index | 0.00 |
Aspect-oriented programming (AOP) seeks to improve software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where programmers write the main application (base code), ignoring cross-cutting concerns, and then aspect programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. This purely oblivious strategy, however, has empirically been shown to tightly couple aspects to base code in many cases, hindering aspect modularity and reuse. In essence, the more intricate the weaving between the cross-cutting concern and the base code (lexically and/or semantically), the harder it becomes to: (a) robustly specify how to weave the aspects in at the required points, (b) capture interactions between aspects and base code, and (c) preserve the correct weaving as the base code evolves. We propose an alternate methodology, termed cooperative aspect-oriented programming (Co-AOP), where complete lexical separation of concerns is not taken as an absolute requirement. Instead, cross-cutting concerns are explicitly modeled as abstract interfaces through explicit join points (EJPs). Programmers specify where these interfaces interact with base code either through explicit lexical references or via traditional oblivious aspects. This explicit awareness allows base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase, and bring us towards a cooperative AOP paradigm. We illustrate our methodology via an example on transactions, and also give an initial evaluation of cooperative AOP through an empirical study on program extensibility comparing both the traditional and cooperative AOP methodologies. Initial results show that cooperative AOP techniques result in code that is less complex with lower overall coupling, facilitating extensibility.