Aspect-oriented programming (
AOP) is a
programming paradigmA programming paradigm is a fundamental style of computer programming....
that increases
modularityModular programming is a software design technique that increases the extent to which software is composed from separate parts, called modules. Conceptually, modules represent a separation of concerns, and improve maintainability by enforcing logical boundaries between components. Modules are...
by allowing the
separation ofIn computer science, separation of concerns is the process of separating a computer program into distinct features that overlap in functionality as little as possible. A concern is any piece of interest or focus in a program. Typically, concerns are synonymous with features or behaviors...
cross-cutting concernIn computer science, cross-cutting concerns are aspects of a program which affect other concerns.These concerns often cannot be cleanly decomposed from the rest of the system in both the design and implementation, and result in either scattering or tangling of the program, or both.For instance, if...
s, forming a basis for
aspect-oriented software developmentAspect-oriented software development is an emerging software development technology that seeks new modularizations of software systems. AOSD allows multiple concerns to be expressed separately and automatically unified into working systems....
.
Overview
Aspect-oriented programming (
AOP) is a
programming paradigmA programming paradigm is a fundamental style of computer programming....
that increases
modularityModular programming is a software design technique that increases the extent to which software is composed from separate parts, called modules. Conceptually, modules represent a separation of concerns, and improve maintainability by enforcing logical boundaries between components. Modules are...
by enabling improved
separation of concernsIn computer science, separation of concerns is the process of separating a computer program into distinct features that overlap in functionality as little as possible. A concern is any piece of interest or focus in a program. Typically, concerns are synonymous with features or behaviors...
. This entails breaking down a program into distinct parts (so-called
concerns, cohesive areas of functionality). All programming paradigms support some level of grouping and
encapsulation- Chemistry :* Molecular encapsulation, in chemistry, the confinement of an individual molecule within a larger molecule* Capsule , in pharmacy, the enclosure of a medicine within a relatively stable shell for administration...
of concerns into separate, independent entities by providing abstractions (e.g. procedures, modules, classes, methods) that can be used to implement, abstract and compose these concerns. But some concerns defy these forms of implementation and are called
crosscutting concerns because they "cut across" multiple abstractions in a program.
Logging is a common example of a crosscutting concern because a logging strategy necessarily affects every single logged part of the system. Logging thereby
crosscuts all logged classes and methods.
All AOP implementations have some crosscutting 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 intercept express a limited form of crosscutting, without much support for type-safety or debugging.
AspectJAspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
has a number of such expressions and encapsulates them in a special class, an
aspectIn computer science, an aspect is a part of a program that cross-cuts its core concerns, therefore violating its separation of concerns. It is a feature linked to many parts of a program, but which is not necessarily the primary function of the program...
. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying
adviceIn aspect and functional programming, advice describes a class of functions which modify other functions when the latter are run; it is a certain function, method or procedure that is to be applied at a given join point of a program....
(additional behavior) at various
join pointIn computer science, a join point is a point in the control flow of a program. In aspect-oriented programming a set of join points is described as a pointcut...
s (points in a program) specified in a quantification or query called a
pointcutIn aspect-oriented computer programming, a pointcut is a set of join points. Whenever the program execution reaches one of the join points described in the pointcut, a piece of code associated with the pointcut is executed. This allows a programmer to describe where and when additional code...
(that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, like adding members or parents.
History
AOP as such has a number of antecedents: the
Visitor Design PatternIn object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure upon which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...
,
CLOS MOP, and others.
AspectJAspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
(perhaps the most popular general-purpose AOP package) was created by
Gregor KiczalesGregor Kiczales is a professor of computer science at the University of British Columbia in Canada. His best known work is on Aspect-oriented programming and the AspectJ extension for Java at Xerox PARC. He has also contributed to the design of the Common Lisp Object System, and is the author of...
and colleagues at
Xerox PARCPARC , formerly Xerox PARC, is a research and development company in Palo Alto, California with a distinguished reputation for its contributions to information technology....
and made available in 2001.
IBM's research team emphasized the continuity of the practice of modularizing concerns with past programming practice, and offered the more powerful (but less usable) Hyper/J and Concern Manipulation Environment, which have not seen wide usage. EmacsLisp changelog added AOP related code in version
19.28. The examples in this article use
AspectJAspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
as it is the most widely known AOP languages.
Motivation and basic concepts
Typically, aspects are
scattered or
tangled as code, making it harder to understand and maintain. It is scattered by virtue of the function (e.g. logging) being spread over a number of unrelated functions that might use
its function, possibly in entirely unrelated systems, different source languages, etc. That means to change logging can require modifying all affected modules. Aspects are tangled not only with the mainline function of the systems in which they are expressed but also with each other. That means changing one concern 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:
void transfer(Account fromAcc, Account toAcc, int amount) {
if (fromAcc.getBalance < amount) {
throw new InsufficientFundsException;
}
fromAcc.withdraw(amount);
toAcc.deposit(amount);
}
However, this transfer method overlooks certain considerations that would be necessary for a deployed application. It requires security checks to verify that the current user has the authorization to perform this operation. The operation should be in a
database transactionA database transaction comprises a unit of work performed within a database management system against a database, and treated in a coherent and reliable way independent of other transactions...
in order to prevent accidental data loss. For diagnostics, the operation should be logged to the system log. And so on. A simplified version with all those new concerns would look somewhat like this:
void transfer(Account fromAccount, Account toAccount, int amount) throws Exception {
if (!getCurrentUser.canPerform(OP_TRANSFER)) {
throw new SecurityException;
}
if (amount < 0) {
throw new NegativeTransferException;
}
if (fromAccount.getBalance < amount) {
throw new InsufficientFundsException;
}
Transaction tx = database.newTransaction;
try {
fromAccount.withdraw(amount);
toAccount.deposit(amount);
tx.commit;
systemLog.logOperation(OP_TRANSFER, fromAccount, toAccount, amount);
}
catch(Exception e) {
tx.rollback;
throw e;
}
}
In the previous example other interests have become
tangled with the basic functionality (sometimes called the
business logic concern). Transactions, security, and logging all exemplify
cross-cutting concerns.
Also consider what happens 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.
Therefore, we find that the cross-cutting concerns do not get properly encapsulated in their own modules. This increases the system complexity and makes evolution considerably more difficult.
AOP attempts 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
pointcutIn aspect-oriented computer programming, a pointcut is a set of join points. Whenever the program execution reaches one of the join points described in the pointcut, a piece of code associated with the pointcut is executed. This allows a programmer to describe where and when additional code...
defines the times (
join pointIn computer science, a join point is a point in the control flow of a program. In aspect-oriented programming a set of join points is described as a pointcut...
s) that a bank account can be accessed, 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.
AOP can be thought of as a debugging tool or as a user level tool. Advice should be reserved for the cases where you cannot get the function changed (user level)
(from Emacs Documentation) 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
In computer science, a join point is a point in the control flow of a program. In aspect-oriented programming a set of join points is described as a pointcut...
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 in order for an aspect to be stable across such changes. Many AOP implementations support method executions and field references as join points.
- A way to specify (or quantify) join points, called pointcut
In aspect-oriented computer programming, a pointcut is a set of join points. Whenever the program execution reaches one of the join points described in the pointcut, a piece of code associated with the pointcut is executed. This allows a programmer to describe where and when additional code...
s. Pointcuts determine whether a given join point matches. Most useful pointcut languages use a syntax like the base language (e.g., Java signatures are used for AspectJAspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
) and allow reuse through naming and combination.
- A means of specifying code to run at a join point. In AspectJ
AspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
, this is called adviceIn aspect and functional programming, advice describes a class of functions which modify other functions when the latter are run; it is a certain function, method or procedure that is to be applied at a given join point of a program....
, and can run 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
- The join points in AspectJ
AspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
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.
- 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 to take as input a Java-like signature. One such pointcut looks like this:
execution(* set*(*))
- This pointcut matches a method-execution join point, if the method name starts with "
set" and there is exactly one argument of any type.
"Dynamic" PCDs check runtime types and bind variables. For example
this(Point)
- This pointcut matches when the currently-executing object is an instance of class
Point. 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
within(com.company.*)
- This pointcut matches any join point in any type in the
com.company package. The * 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
pointcut set : execution(* set*(*) ) && this(Point) && within(com.company.*);
- This pointcut matches a method-execution join point, if the method name starts with "
set" and this is an instance of type Point in the com.company package. It can be referred to using the name "set".
- Advice specifies to run (before, after, or around) at a join point (specified with a pointcut) certain code (specified like code in a method). Advice is invoked automatically by the AOP runtime when the pointcut matches the join point. Here is an example of this:
after : set {
Display.update;
}
- This is effectively saying, "if the
set pointcut matches the join point, run the code Display.update after the join point completes."
Other potential join point models
There are other kinds of JPMs. All advice languages can be defined in terms of their JPM. For example a hypothetical aspect language for
UMLUnified Modeling Language is a standardized general-purpose modeling language in the field of software engineering. The standard is managed, and was created by, the Object Management Group....
may have the following JPM:
- Join points are all model elements.
- Pointcuts are some 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 crosscutting concerns affecting the structure of modules. Also known as
open classOpen class may refer to:*Open Class , an event classification*Open class , a word class readily accepting new items*Open class , a standardbred racing event open to all comers...
es, 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 the crosscutting display-update concern were instead implemented using visitors, an inter-type declaration using the
visitor patternIn object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure upon which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...
would look like this in AspectJ:
aspect DisplayUpdate {
void Point.acceptVisitor(Visitor v) {
v.visit(this);
}
// other crosscutting code...
}
- This code snippet adds the
acceptVisitor method to the Point class.
It is a requirement that any structural additions 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
There are two different ways AOP programs can affect other programs, depending on the underlying languages and environments: (1) a combined program is produced, valid in the original language and indistinguishable from an ordinary program to the ultimate interpreter; and (2) 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 process that has come to be known as
weaving, which is special case of
program transformationA program transformation is any operation that takes a program and generates another program. It is often important that the derived program be semantically equivalent to the original, relative to a particular formal semantics...
. The same AOP language can be implemented through a variety of weaving techniques, 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 which method of combination is used.
Source-level weaving can be implemented using preprocessors (as C++ was implemented originally in
CFrontCfront was the original compiler for C++ from around 1983, which converted C++ to C; developed by Bjarne Stroustrup. The preprocessor did not understand all of the language and much of the code was written via translations...
) 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.
AspectJAspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
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
AspectWerkzAspectWerkz is a dynamic, lightweight and high-performance AOP/AOSD framework for Java. It has been merged with the AspectJ project, which supports AspectWerkz functionality since AspectJ 5....
in 2005.
Any solution that combines programs at runtime has to 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 are unable to process woven code because they expect code produced by Javac rather than all supported bytecode forms (see also "Problems", below).
Another alternative is deploy-time weaving. 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 (debuggers, 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
IBMInternational Business Machines Corporation, abbreviated IBM, is a multinational computer technology and IT consulting corporation headquartered in Armonk, Town of North Castle, New York, United States. The company is one of the few information technology companies with a continuous history dating...
's
WebSphereIBM WebSphere refers to a brand of software products, although the term also popularly refers to one specific product: IBM WebSphere Application Server . WebSphere is designed to set up, operate and integrate electronic business applications across multiple computing platforms, using Java-based Web...
.
Terminology
The following are some standard terminology used in Aspect-oriented programming:
- Cross-cutting concerns: Even though most classes in an OO 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. Even though the primary functionality of each class is very different, the code needed to perform the secondary functionality is often identical.
- Advice: 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.
- Pointcut: This is the term given 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: The combination of the pointcut and the advice is termed an aspect. In the example below, we add a logging aspect to our application by defining a pointcut and giving the correct advice.
Comparison to other programming paradigms
Aspects emerged out of
object-oriented programmingObject-oriented programming is a programming paradigm that uses "objects" – data structures consisting of datafields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as information hiding, data...
and computational reflection. AOP languages have functionality similar to, but more restricted than
metaobject protocolsIn computer science, a metaobject or meta-object is any entity that manipulates, creates, describes, or implements other objects. The object that the metaobject is about is called the base object...
. Aspects relate closely to programming concepts like
subjectsIn computer programming within the subject-oriented programming paradigm, subjects are a way to separate concerns. For example, in a Shape class with two methods Draw and Move, each method would be considered a subject.- External links :*...
,
mixinIn object-oriented programming languages, a mixin is a class that provides a certain functionality to be inherited by a subclass, while not meant for instantiation . Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality...
s, and
delegationIn object-oriented programming there are two related notions of delegation.* Most commonly, it refers to a programming language feature making use of the method lookup rules for dispatching so-called self-calls as defined by Lieberman in his 1986 paper "Using Prototypical Objects to Implement...
. Other ways to use aspect-oriented programming paradigms include Composition Filters and the hyperslices approach. Since at least the 1970s, developers have been using forms of interception and dispatch-patching that are similar to some of the implementation techniques for AOP, but these never had the semantics that the crosscutting specifications were written in one place.
Designers have considered alternative ways to achieve separation of code, such as C#'s partial types, but such approaches lack a quantification mechanism that allows reaching several join points of the code with one declarative statement.
Adoption issues
Programmers need to be able to read code and understand what's happening in order to prevent errors. Even with proper education, understanding crosscutting concerns can be difficult without proper support for visualizing both static structure and the dynamic flow of a program. Visualizing crosscutting concerns is just beginning to be supported in IDEs, as is support for aspect code assist and refactoring.
Given the power of AOP, if a programmer makes a logical mistake in expressing crosscutting, it can lead to widespread program failure. Conversely, another programmer may change the join points in a program – e.g., by renaming or moving methods – in ways that were not anticipated by the aspect writer, with
unintended consequenceUnintended consequences are outcomes that are not the results originally intended by a particular action. The unintended results may be foreseen or unforeseen, but they should be the logical or likely results of the action...
s. One advantage of modularizing crosscutting concerns is enabling one programmer to affect the entire system easily; as a result, such problems present as a conflict over responsibility between two or more developers for a given failure. However, the solution for these problems can be much easier in the presence of AOP, since only the aspect need be changed, whereas the corresponding problems without AOP can be much more spread out.
Implementations
AOP has been implemented (in either the language itself or as external library) for the following
programming languageA programming language is an artificial language designed to express computations that can be performed by a machine, particularly a computer. Programming languages can be used to create programs that control the behavior of a machine, to express algorithms precisely, or as a mode of human...
s:
- AutoHotkey
AutoHotkey is a free, open source macro-creation and automation software utility which allows users to automate repetitive tasks. Any application user interface can be modified by AutoHotkey...
- .NET Framework
The Microsoft .NET Framework is a software framework that can be installed on computers running Microsoft Windows operating systems. It includes a large library of coded solutions to common programming problems and a virtual machine that manages the execution of programs written specifically for...
languages (C# / VB.NET)
- C
C is a general-purpose computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system....
/ C++C++ is a statically typed, free-form, multi-paradigm, compiled, general-purpose programming language. It is regarded as a middle-level language, as it comprises a combination of both high-level and low-level language features...
- Cobol
COBOL is one of the oldest programming languages. Its name is an acronym for COmmon Business-Oriented Language, defining its primary domain in business, finance, and administrative systems for companies and governments....
- Cocoa
- ColdFusion
ColdFusion is a commercial rapid application development platform invented by Jeremy and JJ Allaire in 1995. Originally designed to make it easier to connect simple HTML pages to a database, by 2.0 had become a full platform that included an IDE in addition to a full Scripting Language...
- Common Lisp
Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994 , . Developed to standardize the divergent variants of Lisp which predated it, it is not an implementation but rather a language specification...
- Delphi
Embarcadero Delphi, formerly CodeGear Delphi and Borland Delphi, is a software development environment for Microsoft Windows applications originally developed by Borland and now owned and developed by Embarcadero Technologies...
- Delphi Prism
Delphi Prism is a rapid application development tool for the Microsoft .NET Framework and Mono, developed by Embarcadero Technologies and RemObjects Software....
- e
e is a hardware verification language which is tailored for implementing efficient and high quality testbench.Main features of e are:
- Aspect-oriented programming language
...
(IEEE 1647)
- Haskell
Haskell is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing. It is named after logician Haskell Curry.- History :...
- Java
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities...
- AspectJ
AspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely-used de-facto standard for AOP by emphasizing simplicity and usability...
- JavaScript
JavaScript is an object-oriented scripting language used to enable programmatic access to objects within both the client application and other applications. It is primarily used in the form of client-side JavaScript, implemented as an integrated component of the web browser, allowing the...
- Emacs Lisp
Emacs Lisp is a dialect of the Lisp programming language used by the GNU Emacs and XEmacs text editors . It is used for implementing most of the editing functionality built into Emacs, the remainder being written in C...
- Lua
In computing, Lua is a lightweight, reflective, imperative and functional programming language, designed as a scripting language with extensible semantics as a primary goal. The name comes from the Portuguese word lua meaning "moon"...
- make
- ML
- Perl
Perl is a high-level, general-purpose, interpreted, dynamic programming language. Perl was originally developed by Larry Wall, a linguist working as a systems administrator for NASA, in 1987, as a general-purpose Unix scripting language to make report processing easier. Since then, it has undergone...
- PHP
PHP, or PHP: Hypertext Preprocessor, is a widely used, general-purpose scripting language that was originally designed for web development, to produce dynamic web pages. It can be embedded into HTML and generally runs on a web server, which needs to be configured to process PHP code and create web...
- Prolog
Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics.Prolog has its roots in formal logic, and unlike many other programming languages, Prolog is declarative: The program logic is expressed in terms of relations, represented as...
- Python
Python is a general-purpose high-level programming language. Its design philosophy emphasizes code readability. Python claims to "[combine] remarkable power with very clear syntax", and its standard library is large and comprehensive...
- Ruby
Ruby is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Ruby originated in Japan during the mid-1990s and was initially developed and designed by Yukihiro "Matz" Matsumoto...
- Squeak
The Squeak programming language is a Smalltalk implementation, derived directly from Smalltalk-80 by a group at Apple Computer that included some of the original Smalltalk-80 developers. Its development was continued by the same group at Walt Disney Imagineering, where it was intended for use in...
SmalltalkSmalltalk is an object-oriented, dynamically typed, reflective programming language. Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human–computer symbiosis." It was designed and created in part for educational use, more so for constructionist...
- UML 2.0
- XML
XML is a set of rules for encoding documents electronically. It is defined in the produced by the W3C and several other related specifications; all are fee-free open standards....
See also
- Aspect-Oriented Software Development
Aspect-oriented software development is an emerging software development technology that seeks new modularizations of software systems. AOSD allows multiple concerns to be expressed separately and automatically unified into working systems....
- Programming paradigm
A programming paradigm is a fundamental style of computer programming....
s
- Stability Model
Stability Model is a method of designing and modelling software. It is an extension of Object Oriented Software Design methodology, like UML, but adds its own set of rules, guidelines, procedures, and heuristics to achieve a more advanced Object Oriented software.The motivation is to achieve a...
- Subject-oriented programming
Subject-Oriented Programming is an object-oriented software paradigm in which the state and behavior of objects are not seen as intrinsic to the objects themselves, but are provided by various subjective perceptions of the objects...
an alternative to Aspect-oriented programming
- Executable UML
Executable UML, often abbreviated to xtUML or xUML , is the evolution of the Shlaer-Mellor method to UML. Executable UML graphically specifies a system using a profile of the UML. The models are testable, and can be compiled into a less abstract programming language to target a specific...
- COMEFROM
In computer programming, COMEFROM is an obscure control flow structure used in some programming languages, primarily as a joke....
- Decorator pattern
In object-oriented programming, the decorator pattern is a design pattern that allows new/additional behaviour to be added to an existing object dynamically.- Introduction :...
- Domain-driven design
Domain-driven design is an approach to the design of software, based on the two premises :#that complex domain designs should be based on a model, and...
Further reading
The paper generally considered to be the authoritative reference for AOP.
External links