Aspect-oriented software development

From Wikipedia, the free encyclopedia

Aspect-Oriented Software Development (AOSD) [1] is a software engineering paradigm that focuses on the modularisation of crosscutting concerns throughout the software development lifecycle. AOSD complements other software development paradigms such as Object-Oriented Programming, Component-Based Software Development, Service-Oriented Architectures or Model-Based Software Development by providing explicit abstractions that capture requirements, use cases or features that can not be properly modularized using the primary decomposition mechanisms of the language.

AOSD refers to a wide range of software development techniques that support the modularisation of crosscutting concerns in a software system, from requirement engineering to analysis and design, architecture, programming and implementation techniques, testing and software maintenance techniques.

Contents

[edit] Aspect-Orientation in the Software Development Lifecycle

[edit] Aspect-Oriented Requirement Engineering

Aspect-Oriented Requirement Engineering (also referred to as Early Aspects) focuses on the identification, specification and representation of crosscutting properties at the requirement level. Examples of such properties include security, mobility, availability and real-time constraints. Crosscutting properties are requirements, use-cases or features that have a broadly-scoped effect on other requirements or architectural components.

Aspect oriented requirements engineering approaches are techniques that explicitly recognise the importance of clearly addressing both functional and non-functional crosscutting concerns in addition to non-crosscutting ones. Therefore, these approaches focus on systematically and modularly treating, reasoning about, composing and subsequently tracing crosscutting functional and non-functional concerns via suitable abstraction, representation and composition mechanisms tailored to the requirements engineering domain.

Specific areas of excellence under the denominator of AO Requirements Analysis are:

  • the aspect oriented requirements process itself,
  • the aspect oriented requirements notations,
  • aspect oriented requirements tool support,
  • adoption and integration of aspect oriented requirements engineering, and
  • assessment/evaluation of aspect oriented requirements.

[edit] Aspect-Oriented System Architecture

Aspect-Oriented System Architecture focuses on the localization and specification of crosscutting concerns in architectural designs. Crosscutting concerns that appear at the architectural level cannot be modularized by redefining the software architecture using conventional architectural abstractions. Aspect-Oriented System Architecture languages propose explicit mechanisms to identify, specify and evaluate aspects at the architecture design level.

Aspect oriented architecture starts from the observation that we need to identify, specify and evaluate aspects explicitly at the architecture design level. Aspectual architecture approaches describe steps for identifying architectural aspects. This information is used to redesign a given architecture in which the architectural aspects are made explicit. In this regard, specific areas of excellence are:

  • the aspect oriented architecture process itself,
  • the aspect oriented architecture notations,
  • aspect oriented architecture tool support,
  • adoption and integration of aspect oriented architecture, and
  • assessment/evaluation of aspect oriented architecture.

[edit] Aspect-Oriented Modeling and Design

Aspect oriented design has the same objectives as any software design activity, i.e. characterising and specifying the behaviour and structure of the software system. Its unique contribution to software design lies in the fact that concerns that are necessarily scattered and tangled in more traditional approaches can be modularized. Typically, such an approach includes both a process and a language. The process takes as input requirements and produces a design model. The produced design model represents separate concerns and their relationships. The language provides constructs that can describe the elements to be represented in the design and the relationships that can exist between those elements. In particular, constructs are provided to support concern modularization and the specification of concern composition, with consideration for conflicts. Beyond that, the design of each individual modularized concern compares to standard software design.

Here, specific areas of excellence areas are:

  • the aspect oriented design process itself,
  • the aspect oriented design notations,
  • aspect oriented design tool support,
  • adoption and integration of aspect oriented design, and
  • assessment/evaluation of aspect oriented design.

[edit] Aspect-Oriented Programming

Aspect-Oriented Programming includes programming techniques and tools that support the modularisation of crosscutting concerns at the level of the source code

Just like any other programming language, an aspect oriented language typically consists of two parts: a language specification and an implementation. Hence, there are two corresponding areas of excellence: support for language developers and support for application developers.

Support for application developers

An aspect oriented language supports the implementation of concerns and how to compose those independently implemented concerns. While the specification of such a language is the primary manual for application developers, it provides obviously no guarantee that the application developer will produce high-quality aspect-oriented programs. Specific areas of excellence:

  • the crucial concepts of aspect oriented programming languages,
  • programming in aspect oriented languages, and
  • aspect oriented programming environments.

Support for language developers

Excellence on support for constructing aspect languages includes the following areas:

  • constructing languages for specific domains and/or platforms, and
  • transferring implementation principles of aspect oriented execution environments, including
    • interpreters,
    • compilers, and
    • virtual machines.

[edit] Formal Method Support for Aspect-Orientation

Formal methods can be used both to define aspects semantically and to analyze and verify aspect oriented systems. Aspect-oriented programming extends programming notations with aspect modules that isolate the declaration of when the aspect should be applied (join points) and what actions should be taken when it is reached (advice). Expertise in formal semantic definitions of aspect constructs is useful for language designers to provide a deep understanding of the differences among constructs. Aspects potentially can harm the reliability of a system to which they are woven, and could invalidate essential properties that already were true of the system without the aspect. It is also necessary to show that they actually do add intended crosscutting properties to the system. Hence, numerous questions of correctness and verification are raised by aspect languages. Among the kinds of expertise are:

  • specially designed testing techniques to provide coverage for aspects,
  • program slicing and code analysis approaches to identify interactions among aspects and between aspects and underlying systems,
  • software model checking techniques specialized for aspects, and
  • inductive techniques to verify aspect oriented systems.

Each of the above approaches can be used to

  • specify and analyze individual aspects relative to an existing system,
  • define conditions for composing multiple aspects correctly, and
  • detect and resolve potential interferences among aspects.

Although some approaches are already used in aspect languages, others are still subject of research and are not ready for routine industrial application. Nevertheless, awareness of these issues is essential for language designers, and for effective use of aspects, especially in safety-critical contexts.

[edit] Aspect Mining and Refactoring

[edit] Testing of Aspect-Oriented Programs

[edit] Maintenance of Aspect-Oriented Programs and Refactoring

[edit] Applications of Aspect-Oriented Software Development

[edit] Aspect-Oriented Middleware

Middleware and AOSD strongly complement each other. In general, areas of excellence consist of

  • support for the application developer, which includes
    • the crucial concepts of aspect supporting middleware,
    • aspect oriented software development using a specific middleware, involving the aspect programming model, aspect deployment model, platform infrastructure, and services of the middleware, and
  • product line engineering (methods, architectures, techniques) in distributed and ambient computing, and
  • support for the middleware developer with respect to
    • host-infrastructure middleware,
    • distribution middleware,
    • common middleware services, and
    • domain-specific middleware services.

[edit] Adoption of Aspect-Oriented Software Development

  • IBM Websphere Application Server (WAS) is a java application server that supports Java EE and Web Services. Websphere is distributed according to editions that support different features. Websphere uses AspectJ internally to isolate features of the different editions.
  • JBoss Application Server (JBoss AS) is a free, open-source java application server that supports Java EE. The core of JBoss AS is integrated with the JBoss AOP aspect-oriented programming language. The application server uses JBoss AOP to deploy services such as security and transaction management.
  • Oracle TopLink is a Java object-to-relational persistence framework that is integrated with the Spring Application Server. TopLink achieves high levels of persistence transparency using Spring AOP.
  • SAP
  • Sun Microsystems uses AspectJ to streamline mobile application development for the Java ME platform. Aspects are used to simplify the development of mobile applications for deployment to different operator decks and different mobile gaming community interfaces.
  • Siemens Soarian is a health information management system that supports seamless access to patient medical records and the definition of workflows for health provider organizations. Soarian uses AspectJ to integrate crosscutting features such as tracing, auditing and performance monitoring in the context of an agile development process.
  • Motorola wi4 is a cellular infrastructure system that provides support for the WiMAX wireless broadband standard. The wi4 control software is developed using an aspect-oriented extension to the UML 2.0 standard called WEAVR. WEAVR is used during the development for debugging and testing purposes.
  • ASML is a provider of lithography systems for the semiconductor industry. ASML uses an aspect-oriented extension to C called Mirjam to modularize tracing and profiling concerns.
  • Glassbox is a troubleshooting agent for Java applications that automatically diagnoses common problems. The Glassbox inspector monitors the activity of the Java virtual machine using AspectJ.

[edit] References

  1. ^ Filman, Robert E.; Tzilla Elrad, Siobhàn Clarke, and Mehmet Aksit. Aspect-Oriented Software Development. ISBN 0-321-21976-7. 

[edit] External links