scispace - formally typeset
Open AccessProceedings ArticleDOI

Composition patterns: an approach to designing reusable aspects

Reads0
Chats0
TLDR
This paper demonstrates how composition patterns map to one programming model that provides a solution for separation of cross-cutting requirements in code—aspect-oriented programming, and serves to illustrate that separation of aspects may be maintained throughout the software lifecycle.
Abstract
Requirements such as distribution or tracing have an impact on multiple classes in a system. They are cross-cutting requirements, or aspects. Their support is, by necessity, scattered across those multiple classes. A look at an individual class may also show support for cross-cutting requirements tangled up with the core responsibilities of that class. Scattering and tangling make object-oriented software difficult to understand, extend and reuse. Though design is an important activity within the software lifecycle with well-documented benefits, those benefits are reduced when cross-cutting requirements are present. This paper presents a means to mitigate these problems by separating the design of cross-cutting requirements into composition patterns. Composition patterns require extensions to the UML, and are based on a combination of the subject-oriented model for composing separate, overlapping designs, and UML templates. This paper also demonstrates how composition patterns map to one programming model that provides a solution for separation of cross-cutting requirements in code—aspect-oriented programming. This mapping serves to illustrate that separation of aspects may be maintained throughout the software lifecycle.

read more

Citations
More filters
Proceedings ArticleDOI

Modularisation and composition of aspectual requirements

TL;DR: It is argued that such modularisation makes it possible to establish early trade-offs between aspectual requirements hence providing support for negotiation and subsequent decision-making among stakeholders.
Proceedings ArticleDOI

Theme: an approach for aspect-oriented analysis and design

TL;DR: The Theme approach is devised for viewing the relationships between behaviours in a requirements document, identifying and isolating aspects in the requirements, and modelling those aspects using a design language.
Book

Aspect-Oriented Analysis and Design: The Theme Approach

TL;DR: The Object-Oriented Way is presented as a guide to how to design and implement theme-based content management systems for the 21st Century.
Proceedings ArticleDOI

Early aspects: a model for aspect-oriented requirements engineering

TL;DR: In this paper, the authors propose a general model for aspect oriented requirements engineering (AORE), which supports separation of crosscutting functional and non-functional properties at the requirements level, and argue that early separation of such crosscutting properties supports effective determination of their mapping and influence on artefacts at later development stages.
Proceedings ArticleDOI

A UML-based aspect-oriented design notation for AspectJ

TL;DR: A design notation is presented based on the UML that provides representations for all language constructs in AspectJ and specifies an UML implementation of Aspect J's weaving mechanism, which carries over the advantages of aspect-orientation to the design level.
References
More filters
Book

Design Patterns: Elements of Reusable Object-Oriented Software

TL;DR: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns, which most experienced OOP designers will find out they've known about patterns all along.
Journal ArticleDOI

Aspect-oriented programming

TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Book ChapterDOI

Aspect-Oriented Programming

TL;DR: An analysis of why certain design decisions have been so difficult to clearly capture in actual code is presented, and the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects.
Proceedings ArticleDOI

Aspect-Oriented Programming

Book

Objects, Components, and Frameworks With Uml: The Catalysis Approach

TL;DR: This chapter discusses Model Frameworks as Templates, a model framework for component-based development, and its applications in architecture, management, and user experience.