An Aspect Oriented Framework for Flexible Design Pattern-based Development

@inproceedings{Bernardi2013AnAO,
  title={An Aspect Oriented Framework for Flexible Design Pattern-based Development},
  author={Mario Luca Bernardi and Marta Cimitile and Giuseppe A. Di Lucca},
  booktitle={ICSOFT},
  year={2013}
}
The implementation of a Design Pattern (DP) may be affected by some problems due to typical deficiencies of Object Oriented languages that may worsen the modularity of a software system, and thus its comprehensibility, maintainability, and testability. Aspect Oriented Programming allows to implement DPs by its powerful quantification constructs that can handle better modularity and composition, helping to overcome some of the OO design trade-offs in current DP implementations. In Model Driven… 

Figures from this paper

Declarative design pattern-based development using aspect oriented programming
TLDR
An approach to specify and to apply, declaratively, DPs to the classes of the base system and to compose, at run-time, an AOP-based version of the specified DPs is defined.
Reducing Static Dependences Exploiting a Declarative Design Patterns Framework
TLDR
According to this research, code crosscutting can be reduced by the integration of Model Driven Development techniques with Aspect Oriented Programming (AOP) techniques with an approach based on a Domain Specification Language (DSL).

References

SHOWING 1-10 OF 18 REFERENCES
Improving Design Pattern Quality Using Aspect Orientation
  • M. Bernardi, G. D. Lucca
  • Computer Science
    13th IEEE International Workshop on Software Technology and Engineering Practice (STEP'05)
  • 2005
TLDR
An approach to re-implement DPs by AOP is presented in this paper: some different AOP re-IMplementations of DPs in existing systems from real world have been performed to improve DPs quality.
Pattern language for the design of aspect languages and aspect composition frameworks
  • U. Zdun
  • Computer Science
    IEE Proc. Softw.
  • 2004
TLDR
A pattern language is presented in the paper for tracing and manipulating software structures and dependencies, with an explanation of different, existing aspect composition frameworks as sequences through this pattern language.
A metamodeling approach to pattern specification
TLDR
PMF provides a pattern specification language called Epattern, which is capable of precisely specifying patterns in MOF-compliant metamodels and contains features to manage the complexity of specifying patterns and simplify their application and detection in user models.
A Transformational Process-Based Formal Approach to Object-Oriented Design
TLDR
This paper provides an implementation in Prolog that allows the object model design of the example by the application of some transformations in a structured semi-automated manner and believes the method scales up to larger systems as it allows architectural object-oriented transformations to be also deened.
A model-driven framework for representing and applying design patterns
TLDR
This paper proposes to represent a design pattern using a triple (MP, MS, T) where MP is a model of the design problem solved by the pattern, MS is a models of the solution proposed by it, and T is a rule-based representation of the transformations embodied in the application of the pattern.
Model Driven Development of Process-centric Web Applications
TLDR
This paper proposes the integration of three MDE metamodels used to represent the structure of information, service and presentation layers of a WA with the meetamodel of Declare, a declarative language for business process rapresentation, to combine an efficient roundtrip engineering support with the advantages of an MDE approach.
On Aspect-Oriented Technology and Object-Oriented Design Patterns
TLDR
This paper illustrates its own approach by presenting an aspect-oriented implementation of the GoF Strategy pattern, and claims implementation is not sufficient: aspect-orientation also needs to be considered at the design level in the description of design patterns.
Design pattern implementation in Java and aspectJ
TLDR
AspectJ implementations of the GoF design patterns show modularity improvements in 17 of 23 cases, manifested in terms of better code locality, reusability, composability, and (un)pluggability.
Replacing Object-Oriented Design Patterns with Intrinsic Aspect-Oriented Design Patterns
  • Pavol Baca, V. Vranic
  • Computer Science
    2011 Second Eastern European Regional Conference on the Engineering of Computer Based Systems
  • 2011
TLDR
How two other intrinsic aspect-oriented patterns can be used as an alternative to object- oriented patterns are proposed: Worker Object Creation can be successfully used instead of Proxy, while Cuckoo's Egg can replace Singleton, Abstract Factory, and Flyweight.
Design patterns: elements of reuseable object-oriented software
The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out
...
...