Aspect-oriented programming

Aspect-oriented programming
Name	Aspect-oriented programming
Abbreviation	AOP
Paradigms	Object-oriented programming, Procedural programming, Functional programming
First appeared	1997
Designers	Gregor Kiczales, Laurence Bergmans, Gérard Huet
Influenced by	Metaobject protocol, Software engineering, Modularity
Influenced	Middleware (computer science), Dependency injection, Model-driven engineering, Service-oriented architecture

Aspect-oriented programming is a programming paradigm that aims to increase modularity by separating cross-cutting concerns. It complements Object-oriented programming and Procedural programming by providing mechanisms to encapsulate behaviors that affect multiple parts of a program, enabling developers to express concerns such as logging, security, and transaction management separately from business logic. The approach has been discussed and advanced in academic and industrial settings involving institutions like University of British Columbia and companies such as IBM and BEA Systems.

Overview

Aspect-oriented programming decomposes software systems into distinct units that capture single concerns, enabling composition of primary modules with auxiliary behaviors. Core actors in AOP designs include pointcuts, advice, and join points, which interact with artifacts produced by compilers and run-time engines used by vendors like Oracle Corporation and projects from Apache Software Foundation. Toolchains for AOP intersect with languages and platforms supported by organizations including Sun Microsystems and Microsoft.

History and Evolution

Early academic work at institutions such as Xerox PARC and University of British Columbia contributed to foundational ideas, with key publications in conferences like ACM SIGPLAN and International Conference on Software Engineering. Researchers including Gregor Kiczales and teams at Mitsubishi Electric Research Laboratories advanced weaving techniques and the metaobject protocol lineage. Commercial evolution saw integration into middleware products from IBM and BEA Systems, and later into ecosystems managed by Eclipse Foundation and Apache Software Foundation.

Concepts and Terminology

AOP introduces terminology that builds on prior concepts from Metaobject protocol research and Compiler theory. A join point denotes a well-defined point in program execution traceable by debuggers from vendors like Red Hat and Canonical (company). Pointcuts specify sets of join points similar to query languages used in Oracle Corporation databases, while advice represents code snippets executed at matched join points, akin to hooks in systems developed by Microsoft. Weaving denotes the process of composing aspects with primary code either at compile time, load time, or run time, involving toolchains similar to those used by GNU Project and Intel Corporation.

Languages and Implementations

Several languages and extensions have implemented AOP features. Notable implementations include extensions for Java (programming language) through projects like AspectJ and frameworks integrated with Spring Framework and servers from JBoss (company). Language-level support or libraries have been developed for C#, with contributions from Microsoft Research, and for Python (programming language) via plugins and libraries in communities around Python Software Foundation. Other implementations and research prototypes emerged from groups at Massachusetts Institute of Technology, Stanford University, and companies like Nokia.

Use Cases and Examples

AOP is frequently applied to cross-cutting concerns such as logging in enterprise applications deployed on WebLogic Server, security enforcement in systems integrated with OAuth (protocol), transaction management in systems using Java Transaction API, and performance monitoring in environments running on Amazon Web Services. Example patterns include applying retry logic across service calls in microservices architectures influenced by Netflix, Inc. and centralized exception handling in applications developed by teams at Google.

Criticisms and Limitations

Critics from academic venues like ACM and industry practitioners at companies such as Microsoft have pointed to challenges including obscured control flow that complicates reasoning in codebases, impediments to standard tooling from organizations like GitHub and JetBrains, and difficulties in debugging with integrated development environments produced by Eclipse Foundation and IntelliJ IDEA. Concerns also include interaction complexity when multiple aspects apply to the same join point, echoing issues discussed in publications from IEEE.

Tooling and Adoption

Adoption of AOP has been uneven across ecosystems. Tooling support exists in IDEs from Eclipse Foundation and JetBrains and build systems such as Apache Maven and Gradle (software), while some large organizations like Amazon.com and Google have favored alternative approaches such as service decomposition and dependency injection promoted by Spring Framework. Open-source contributions from communities hosted by Apache Software Foundation and GitHub continue to maintain AOP libraries and integrations.

Related Paradigms and Influence

AOP has influenced and been influenced by paradigms and practices including Dependency injection, Model-driven engineering, Middleware (computer science), and Service-oriented architecture. Research intersections involve topics explored at venues like International Conference on Software Engineering and collaborations among institutions such as Carnegie Mellon University and ETH Zurich.

Category:Programming paradigms