Aspect-oriented programming: Difference between revisions

Revision as of 00:43, 17 January 2020

Latest revision as of 03:52, 10 August 2025

(66 intermediate revisions by 48 users not shown)

Line 1:

{{Short description|Programming paradigmsparadigm}}

{{Use dmy dates|date=June 2023}}

In [[computing]], '''aspect-oriented programming''' ('''AOP''') is a [[programming paradigm]] that aims to increase [[Modularity (programming)|modularity]] by allowing the [[separation of concerns|separation of]] [[cross-cutting concern]]s. It does so by adding additional behavior to existing code (an [[Advice (programming)|advice]]) ''without'' modifying the code itself, instead separately specifying which code is modified via a "[[pointcut]]" specification, such as "log all function calls when the function's name begins with 'set{{'"}}. This allows behaviors that are not central to the [[business logic]] (such as logging) to be added to a program without cluttering the code, of core to the functionality. AOP forms a basis for [[aspect-oriented software development]]functions.

AOP includes programming methods and tools that support the modularization of concerns at the level of the source code, while "'''aspect-oriented software development"''' refers to a whole engineering discipline.

Aspect-oriented programming entails breaking down program logic into distinctcohesive partsareas of functionality (so-called ''concerns'', cohesive areas of functionality). Nearly all programming paradigms support some level of grouping and [[encapsulation (computer science)|encapsulation]] of concerns into separate, independent entities by providing abstractions (e.g., functions, procedures, modules, classes, methods) that can be used for implementing, abstracting, and composing these concerns. Some concerns "cut across" multiple abstractions in a program, and defy these forms of implementation. These concerns are called ''cross-cutting concerns'' or horizontal concerns.

[[dataLogging logging(computing)|Logging]] exemplifies a crosscuttingcross-cutting concern because a logging strategy necessarilymust affectsaffect every logged part of the system. Logging thereby ''crosscuts'' all logged classes and methods.

All AOP implementations have some crosscuttingcross-cutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. For example, interceptors that specify the methods to express a limited form of crosscuttingcross-cutting, without much support for type-safety or debugging. [[AspectJ]] has a number of such expressions and encapsulates them in a special class, called an [[aspect (computer science)|aspect]]. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying [[Advice in aspect-oriented programming|advice]] (additional behavior) at various [[join point]]s (points in a program) specified in a quantification or query called a [[pointcut]] (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, likesuch as adding members or parents.

==History==

AOP has several direct antecedents A1 and A2:<ref>{{Cite conference | doi = 10.1007/BFb0053381 | title = Aspect-oriented programming | work = Proceedings of the 11th European Conference on Object-Oriented Programming | conference = [[European Conference on Object-Oriented Programming|ECOOP]]'97 | volume = 1241 | pages = 220–242 | series = [[Lecture Notes in Computer Science|LNCS]] |(LNCS) |year = 1997 | last1 = Kiczales | first1 = G. | author1-link = Gregor Kiczales | last2 = Lamping | first2 = J. | last3 = Mendhekar | first3 = A. | last4 = Maeda | first4 = C. | last5 = Lopes | first5 = C. | last6 = Loingtier | first6 = J. M. | last7 = Irwin | first7 = J. | isbn = 3-540-63089-9 | citeseerx = 10.1.1.115.8660 | url = http://www.cs.ubc.ca/~gregor/papers/kiczales-ECOOP1997-AOP.pdf | url-status = live | archiveurl archive-url= https://web.archive.org/web/20160112141810/http://www.cs.ubc.ca/%7Egregor/papers/kiczales-ECOOP1997-AOP.pdf | archivedate archive-date= 2016-01-12 }}</ref> [[reflection (computerReflective programming)|reflection]] and [[Metaobject|metaobject protocol]]s protocols, [[subject-oriented programming]], Composition Filters, and Adaptive Programming.<ref>"Adaptive Object Oriented Programming: The Demeter Approach with Propagation Patterns" ''Karl Liebherr'' 1996 {{ISBN|0-534-94602-X}} presents a well-worked version of essentially the same thing (Lieberherr subsequently recognized this and reframed his approach).</ref>

[[Gregor Kiczales]] and colleagues at [[Xerox PARC]] developed the explicit concept of AOP, and followed this with the [[AspectJ]] AOP extension to Java. IBM's research team pursued a tool approach over a language design approach and in 2001 proposed [[Hyper/J]] and the [[Concern Manipulation Environment]], which have not seen wide usageuse.

The examples in this article use AspectJ.

The [[Microsoft Transaction Server]] is considered to be the first major application of AOP followed by [[Enterprise JavaBeans]].<ref name="BoxSells2002">{{cite book|author1=Don Box|author2=Chris Sells|title=Essential.NET: The common language runtime|url=https://archive.org/details/essentialnetcomm01boxd|url-access=registration|accessdateaccess-date=4 October 2011|date=4 November 2002|publisher=Addison-Wesley Professional|isbn=978-0-201-73411-9|page=[https://archive.org/details/essentialnetcomm01boxd/page/n231206 206]}}</ref><ref name="RomanSriganesh2005">{{cite book|last1=Roman|first1=Ed|last2=Sriganesh|first2=Rima Patel|last3=Brose|first3=Gerald|title=Mastering Enterprise JavaBeans|url=https://books.google.com/books?id=60oym_-uu3EC&pg=PA285|accessdateaccess-date=4 October 2011|date=1 January 2005|publisher=John Wiley and Sons|isbn=978-0-7645-8492-3|page=285}}</ref>

== Motivation and basic concepts ==

Typically, an aspect is ''scattered'' or ''tangled'' as code, making it harder to understand and maintain. It is scattered by virtue of the function (such as logging) being spread over a number of unrelated functions that might use ''its'' function, possibly in entirely unrelated systems, differentor sourcewritten languages,in etcdifferent languages. ThatThus, means to changechanging logging can require modifying all affected modules. Aspects become tangled not only with the mainline function of the systems in which they are expressed but also with each other. That means changingChanging one concern thus entails understanding all the tangled concerns or having some means by which the effect of changes can be inferred.

For example, consider a banking application with a conceptually very simple method for transferring an amount from one account to another:<ref>Note: The examples in this article appear in a syntax that resembles that of the [[Java (programming language)|Java]] language.</ref>

<sourcesyntaxhighlight lang="java">

void transfer(Account fromAcc, Account toAcc, int amount) throws Exception {

if (fromAcc.getBalance() < amount)

Line 32 ⟶ 33:

toAcc.deposit(amount);

}

</syntaxhighlight>

</source>

However, this transfer method overlooks certain considerations that a deployed application would require:, itsuch lacks security checks toas verifyverifying that the current user hasis the authorizationauthorized to perform this operation;, aencapsulating [[database transaction|database transactions]] should encapsulate the operation in order to prevent accidental data loss;, forand diagnostics,logging the operation shouldfor be logged to the system log,diagnostic etcpurposes.

A version with all those new concerns, for the sake of example, couldmight look somewhat like this:

<sourcesyntaxhighlight lang="java">

void transfer(Account fromAcc, Account toAcc, int amount, User user,

Logger logger, Database database) throws Exception {

Line 60 ⟶ 61:

logger.info("Transaction successful.");

}

</syntaxhighlight>

</source>

In this example, other interests have become ''tangled'' with the basic functionality (sometimes called the ''business logic concern''). Transactions, security, and logging all exemplify ''[[cross-cutting concern]]s''.

Now consider what happenswould happen if we suddenly need to change (for example) the security considerations for the application. In the program's current version, security-related operations appear ''scattered'' across numerous methods, and such a change would require a major effort.

AOP attemptstries to solve this problem by allowing the programmer to express cross-cutting concerns in stand-alone modules called ''aspects''. Aspects can contain ''advice'' (code joined to specified points in the program) and ''inter-type declarations'' (structural members added to other classes). For example, a security module can include advice that performs a security check before accessing a bank account. The [[pointcut]] defines the times ([[join point]]s) when one can access a bank account, and the code in the advice body defines how the security check is implemented. That way, both the check and the places can be maintained in one place. Further, a good pointcut can anticipate later program changes, so if another developer creates a new method to access the bank account, the advice will apply to the new method when it executes.

So for the example above implementing logging in an aspect:

<sourcesyntaxhighlight lang="aspectj">

aspect Logger {

void Bank.transfer(Account fromAcc, Account toAcc, int amount, User user, Logger logger) {

Line 82 ⟶ 83:

// Other crosscutting code.

}

</syntaxhighlight>

</source>

One can think of AOP as a debugging tool or as a user-level tool. Advice should be reserved for thecases casesin wherewhich youone cannot get the function changed (user level)<ref>{{cite web|url=https://www.gnu.org/software/emacs/manual/html_node/elisp/Advising-Functions.html|title=gnu.org|websitepublisher=www.gnu.orgGNU Project|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20171224053656/http://www.gnu.org/software/emacs/manual/html_node/elisp/Advising-Functions.html|archivedatearchive-date=24 December 2017}}</ref> or do not want to change the function in production code (debugging).

==Join point models==

The advice-related component of an aspect-oriented language defines a join point model (JPM). A JPM defines three things:

# When the advice can run. These are called ''[[join point]]s'' because they are points in a running program where additional behavior can be usefully joined. A join point needs to be addressable and understandable by an ordinary programmer to be useful. It should also be stable across inconsequential program changes into order for anmaintain aspect to be stable across such changesstability. Many AOP implementations support method executions and field references as join points.

# A way to specify (or ''quantify'') join points, called ''[[pointcut]]s''. Pointcuts determine whether a given join point matches. Most useful pointcut languages use a syntax like the base language (for example, [[AspectJ]] uses Java signatures) and allow reuse through naming and combination.

# A means of specifying code to run at a join point. [[AspectJ]] calls this ''[[advice in aspect-oriented programming|advice]]'', and can run it before, after, and around join points. Some implementations also support things like defining a method in an aspect on another class.

Join-point models can be compared based on the join points exposed, how join points are specified, the operations permitted at the join points, and the structural enhancements that can be expressed.

===AspectJ's join-point model===

{{Main article|AspectJ }}

{{unordered list

*| The join points in AspectJ include method or constructor call or execution, the initialization of a class or object, field read and write access, and exception handlers, etc. They do not include loops, super calls, throws clauses, or multiple statements, etc.

*| Pointcuts are specified by combinations of ''primitive pointcut designators'' (PCDs).

:"Kinded" PCDs match a particular kind of join point (e.g., method execution) and tend tooften take as input a Java-like signature as input. One such pointcut looks like this:

* The join points in AspectJ include method or constructor call or execution, the initialization of a class or object, field read and write access, exception handlers, etc. They do not include loops, super calls, throws clauses, multiple statements, etc.

<syntaxhighlight lang="aspectj">

* Pointcuts are specified by combinations of ''primitive pointcut designators'' (PCDs).

execution(* set*(*))

</syntaxhighlight>

:"Kinded" PCDs match a particular kind of join point (e.g., method execution) and tend to take as input a Java-like signature. One such pointcut looks like this:

:This pointcut matches a method-execution join point, if the method name starts with "<code>set</code>" and there is exactly one argument of any type.

execution(* set*(*))

:This pointcut matches a method-execution join point, if the method name starts with "<code>set</code>" and there is exactly one argument of any type.

"Dynamic" PCDs check runtime types and bind variables. For example,

<syntaxhighlight lang="aspectj">

this(Point)

</syntaxhighlight>

:This pointcut matches when the currently executing object is an instance of class <code>Point</code>. Note that the unqualified name of a class can be used via Java's normal type lookup.

"Scope" PCDs limit the lexical scope of the join point. For example:

<syntaxhighlight lang="aspectj">

within(com.company.*)

</syntaxhighlight>

: This pointcut matches any join point in any type in the <code>com.company</code> package. The ''<code>*</code>'' is one form of the wildcards that can be used to match many things with one signature.

Pointcuts can be composed and named for reuse. For example:

<sourcesyntaxhighlight lang="aspectj">

pointcut set() : execution(* set*(*) ) && this(Point) && within(com.company.*);

</syntaxhighlight>

</source>

:This pointcut matches a method-execution join point, if the method name starts with "<code>set</code>" and <code>this</code> is an instance of type <code>Point</code> in the <code>com.company</code> package. It can be referred to using the name "<code>set()</code>".

*| Advice specifies to run at (before, after, or around) a join point (specified with a pointcut) certain code (specified like code in a method). The AOP runtime invokes Advice automatically when the pointcut matches the join point. For example:

<syntaxhighlight lang="aspectj">

after() : set() {

Display.update();

}

</syntaxhighlight>

:This effectively specifies: "if the ''<code>set()</code>'' pointcut matches the join point, run the code <code>Display.update()</code> after the join point completes."}}

after() : set() {

Display.update();

}

:

:This effectively specifies: "if the ''<code>set()</code>'' pointcut matches the join point, run the code <code>Display.update()</code> after the join point completes."

===Other potential join point models===

Line 137 ⟶ 139:

* Join points are all model elements.

* Pointcuts are some boolean[[Boolean expression]] combining the model elements.

* The means of affect at these points are a visualization of all the matched join points.

===Inter-type declarations===

''Inter-type declarations'' provide a way to express crosscuttingcross-cutting concerns affecting the structure of modules. Also known as ''open classes'' and ''[[extension method]]s'', this enables programmers to declare in one place members or parents of another class, typically in order to combine all the code related to a concern in one aspect. For example, if a programmer implemented the crosscuttingcross-cutting display-update concern using visitors instead, an inter-type declaration using the [[visitor pattern]] might look like this in AspectJ:

<sourcesyntaxhighlight lang="aspectj">

aspect DisplayUpdate {

void Point.acceptVisitor(Visitor v) {

Line 150 ⟶ 152:

// other crosscutting code...

}

</syntaxhighlight>

</source>

This code snippet adds the <code>acceptVisitor</code> method to the <code>Point</code> class.

ItAny isstructural aadditions requirementare thatrequired any structural additionsto be compatible with the original class, so that clients of the existing class continue to operate, unless the AOP implementation can expect to control all clients at all times.

==Implementation==

Line 162 ⟶ 164:

# the ultimate interpreter or environment is updated to understand and implement AOP features.

The difficulty of changing environments means most implementations produce compatible combination programs through a processtype of [[program transformation]] known as ''weaving'' - a special case of [[program transformation]]. An [[aspect weaver]] reads the aspect-oriented code and generates appropriate object-oriented code with the aspects integrated. The same AOP language can be implemented through a variety of weaving methods, so the semantics of a language should never be understood in terms of the weaving implementation. Only the speed of an implementation and its ease of deployment are affected by whichthe method of combination is used.

Systems can implement source-level weaving using preprocessors (as C++ was implemented originally in [[CFront]]) that require access to program source files. However, Java's well-defined binary form enables bytecode weavers to work with any Java program in .class-file form. Bytecode weavers can be deployed during the build process or, if the weave model is per-class, during class loading. [[AspectJ]] started with source-level weaving in 2001, delivered a per-class bytecode weaver in 2002, and offered advanced load-time support after the integration of [[AspectWerkz]] in 2005.

Any solution that combines programs at runtime has tomust provide views that segregate them properly to maintain the programmer's segregated model. Java's bytecode support for multiple source files enables any debugger to step through a properly woven .class file in a source editor. However, some third-party decompilers cannot process woven code because they expect code produced by Javac rather than all supported bytecode forms (see also "[[#Criticism|§&nbsp;Criticism]]", below).

[[Deploy-time]] weaving offers another approach.<ref>{{cite web |url=http://www.forum2.org/tal/AspectJ2EE.pdf |title=Archived copy |accessdateaccess-date=2005-06-19 |url-status=dead |archiveurlarchive-url=https://web.archive.org/web/20051008065854/http://www.forum2.org/tal/AspectJ2EE.pdf |archivedatearchive-date=2005-10-08 }}</ref> This basically implies post-processing, but rather than patching the generated code, this weaving approach ''subclasses'' existing classes so that the modifications are introduced by method-overriding. The existing classes remain untouched, even at runtime, and all existing tools, such as (debuggers, and profilers, etc.) can be used during development. A similar approach has already proven itself in the implementation of many [[Java EE]] application servers, such as [[IBM]]'s [[WebSphere]].

===Terminology===

Line 174 ⟶ 176:

Standard terminology used in Aspect-oriented programming may include:

;Cross-cutting concerns: {{main article|Cross-cutting concern}} Even though most classes in an OOobject-oriented model will perform a single, specific function, they often share common, secondary requirements with other classes. For example, we may want to add logging to classes within the data-access layer and also to classes in the UI layer whenever a thread enters or exits a method. Further concerns can be related to security such as [[Access control#Computer security|access control]] <ref name="dewin2002">B. De Win, B. Vanhaute and B. De Decker. "Security through aspect-oriented programming". In ''Advances in Network and Distributed Systems Security'' (2002).</ref> or [[Information flow (information theory)|information flow control]].<ref name="pasquier2014">T. Pasquier, J. Bacon and B. Shand. "FlowR: Aspect Oriented Programming for Information Flow Control in Ruby". In ''ACM Proceedings of the 13th international conference on Modularity (Aspect Oriented Software Development)'' (2014).</ref> Even though each class has a very different primary functionality, the code needed to perform the secondary functionality is often identical.

;

;Advice: {{main article|Advice (programming)}} This is the additional code that you want to apply to your existing model. In our example, this is the logging code that we want to apply whenever the thread enters or exits a method.

;PointcutAdvice: {{main article|PointcutAdvice (programming)}} This is the termadditional givencode tothat theyou pointwant ofto executionapply into the application at which cross-cutting concern needs toyour beexisting appliedmodel. In our example, a pointcutthis is reached when the threadlogging enterscode athat method,we andwant anotherto pointcutapply is reached whenwhenever the thread enters or exits thea method.:

;Pointcut: {{main article|Pointcut}} This refers to the point of execution in the application at which cross-cutting concern needs to be applied. In our example, a pointcut is reached when the thread enters a method, and another pointcut is reached when the thread exits the method.

;

;Aspect: {{main article|Aspect (computer science)}} The combination of the pointcut and the advice is termed an aspect. In the example above, we add a logging aspect to our application by defining a pointcut and giving the correct advice.

== Comparison to other programming paradigms ==

Aspects emerged from [[object-oriented programming]] and [[computationalreflective reflectionprogramming]]. AOP languages have functionality similar to, but more restricted than, [[Metaobject|metaobject protocols]]. Aspects relate closely to programming concepts like [[subjects (programming)|subjects]], [[mixin]]s, and [[delegation (programming)|delegation]]. Other ways to use aspect-oriented programming paradigms include [[Composition Filters]] and the [[Hyper/J|hyperslices]] approach. Since at least the 1970s, developers have been using forms of interception and dispatch-patching that resemble some of the implementation methods for AOP, but these never had the semantics that the crosscuttingcross-cutting specifications provide written in one place. {{Citation needed|date=February 2019}}

Designers have considered alternative ways to achieve separation of code, such as [[C Sharp (programming language)|C#]]'s partial types, but such approaches lack a quantification mechanism that allows reaching several join points of the code with one declarative statement.{{citation needed|date=May 2021}}

Though it may seem unrelated, in testing, the use of mocks or stubs requires the use of AOP techniques, likesuch as around advice, and so forth. Here the collaborating objects are for the purpose of the test, a cross -cutting concern. Thus, the various Mock Object frameworks provide these features. For example, a process invokes a service to get a balance amount. In the test of the process, it is unimportant where the amount comes from, is unimportant,but only that the process uses the balance according to the requirements.{{citation needed|date=May 2021}}

== Adoption issues ==

Programmers need to be able to read code and understand what is happening in ordercode to prevent errors.<ref>[[Edsger Dijkstra]], [http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF ''Notes on Structured Programming''] {{webarchive|url=https://web.archive.org/web/20061012020239/http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF |date=2006-10-12 }}, pg. 1-2</ref>

Even with proper education, understanding crosscuttingcross-cutting concerns can be difficult without proper support for visualizing both static structure and the dynamic flow of a program.<ref name="harmful" /> BeginningStarting in 2002, AspectJ began to provide IDE plug-ins to support the visualizing of crosscuttingcross-cutting concerns. Those features, as well as aspect code assist and [[Code refactoring|refactoring]], are now common.

Given the power of AOP, if a programmer makesmaking a logical mistake in expressing crosscutting, itcross-cutting can lead to widespread program failure. Conversely, another programmer may change the join points in a program, &ndash;such e.g.,as by renaming or moving methods &ndash;, in ways that the aspect writer did not anticipate, and with [[unforeseen consequences]]. One advantage of modularizing crosscuttingcross-cutting concerns is enabling one programmer to easily affect the entire system. easily; asAs a result, such problems presentmanifest as a conflict over responsibility between two or more developers for a given failure. However,AOP thecan solutionexpedite forsolving these problems can be much easier in the presence of AOP, sinceas only the aspect needs tomust be changed,. whereasWithout AOP, the corresponding problems without AOP can be much more spread out.{{citation needed|date=May 2021}}

==Criticism==

The most basic criticism of the effect of AOP is that control flow is obscured, and that it is not only worse than the much-maligned [[GOTO]] statement, but is in fact closely analogous to the joke [[COME FROM]] statement.<ref name="harmful" />. The ''obliviousness of application'', which is fundamental to many definitions of AOP (the code in question has no indication that an advice will be applied, which is specified instead in the pointcut), means that the advice is not visible, in contrast to an explicit method call.<ref name="harmful">{{cite conference|url=http://pp.info.uni-karlsruhe.de/uploads/publikationen/constantinides04eiwas.pdf| |title=AOP Considered Harmful |first1=Constantinos |last1=Constantinides |first2=Therapon |last2=Skotiniotis |first3=Maximilian |last3=Störzer|date=September 2004|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20160323061458/https://pp.info.uni-karlsruhe.de/uploads/publikationen/constantinides04eiwas.pdf|archivedatearchive-date=23 March 2016|conference=European Interactive Workshop on Aspects in Software (EIWAS)| |___location=Berlin, Germany}}</ref><ref>[[C2:ComeFrom]]</ref> For example, compare the COME FROM program:<ref name="harmful"/>

<sourcesyntaxhighlight lang="basic" highlight="4">

5 INPUT X

10 PRINT 'Result is :'

Line 202 ⟶ 206:

25 X = X * X

30 RETURN

</syntaxhighlight>

</source>

with an AOP fragment with analogous semantics:

<sourcesyntaxhighlight lang="java" highlight="8">

main() {

input x

Line 214 ⟶ 218:

return temp * temp

}

</syntaxhighlight>

</source>

Indeed, the pointcut may depend on runtime condition and thus not be statically deterministic. This can be mitigated but not solved by static analysis and IDE support showing which advices ''potentially'' match.

General criticisms are that AOP purports to improve "both modularity and the structure of code", but some counter that it instead undermines these goals and impedes "independent development and understandability of programs".<ref name="steimann">{{Cite journal | doi = 10.1145/1167515.1167514 | title = The paradoxical success of aspect-oriented programming | journal = ACM SIGPLAN Notices | volume =41 41| issue =10 10| pages =481–497 481| year =2006 2006| last1 = Steimann | first1 = F. | citeseerx = 10.1.1.457.2210}}, ([http://people.dsv.su.se/~johano/ioor/succ_aop.pdf slides] {{webarchive|url=https://web.archive.org/web/20160304060007/http://people.dsv.su.se/~johano/ioor/succ_aop.pdf |date=2016-03-04 }},[http://www.eecs.ucf.edu/~leavens/modular-aop/Discussion.pdf slides 2] {{webarchive|url=https://web.archive.org/web/20150923234021/http://www.eecs.ucf.edu/~leavens/modular-aop/Discussion.pdf |date=2015-09-23 }}, [http://www.oopsla.org/2006/submission/essays/the_paradoxical_success_of_aspect-oriented_programming.html abstract] {{webarchive|url=https://web.archive.org/web/20150924060711/http://www.oopsla.org/2006/submission/essays/the_paradoxical_success_of_aspect-oriented_programming.html |date=2015-09-24 }}), Friedrich Steimann, Gary T. Leavens, [[OOPSLA]] 2006</ref> Specifically, quantification by pointcuts breaks modularity: "one must, in general, have whole-program knowledge to reason about the dynamic execution of an aspect-oriented program."<ref>{{cite web|url=http://www.eecs.ucf.edu/~leavens/modular-aop/|title=More Modular Reasoning for Aspect-Oriented Programs|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150812045258/http://www.eecs.ucf.edu/~leavens/modular-aop/|archivedatearchive-date=12 August 2015}}</ref> Further, while its goals (modularizing cross-cutting concerns) are well understood, its actual definition is unclear and not clearly distinguished from other well-established techniques.<ref name="steimann"/> Cross-cutting concerns potentially cross-cut each other, requiring some resolution mechanism, such as ordering.<ref name="steimann"/> Indeed, aspects can apply to themselves, leading to problems such as the [[liar paradox]].<ref>{{cite web|url=http://www.fernuni-hagen.de/ps/pubs/FOAL2006.pdf|title=AOP and the Antinomy of the Liar|website=fernuni-hagen.de|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20170809201001/http://www.fernuni-hagen.de/ps/pubs/FOAL2006.pdf|archivedatearchive-date=9 August 2017}}</ref>

Technical criticisms include that the quantification of pointcuts (defining where advices are executed) is "extremely sensitive to changes in the program", which is known as the ''fragile pointcut problem''.<ref name="steimann"/> The problems with pointcuts are deemed intractable:. ifIf one replaces the quantification of pointcuts with explicit annotations, one obtains [[attribute-oriented programming]] instead, which is simply an explicit subroutine call and suffers the identical problem of scattering, thatwhich AOP was designed to solve.<ref name="steimann"/>

==Implementations==

The followingMany [[programming language]]s have implemented AOP, within the language, or as an external [[Library (computing)|library]], including:

*[[.NET Framework]] framework languages ([[C Sharp (programming language)|C#]] /, [[Visual Basic (.NET|)]] (VB.NET]]))<ref>Numerous:

[https://github.com/vc3/Afterthought Afterthought] {{webarchive|url=https://web.archive.org/web/20160315162029/https://github.com/vc3/Afterthought |date=2016-03-15 }}, [http://www.rapier-loom.net/ LOOM.NET] {{webarchive|url=https://web.archive.org/web/20080827215106/http://www.rapier-loom.net/ |date=2008-08-27 }}, [http://www.codeplex.com/entlib Enterprise Library 3.0 Policy Injection Application Block] {{webarchive|url=https://web.archive.org/web/20070119154829/http://www.codeplex.com/entlib |date=2007-01-19 }}, [httphttps://sourceforge.net/projects/aspectdng/ AspectDNG] {{webarchive|url=https://web.archive.org/web/20040929053513/http://sourceforge.net/projects/aspectdng |date=2004-09-29 }}, [http://www.castleproject.org/projects/dynamicproxy/ DynamicProxy] {{webarchive|url=https://web.archive.org/web/20151205001755/http://www.castleproject.org/projects/dynamicproxy/ |date=2015-12-05 }}, [httphttps://composestar.sourceforge.net/ Compose*] {{webarchive|url=http://archive.wikiwix.com/cache/20050821193804/http://composestar.sourceforge.net/ |date=2005-08-21 }}, [http://www.postsharp.net/ PostSharp] {{webarchive|url=https://web.archive.org/web/20160503095409/https://www.postsharp.net/ |date=2016-05-03 }}, [http://www.seasar.org/en/dotnet/ Seasar.NET] {{webarchive|url=https://web.archive.org/web/20060725015434/http://www.seasar.org/en/dotnet/ |date=2006-07-25 }}, [http://dotspect.tigris.org/ DotSpect (.SPECT)] {{webarchive|url=https://web.archive.org/web/20060331071126/http://dotspect.tigris.org/ |date=2006-03-31 }}, [http://www.springframework.net/ Spring.NET] {{webarchive|url=https://web.archive.org/web/20060402205922/http://springframework.net/ |date=2006-04-02 }} (as part of its functionality), [https://www.cs.columbia.edu/~eaddy/wicca Wicca and Phx.Morph] {{webarchive|url=https://web.archive.org/web/20061207110849/http://www1.cs.columbia.edu/~eaddy/wicca/ |date=2006-12-07 }}, [http://setpoint.codehaus.org/ SetPoint] {{webarchive|url=https://web.archive.org/web/20081007002006/http://setpoint.codehaus.org/ |date=2008-10-07 }}</ref>

**[https://www.postsharp.net/ PostSharp] is a commercial AOP implementation with a free but limited edition.

**[[Unity Application Block|Unity]], It provides an API to facilitate proven practices in core areas of programming including data access, security, logging, exception handling and others.

**[https://github.com/tfreyburger/aspectDN/ AspectDN] is an AOP implementation allowing to weave the aspects directly on the .NET executable files.

*[[ActionScript]]<ref>{{cite web|url=http://www.as3commons.org/as3-commons-bytecode|title=Welcome to as3-commons-bytecode|website=as3commons.org|accessdate=5 May 2018|url-status=live|archiveurl=https://web.archive.org/web/20141003100345/http://www.as3commons.org/as3-commons-bytecode/|archivedate=3 October 2014}}</ref>

*[[Ada (programming language)|AdaActionScript]]<ref>{{cite web|url=http://www.adacoreas3commons.comorg/uploads/technicalas3-papers/Ada2012_Rational_Introducion.pdfcommons-bytecode|title=Ada2012Welcome Rationaleto as3-commons-bytecode|website=adacoreas3commons.comorg|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/2016041813234020141003100345/http://www.adacoreas3commons.comorg/uploads/technicalas3-paperscommons-bytecode/Ada2012_Rational_Introducion.pdf|archivedatearchive-date=183 AprilOctober 20162014}}</ref>

*[[AutoHotkeyAda (programming language)|Ada]]<ref>{{cite web|url=http://www.autohotkeyadacore.com/forumuploads/viewtopictechnical-papers/Ada2012_Rational_Introducion.php?ppdf|title=Ada2012 Rationale|website=adacore.com|access-date=5 May 2018|url-status=243426live|archive-url=https://web.archive.isorg/web/2013011712511720160418132340/http://www.autohotkeyadacore.com/forumuploads/viewtopictechnical-papers/Ada2012_Rational_Introducion.php?p=243426|url-status=deadpdf|archive-date=1718 JanuaryApril 2013|title=Function Hooks|website=autohotkey.com|accessdate=5 May 20182016}}</ref>

*[[AutoHotkey]]<ref>{{cite web|url=http://www.autohotkey.com/forum/viewtopic.php?p=243426|archive-url=https://archive.today/20130117125117/http://www.autohotkey.com/forum/viewtopic.php?p=243426|url-status=dead|archive-date=17 January 2013|title=Function Hooks|website=autohotkey.com|access-date=5 May 2018}}</ref>
*[[C (programming language)|C]] /, [[C++]]<ref>Several: [[AspectC++]], [http://wwwiti.cs.uni-magdeburg.de/iti_db/forschung/fop/featurec/ FeatureC++], [http://www.cs.ubc.ca/labs/spl/projects/aspectc.html AspectC] {{webarchive|url=https://web.archive.org/web/20060821190630/http://www.cs.ubc.ca/labs/spl/projects/aspectc.html |date=2006-08-21 }}, [http://www.aspectc.net/ AspeCt-oriented C] {{webarchive|url=https://web.archive.org/web/20081120144608/http://www.aspectc.net/ |date=2008-11-20 }}, [https://archive.istoday/20120721212648/http://www.bramadams.org/aspicere/index.html Aspicere]</ref>

*[[COBOL]]<ref>{{cite web|url=http://homepages.vub.ac.be/~kdeschut/cobble/|title=Cobble|author=|date=|website=vub.ac.be|accessdateaccess-date=5 May 2018}}{{dead link|date=May 2018 |bot=SheriffIsInTown |fix-attempted=yes }}</ref>

*The [[Cocoa (API)|Cocoa]] [[Objective-C]] frameworks<ref>{{cite web|url=http://www.ood.neu.edu/aspectcocoa/|title=AspectCocoa|website=neu.edu|accessdateaccess-date=5 May 2018|url-status=dead|archiveurlarchive-url=https://web.archive.org/web/20071026022525/http://www.ood.neu.edu/aspectcocoa/|archivedatearchive-date=26 October 2007}}</ref>

*[[ColdFusion]]<ref>{{cite web|url=http://coldspringframework.org/|title=ColdSpring Framework: Welcome|date=5 November 2005|accessdateaccess-date=5 May 2018|url-status=bot: unknown|archiveurlarchive-url=https://web.archive.org/web/20051105014513/http://coldspringframework.org/|archivedatearchive-date=5 November 2005}}</ref>

*[[Common Lisp]]<ref>{{cite web|url=http://common-lisp.net/project/closer/aspectl.html|title=Closer Project: AspectL.|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=http://archive.wikiwix.com/cache/20110223172923/http://common-lisp.net/project/closer/aspectl.html|archivedatearchive-date=23 February 2011}}</ref>

*[[Borland Delphi (software)|Delphi]]<ref>{{cite web|url=https://code.google.com/p/infra/|title=infra -– Frameworks Integrados para Delphi -– Google Project Hosting|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150909070130/http://code.google.com/p/infra/|archivedatearchive-date=9 September 2015}}</ref><ref>{{cite web|url=https://code.google.com/p/meaop/|title=meaop -– MeSDK: MeObjects, MeRTTI, MeAOP -– Delphi AOP(Aspect Oriented Programming), MeRemote, MeService... -– Google Project Hosting|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150910210536/http://code.google.com/p/meaop/|archivedatearchive-date=10 September 2015}}</ref><ref>{{cite web|url=https://code.google.com/p/delphisorcery/|title=Google Project Hosting|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20141225080131/https://code.google.com/p/delphisorcery/|archivedatearchive-date=25 December 2014}}</ref>

*[[Delphi Prism]]<ref>{{cite web|url=http://prismwiki.codegear.com/en/Cirrus|title=RemObjects Cirrus|website=codegear.com|accessdateaccess-date=5 May 2018|url-status=dead|archiveurlarchive-url=https://web.archive.org/web/20120123094027/http://prismwiki.codegear.com/en/Cirrus|archivedatearchive-date=23 January 2012}}</ref>

*[[E (verification language)|e]] (IEEE 1647)

*[[Emacs Lisp]]<ref>{{cite web|url=https://www.gnu.org/software/emacs/elispmanual/html_node/elisp/Advising-Functions.html|title=Emacs Advice Functions|websitepublisher=gnu.orgGNU Project|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20111024211408/http://www.gnu.org/software/emacs/elisp/html_node/Advising-Functions.html|archivedatearchive-date=24 October 2011}}</ref>

*[[Groovy (programming language)|Groovy]]

*[[Haskell]]<ref>[[Monad (functional programming)|Monad]]s allow program semantics to be altered by changing the type of the program without altering its code: {{cite journal |citeseerx=10.1.1.25.8262 |title=Monads As a theoretical basis for AOP |journal=International Workshop on Aspect-Oriented Programming at ECOOP |first=Wolfgang |last=De Meuter |year=1997 |page=25}} {{cite book |chapter-url=http://dl.acm.org/citation.cfm?id=2451457 |first1=Nicolas |last1=Tabareau |first2=Ismael |last2=Figueroa |first3=Éric |last3=Tanter |title=Proceedings of the 12th annual international conference on Aspect-oriented software development |chapter=A typed monadic embedding of aspects |series=Aosd '13 |date=March 2013 |pages=171–184 |doi=10.1145/2451436.2451457 |isbn=9781450317665 |s2cid=27256161 |url=https://hal.inria.fr/hal-00763695/file/main.pdf}} [[Type class]]es allow additional capabilities to be added to a type: {{cite book |first1=Martin |last1=Sulzmann |first2=Meng |last2=Wang |title=Proceedings of the 6th workshop on Foundations of aspect-oriented languages |chapter=Aspect-oriented programming with type classes |chapter-url=http://portal.acm.org/citation.cfm?id=1233842 |date=March 2007 |pages=65–74 |doi=10.1145/1233833.1233842 |isbn=978-1595936615 |s2cid=3253858 |url=https://kar.kent.ac.uk/47468/1/local_143541.pdf}}.</ref>

*[[Haskell (programming language)|Haskell]]<ref>[[monad (functional programming)]] ({{cite journal | citeseerx = 10.1.1.25.8262 | title = Monads As a theoretical basis for AOP }}) and [http://portal.acm.org/citation.cfm?id=1233842 Aspect-oriented programming with type classes.] [http://dl.acm.org/citation.cfm?id=2451457 A Typed Monadic Embedding of Aspects]</ref>

*[[Java (programming language)|Java]]<ref>Numerous others: [http://www.caesarj.org/ CaesarJ] {{webarchive|url=https://web.archive.org/web/20081219181529/http://caesarj.org/ |date=2008-12-19 }}, [httphttps://composestar.sourceforge.net/ Compose*] {{webarchive|url=http://archive.wikiwix.com/cache/20050821193804/http://composestar.sourceforge.net/ |date=2005-08-21 }}, [http://dynaop.dev.java.net/ Dynaop] {{webarchive|url=https://web.archive.org/web/20070724061030/https://dynaop.dev.java.net/ |date=2007-07-24 }}, [http://jac.objectweb.org/ JAC] {{webarchive|url=https://web.archive.org/web/20040619135517/http://jac.objectweb.org/ |date=2004-06-19 }}, [[Google Guice]] (as part of its functionality), [http://www.csg.is.titech.ac.jp/~chiba/javassist/ Javassist] {{webarchive|url=https://web.archive.org/web/20040901095342/http://www.csg.is.titech.ac.jp/~chiba/javassist/ |date=2004-09-01 }}, [http://ssel.vub.ac.be/jasco/ JAsCo (and AWED)] {{webarchive|url=https://web.archive.org/web/20050411010213/http://ssel.vub.ac.be/jasco/ |date=2005-04-11 }}, [http://www.ics.uci.edu/~trungcn/jaml/ JAML] {{webarchive|url=https://web.archive.org/web/20050415091244/http://www.ics.uci.edu/~trungcn/jaml/ |date=2005-04-15 }}, [http://labs.jboss.com/portal/jbossaop JBoss AOP] {{webarchive|url=https://web.archive.org/web/20061017211354/http://labs.jboss.com/portal/jbossaop/ |date=2006-10-17 }}, [http://roots.iai.uni-bonn.de/research/logicaj LogicAJ] {{webarchive|url=https://web.archive.org/web/20060504154852/http://roots.iai.uni-bonn.de/research/logicaj/ |date=2006-05-04 }}, [http://www.objectteams.org/ Object Teams] {{webarchive|url=https://web.archive.org/web/20050831200910/http://objectteams.org/ |date=2005-08-31 }}, [http://prose.ethz.ch/ PROSE] {{webarchive|url=https://web.archive.org/web/20070124094344/http://prose.ethz.ch/ |date=2007-01-24 }}, [http://www.aspectbench.org/ The AspectBench Compiler for AspectJ (abc)] {{webarchive|url=https://web.archive.org/web/20141216200424/http://aspectbench.org/ |date=2014-12-16 }}, [[Spring framework]] (as part of its functionality), [[Seasar]], [http://roots.iai.uni-bonn.de/research/jmangler/ The JMangler Project] {{webarchive|url=https://web.archive.org/web/20051028191025/http://roots.iai.uni-bonn.de/research/jmangler/ |date=2005-10-28 }}, [httphttps://injectj.sourceforge.net/ InjectJ] {{webarchive|url=https://web.archive.org/web/20050405080539/http://injectj.sourceforge.net/ |date=2005-04-05 }}, [http://www.csg.is.titech.ac.jp/projects/gluonj/ GluonJ] {{webarchive|url=https://web.archive.org/web/20070206010219/http://www.csg.is.titech.ac.jp/projects/gluonj/ |date=2007-02-06 }}, [http://www.st.informatik.tu-darmstadt.de/static/pages/projects/AORTA/Steamloom.jsp Steamloom] {{webarchive|url=https://web.archive.org/web/20070818100432/http://www.st.informatik.tu-darmstadt.de/static/pages/projects/AORTA/Steamloom.jsp |date=2007-08-18 }}</ref>

**[[AspectJ]]

*[[JavaScript]]<ref>Many: [http://i.gotfresh.info/2007/12/7/advised-methods-for-javascript-with-prototype/ Advisable] {{webarchive|url=https://web.archive.org/web/20080704052200/http://i.gotfresh.info/2007/12/7/advised-methods-for-javascript-with-prototype |date=2008-07-04 }}, [https://code.google.com/p/ajaxpect/ Ajaxpect] {{webarchive|url=https://web.archive.org/web/20160709203939/https://code.google.com/p/ajaxpect/ |date=2016-07-09 }}, [http://plugins.jquery.com/project/AOP jQuery AOP Plugin] {{webarchive|url=https://web.archive.org/web/20080113184156/http://plugins.jquery.com/project/AOP |date=2008-01-13 }}, [http://aspectes.tigris.org/ Aspectes] {{webarchive|url=http://archive.wikiwix.com/cache/20060508035836/http://aspectes.tigris.org/ |date=2006-05-08 }}, [http://www.aspectjs.com/ AspectJS] {{webarchive|url=https://web.archive.org/web/20081216010832/http://www.aspectjs.com/ |date=2008-12-16 }}, [http://www.cerny-online.com/cerny.js/ Cerny.js] {{webarchive|url=https://web.archive.org/web/20070627024906/http://www.cerny-online.com/cerny.js/ |date=2007-06-27 }}, [http://dojotoolkit.org/ Dojo Toolkit] {{webarchive|url=https://web.archive.org/web/20060221211958/http://www.dojotoolkit.org/ |date=2006-02-21 }}, [httphttps://humax.sourceforge.net/ Humax Web Framework] {{webarchive|url=https://web.archive.org/web/20081209103012/http://humax.sourceforge.net/ |date=2008-12-09 }}, [https://code.google.com/p/joose-js/ Joose] {{webarchive|url=https://web.archive.org/web/20150318193601/http://code.google.com/p/joose-js/ |date=2015-03-18 }}, [[Prototype.js|Prototype]] -– [http://www.prototypejs.org/api/function/wrap Prototype Function#wrap] {{webarchive|url=https://web.archive.org/web/20090505233620/http://www.prototypejs.org/api/function/wrap |date=2009-05-05 }}, [http://developer.yahoo.com/yui/3/api/Do.html YUI 3 (Y.Do)] {{webarchive|url=https://web.archive.org/web/20110125115930/https://developer.yahoo.com/yui/3/api/Do.html |date=2011-01-25 }}</ref>

*[[Logtalk (programming language)|Logtalk]]<ref>Using built-in support for categories (which allows the encapsulation of aspect code) and event-driven programming (which allows the definition of ''before'' and after ''event'' handlers).</ref>

*[[Lua (programming language)|Lua]]<ref>{{cite web|url=http://luaforge.net/projects/aspectlua/|title=AspectLua|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150717094121/http://luaforge.net/projects/aspectlua/|archivedatearchive-date=17 July 2015}}</ref>

*[[make (software)|make]]<ref>{{cite web|url=http://www.bramadams.org/makao/|archive-url=https://archive.istoday/20120724151524/http://www.bramadams.org/makao/|url-status=dead|archive-date=24 July 2012|title=MAKAO, re(verse)-engineering build systems|accessdateaccess-date=11 August 2015}}</ref>

*[[Matlab]]<ref>{{cite web|url=http://www.sable.mcgill.ca/mclab/aspectmatlab/index.html|title=McLab|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150924093214/http://www.sable.mcgill.ca/mclab/aspectmatlab/index.html|archivedatearchive-date=24 September 2015}}</ref>

*[[ML (programming language)|ML]]<ref>{{cite web |title=AspectML – Aspect-oriented Functional Programming Language Research |url=http://www.cs.princeton.edu/sip/projects/aspectml/|title=AspectML - Aspect-oriented Functional Programming Language Research|accessdate=11 August 2015|url-status=livedead |archiveurlarchive-url=https://web.archive.org/web/20101205005108/http://www.cs.princeton.edu/sip/projects/aspectml/ |archivedatearchive-date=5 December 2010 |access-date=11 August 2015}}</ref>

*[[Nemerle]]<ref>{{cite web|url=https://github.com/rsdn/nemerle/blob/master/README.md|title=nemerle/README.md at master · rsdn/nemerle|website=[[GitHub]] |access-date=22 March 2018}}</ref>

*[[Perl]]<ref>{{cite web|url=https://metacpan.org/module/Aspect|title=Aspect - Aspect-Oriented Programming (AOP) for Perl - metacpan.org|author=Adam Kennedy|accessdate=11 August 2015|url-status=live|archiveurl=https://web.archive.org/web/20130831064935/https://metacpan.org/module/Aspect|archivedate=31 August 2013}}</ref>

*[[Perl]]<ref>{{cite web|url=https://metacpan.org/module/Aspect|title=Aspect – Aspect-Oriented Programming (AOP) for Perl – metacpan.org|author=Adam Kennedy|access-date=11 August 2015|url-status=live|archive-url=https://web.archive.org/web/20130831064935/https://metacpan.org/module/Aspect|archive-date=31 August 2013}}</ref>
*[[PHP]]<ref>Several: [http://aop.io PHP-AOP (AOP.io)] {{webarchive|url=http://archive.wikiwix.com/cache/20140818050736/http://aop.io/ |date=2014-08-18 }}, [http://go.aopphp.com Go! AOP framework] {{webarchive|url=https://web.archive.org/web/20130301043014/http://go.aopphp.com/ |date=2013-03-01 }}, [https://code.google.com/p/phpaspect/ PHPaspect] {{webarchive|url=https://web.archive.org/web/20160822234503/https://code.google.com/p/phpaspect/ |date=2016-08-22 }}, [http://www.seasar.org/en/php5/index.html Seasar.PHP] {{webarchive|url=https://web.archive.org/web/20051226040309/http://www.seasar.org/en/php5/index.html |date=2005-12-26 }}, [https://archive.istoday/20120712081326/http://php-aop.googlecode.com/ PHP-AOP], [https://flow.neos.io/ Flow] {{webarchive|url=https://web.archive.org/web/20180104132543/https://flow.neos.io/ |date=2018-01-04 }}, [https://github.com/AOP-PHP/AOP AOP PECL Extension] {{webarchive|url=https://web.archive.org/web/20170411031809/https://github.com/AOP-PHP/AOP |date=2017-04-11 }}</ref>

*[[Prolog]]<ref>{{cite web |date=14 December 2005 |title=Aspect-Oriented Programming in Prolog |url=http://www.bigzaphod.org/whirl/dma/docs/aspects/aspects-man.html|title=bigzaphod.org is coming soon|website=www.bigzaphod.org|accessdate=5 May 2018|url-status=livedead |archiveurlarchive-url=https://web.archive.org/web/2016042018183720120303120515/httphttps://www.bigzaphod.org/whirl/dma/docs/aspects/aspects-man.html |archivedatearchive-date=203 AprilMarch 20162012 |access-date=5 May 2018 |website=bigzaphod.org}}</ref>

*[[Python (programming language)|Python]]<ref>Several: [http://peak.telecommunity.com/ PEAK] {{webarchive|url=https://web.archive.org/web/20050409082546/http://peak.telecommunity.com/ |date=2005-04-09 }}, [https://web.archive.org/web/20110609153559/http://old.aspyct.org/ Aspyct AOP], [http://www.cs.tut.fi/~ask/aspects/aspects.html Lightweight Python AOP] {{webarchive|url=https://web.archive.org/web/20041009194711/http://www.cs.tut.fi/~ask/aspects/aspects.html |date=2004-10-09 }}, [http://www.logilab.org/projects/aspects Logilab's aspect module] {{webarchive|url=https://web.archive.org/web/20050309034259/http://www.logilab.org/projects/aspects |date=2005-03-09 }}, [httphttps://pythius.sourceforge.net/ Pythius] {{webarchive|url=https://web.archive.org/web/20050408072457/http://pythius.sourceforge.net/ |date=2005-04-08 }}, [http://springpython.webfactional.com/1.1.x/reference/html/aop.html Spring Python's AOP module] {{webarchive|url=https://web.archive.org/web/20160304055741/http://springpython.webfactional.com/1.1.x/reference/html/aop.html |date=2016-03-04 }}, [httphttps://pytilities.sourceforge.net/doc/1.1.0/guide/aop/ Pytilities' AOP module] {{webarchive|url=https://web.archive.org/web/20110825101213/http://pytilities.sourceforge.net/doc/1.1.0/guide/aop/ |date=2011-08-25 }}, [http://python-aspectlib.readthedocs.org/en/latest/ aspectlib] {{webarchive|url=https://web.archive.org/web/20141105061010/http://python-aspectlib.readthedocs.org/en/latest/ |date=2014-11-05 }}</ref>

*[[Racket (programming language)|Racket]]<ref>{{cite web|url=http://planet.racket-lang.org/display.ss?package=aspectscheme.plt&owner=dutchyn|title=PLaneT Package Repository : PLaneT > dutchyn > aspectscheme.plt|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150905062740/http://planet.racket-lang.org/display.ss?package=aspectscheme.plt&owner=dutchyn|archivedatearchive-date=5 September 2015}}</ref>

*[[Ruby (programming language)|Ruby]]<ref>{{cite web|url=httphttps://aspectr-fork.sourceforge.net/|title=AspectR -– Simple aspect-oriented programming in Ruby|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=http://archive.wikiwix.com/cache/20150812003432/http://aspectr-fork.sourceforge.net/|archivedatearchive-date=12 August 2015}}</ref><ref>{{cite web|url=http://aquarium.rubyforge.org/|archive-url=https://web.archive.org/web/20071026055811/http://aquarium.rubyforge.org/|url-status=dead|archive-date=26 October 2007|title=Home|author=Dean Wampler|accessdateaccess-date=11 August 2015}}</ref><ref>{{cite web|url=https://github.com/gcao/aspector|title=gcao/aspector|work=GitHub|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150104180534/https://github.com/gcao/aspector|archivedatearchive-date=4 January 2015}}</ref>

*[[Squeak]] [[Smalltalk]]<ref>{{cite web|url=http://www.prakinf.tu-ilmenau.de/~hirsch/Projects/Squeak/AspectS/|title=AspectS|website=tu-ilmenau.de|accessdateaccess-date=5 May 2018|url-status=dead|archiveurlarchive-url=https://web.archive.org/web/20060106112030/http://www.prakinf.tu-ilmenau.de/~hirsch/Projects/Squeak/AspectS/|archivedatearchive-date=6 January 2006}}</ref><ref>{{cite web|url=http://csl.ensm-douai.fr/MetaclassTalk|title=MetaclassTalk: Reflection and Meta-Programming in Smalltalk|accessdateaccess-date=11 August 2015|url-status=dead|archiveurlarchive-url=https://web.archive.org/web/20150729062351/http://csl.ensm-douai.fr/MetaclassTalk|archivedatearchive-date=29 July 2015}}</ref>

*[[UML 2|UML 2.0]]<ref>{{cite web|url=http://www.iit.edu/~concur/weavr|title=WEAVR|website=iit.edu|accessdateaccess-date=5 May 2018|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20081212200221/http://www.iit.edu/~concur/weavr/|archivedatearchive-date=12 December 2008}}</ref>

*[[XML]]<ref>{{cite web|url=https://code.google.com/p/aspectxml/|title=aspectxml -– An Aspect-Oriented XML Weaving Engine (AXLE) -– Google Project Hosting|accessdateaccess-date=11 August 2015|url-status=live|archiveurlarchive-url=https://web.archive.org/web/20150912161613/http://code.google.com/p/aspectxml/|archivedatearchive-date=12 September 2015}}</ref>

==See also==

* [[Aspect-oriented software development]]

* [[Distributed AOP]]

* [[Attribute grammar]], a formalism that can be used for aspect-oriented programming on top of [[functional programming]] languages]]

* [[Programming paradigm]]s

* [[Subject-oriented programming]], an alternative to Aspectaspect-oriented programming

* [[Role-oriented programming]], an alternative to Aspectaspect-oriented programming

* [[Predicate dispatch]], an older alternative to Aspectaspect-oriented programming

* [[Executable UML]]

* [[Decorator pattern]]

Line 272 ⟶ 277:

==Notes and references==

{{reflistReflist}}

==Further reading==

* {{Cite conference | doi = 10.1007/BFb0053381 | title = Aspect-oriented programming | work = Proceedings of the 11th European Conference on Object-Oriented Programming | conference = [[European Conference on Object-Oriented Programming|ECOOP]]'97 | volume =1241 1241| pages =220–242 220–242| series = [[Lecture Notes in Computer Science|LNCS]] (LNCS) | year =1997 1997| last1 = Kiczales | first1 = G. | author1-link = Gregor Kiczales | last2 = Lamping | first2 = J. | last3 = Mendhekar | first3 = A. | last4 = Maeda | first4 = C. | last5 = Lopes | first5 = C. | last6 = Loingtier | first6 = J. M. | last7 = Irwin | first7 = J. | isbn = 3-540-63089-9 | citeseerx = 10.1.1.115.8660 | url = http://www.cs.ubc.ca/~gregor/papers/kiczales-ECOOP1997-AOP.pdf}} The paper generally considered to be the authoritative reference for AOP.

* {{cite book |author1=Robert E. Filman |author2=Tzilla Elrad |author3=Siobhán Clarke |author3-link=Siobhán Clarke|author4=Mehmet Aksit |year=2004 |title=Aspect-Oriented Software Development |publisher=Addison-Wesley |isbn=978-0-321-21976-3}}

* {{cite book |author1=Andreas Holzinger |author2=M. Brugger |author3=W. Slany | year = 2011 | title = Applying Aspect Oriented Programming (AOP) in Usability Engineering processes: On the example of Tracking Usage Information for Remote Usability Testing.|others=D. A. Marca, B. Shishkov and M. v. Sinderen (editors)|work=Proceedings of the 8th International Conference on electronic Business and Telecommunications. Sevilla|pages=53–56}}

* {{cite book |author1=RobertRenaud E.Pawlak, FilmanLionel Seinturier |author2=TzillaJean-Philippe ElradRetaillé |author3name-list-style=Siobhán Clarkeamp |author4year=Mehmet Aksit2005 | year title=Foundations 2004of |AOP titlefor = Aspect-Oriented SoftwareJ2EE Development |publisher=Apress |isbn = 978-01-32159059-21976507-37}}

* {{cite book |first=Ramnivas |last=Laddad |author-link=Ramnivas Laddad |year=2003 |title=AspectJ in Action: Practical Aspect-Oriented Programming |publisher=Manning |isbn=978-1-930110-93-9 |url-access=registration |url=https://archive.org/details/aspectjinactionp00ladd}}

* {{cite book |author1=Renaud Pawlak, Lionel Seinturier |author2=Jean-Philippe Retaillé |lastauthoramp=yes | year = 2005 | title = Foundations of AOP for J2EE Development | isbn = 978-1-59059-507-7}}

* {{cite book | first = RamnivasIvar | last=Jacobson |author-link=Ivar LaddadJacobson | authorlink author2=Pan-Wei Ramnivas LaddadNg | year = 20032005 | title =Aspect-Oriented AspectJSoftware inDevelopment Action:with PracticalUse Aspect-OrientedCases Programming|publisher=Addison-Wesley | isbn = 978-10-930110321-9326888-94 | urlauthor2-access link=Pan-Wei registration | url = https://archive.org/details/aspectjinactionp00ladd Ng}}

* {{cite book | first = Ivar | last = Jacobson | authorlink = Ivar Jacobson |author2=Pan-Wei Ng | year = 2005 | title = Aspect-Oriented Software Development with Use Cases | isbn = 978-0-321-26888-4| author2-link = Pan-Wei Ng }}

* [http://www.cmsdevelopment.com/en/articles/aosdinphp/ Aspect-oriented Software Development and PHP, Dmitry Sheiko, 2006]

* {{cite book |author1=Siobhán Clarke|author1-link=Siobhán Clarke |author2=Elisa Baniassad |lastauthorampname-list-style=yesamp | year = 2005 | title = Aspect-Oriented Analysis and Design: The Theme Approach |publisher=Addison-Wesley |isbn = 978-0-321-24674-5}}

* {{cite book |author = Raghu Yedduladoddi |date = 2009 | title = Aspect Oriented Software Development: An Approach to Composing UML Design Models |publisher=VDM |isbn = 978-3-639-12084-4}}

* "Adaptive Object-Oriented Programming Using Graph-Based Customization" – Lieberherr, Silva-Lepe, ''et al.'' -– 1994

* {{cite journal|last=Zambrano Polo y La Borda|first=Arturo Federico|title=Addressing aspect interactions in an industrial setting: experiences, problems and solutions|date=5 June 2013|pages=159|doi=10.35537/10915/35861|url=http://sedici.unlp.edu.ar/handle/10915/35861|accessdateaccess-date=30 May 2014|doi-access=free}}

* Wijesuriya, Viraj Brian (2016-08-30) ''[http://www.slideshare.net/tyrantbrian/aspect-oriented-development Aspect Oriented Development, Lecture Notes, University of Colombo School of Computing, Sri Lanka ]'']

* {{ cite book | first = Matthew D. | last = Groves | authorlink author-link= Matthew D. Groves | year = 2013 | title = AOP in .NET |publisher=Manning |isbn = 9781617291142 }}

== External links ==

* [[Eric Bodden]]'s [http://www.sable.mcgill.ca/aop.net/ list of AOP tools] in .netNET framework

* [https://web.archive.org/web/20030821074213/http://aosd.net/conference/ Aspect-Oriented Software Development], annual conference on AOP

* [http://www.eclipse.org/aspectj/doc/released/progguide/index.html AspectJ Programming Guide]

* [https://web.archive.org/web/20141216200424/http://aspectbench.org/ The AspectBench Compiler for AspectJ], another Java implementation

* [http://www.ibm.com/developerworks/views/java/libraryview.jsp?search_by=AOP@work: Series of IBM developerWorks articles on AOP]

* [http{{cite web |last1=Laddad |first1=Ramnivas |date=2002-01-18 |url=https://www.javaworldinfoworld.com/javaworldarticle/jw2073918/i-01want-2002/jwmy-0118aop-aspect--part-1.html |title=I want my AOP!, Part 1 |work=[[JavaWorld]] |access-date=2020-07-20}} A detailed series of articles on basics of aspect-oriented programming and AspectJ]

* [https://web.archive.org/web/20090821185951/http://codefez.com/what-is-aspect-oriented-programming/ What is Aspect-Oriented Programming?], introduction with RemObjects Taco

* [http://www.cis.uab.edu/gray/Research/C-SAW/ Constraint-Specification Aspect Weaver]

* [http://www.devx.com/Java/Article/28422 Aspect- vs. Object-Oriented Programming: Which Technique, When?] {{Webarchive|url=https://web.archive.org/web/20210415064448/http://www.devx.com/Java/Article/28422 |date=15 April 2021}}

* [http://video.google.com/videoplay?docid=8566923311315412414&q=engEDU Gregor Kiczales, Professor of Computer Science, explaining AOP], video 57 min.

* [http://database.ittoolbox.com/documents/academic-articles/what-does-aspectoriented-programming-mean-to-cobol-4570 Aspect Oriented Programming in COBOL] {{Webarchive|url=https://web.archive.org/web/20081217055353/http://database.ittoolbox.com/documents/academic-articles/what-does-aspectoriented-programming-mean-to-cobol-4570 |date=2008-12-17}}

* [http://static.springframework.org/spring/docs/2.0.x/reference/aop.html Aspect-Oriented Programming in Java with Spring Framework]

* [http://www.sharpcrafters.com/aop.net Wiki dedicated to AOP methods on.NET]

Line 306 ⟶ 310:

* [http://java2novice.com/spring/aop-and-aspectj-introduction/ Spring AOP and AspectJ Introduction]

* [http://www.cs.bilkent.edu.tr/~bedir/CS586-AOSD AOSD Graduate Course at Bilkent University]

* [http://www.se-radio.net/podcast/2008-08/episode-106-introduction-aop Introduction to AOP -– Software Engineering Radio Podcast Episode 106]

* [https://web.archive.org/web/20120801133941/http://innoli.com/en/Innoli-EN/OpenSource.html An Objective-C implementation of AOP by Szilveszter Molnar]

* [https://github.com/forensix/MGAOP Aspect-Oriented programming for iOS and OS X by Manuel Gebele]

* [https://community.devexpress.com/blogs/wpf/archive/2013/12/04/devexpress-mvvm-framework-introduction-to-poco-viewmodels.aspx DevExpress MVVM Framework. Introduction to POCO ViewModels]

{{aosd}}

{{Programming paradigms navbox}}

{{Authority control}}