xAFIT provides a runtime environment for AF-RDL scripts Instantiation process inputs

1. Assisting Aspect-Oriented Framework InstantiationTowards Modeling, Transformation and Tool Support Marcilio Mendonca, Paulo Alencar, Toacy Oliveira, Donald Cowan {marcilio, palencar, dcowan}@csg.uwaterloo.ca, toacy@inf.pucrs.br OOPSLA 2005 Poster Session An approach to aspect-oriented framework instantiation based on modeling, transformation and tool support. AO Frameworks are Moving to Mainstream But Instantiation is still Complex Modeling AO Frameworks Representing Instantiation Steps Supporting Automation Model Transformation can be Helpful • Framework Instantiation: semi-complete  complete model transformation • Model transformation is a trend (e.g. Model-Driven Architecture) • In MDA, models can be serialized to XML (e.g. XMI specification) • Our approach uses XQuery to transform serialized models (e.g. XMI) AF-UML extends UML to support Frameworks and Aspect-Oriented concepts (e.g. aspects, variability) – Aspect Diagram Lack of Documentation Approaches for AOFs • Current Modeling Languages are either: • UML Profiles for Aspect-Oriented Systems (e.g. aSideUML, Theme/UML) • UML Profiles for Object-Oriented Frameworks (e.g. UML-F, UML-FI) There is no standard way to represent instantiation steps across AOF projects • Every new framework project may also imply new strategies and approaches for application generation • Instantiation steps may be hidden and hard to maintain (e.g. hardcoded in application generators) Automation of AOF instantiation is needed • Lack of automated tools supporting aspect-oriented concepts • Aspects are not considered as first-class citizens • Traditional OO abstractions fail to modularize crosscutting concerns • Yet, such concerns may expose hotspots (e.g. persistence) • Hotspots of the same concern are not localized, hence are hard to identify and instantiate • Aspects allow for a clean separation of concerns in AO Frameworks • xAFIT provides a runtime environment for AF-RDL scripts • Instantiation process inputs • AF-RDL scripts • Framework model in AF-UML • Application developer inputs • Instantiation process output • Application model in AF-UML (without annotations) • The approach takes advantage of XQuery to perform transformations over serialized models (e.g. XMI) • Our process language (AF-RDL) allows framework developers to represent instantiation steps explicitly • Sample Instantiation Unit • IUNIT myInstantiationUnit • ITASK myInstantiationTask • … • call R1(… ); • … • ITASK_END • ITASK R1(…) • call_pattern P1(…); • ITASK_END • … • IUNIT_END • Main Instantiation Commands • extend_class(superclass, subclass) • extend_class(superclass) • extend_method(superclass, subclass, method) • extend_aspect(superaspect, subaspect) • extend_aspect_method(superaspect, subaspect, method) • extend_aspect_pointcut(superaspect, subaspect, pointcut ) • Types: Class, Aspect, Method, Attribute, Pointcut, Boolean, Number, String, Package Sample Pattern Library PATTERN_LIBRARY myPatternLib PATTERN Observer(…) … END_PATTERN PATTERN AbstractFactory(…) … END_PATTERN … END_PATTERN_LIBRARY Our Approach to AO Framework Instantiation Mandatory Class and Method Extension Select One Subclass AF-UML = UML + Aspect + Frameworks xAFIT Architecture Overview Graphical Interface xAFIT System Facade AF-RDL = Instantiation Commands Mandatory Aspect, Method, and Pointcut Extension xAFIT = AF-RDL → xQuery Transformation Engine Parser Model Handler • Components of Our Approach: • Modeling Language: AF-UML • Process Language: AF-RDL • CASE Tool (transformation): xAFIT XQuery Engine AF-RDL Parser XMI Handler AOF Instantiation – A Case Study: CSGDrawing Editor (An Aspect-Oriented Drawing Editor Framework) Next Steps • Define a graphical model to represent instantiation steps (Instantiation Model). Link its elements to AF-UML. • Integrate feature models to our approach • Refine the AF-UML modeling language List of Variabilities AF-UML Framework Aspect Diagram AF-RDL Script (Instantiation Steps) AF-UML Application Aspect Diagram(Without Annotations) Variability Extension Mechanism IUnit CSGDEFramework // Instantiation Unit ITask Main // Instantiation Task myShape : CLASS; myDrawer: CLASS; myObserverAsp : ASPECT; loop myShape = extend_class(“Figure”, ?); extend_method(“Figure”, myShape, “draw”); extend_method(“Figure”, myShape,”enlarge”); extend_method(“Figure”, myShape,”shrink”); loop_end myDrawer = extend_class(“Drawer”, ?); extend_method(“Drawer”, myDrawer, “createFigures”); extend_method(“Drawer”, myDrawer, “draw”); myObserverAsp = extend_aspect(“DEObserverAspect”,?); extend_aspect_method(“DEObserverPattern”, myObserverAsp, “updateObserver”); extend_aspect_pointcut(“DEObserverPattern”, myObserverAsp, “Subject.notifyObservers”); ITask_END IUnit_END The shapes (e.g., Circle, Square) Class Extension The drawing, enlarging and shrinking algorithms for the shapes Method Extension The set of shapes that will be part of the drawing Method Extension The drawing algorithm Method Extension The Figure objects that should notify the Display about state changes Pointcut Extension The Display response algorithm to Figure resizing Aspect Method Extension Application Model Serialized (e.g. XMI) Variability Model (e.g. Feature Model) Framework Model Serialized (e.g. XMI) XQueryTransformation