WORLD CLASS – through people, technology and dedication

1. Computer Science & Software Engineering AspectAda Aspect-Oriented Programming for Ada95 WORLD CLASS – through people, technology and dedication

2. Agenda • Separation of Concerns + Crosscutting • Aspect-Oriented Programming (AOP) Model • Logging Example • AspectAda Prototype Architecture • Effect on SW Quality

3. Separation of Concerns (SoC) • “Separation of Concerns (SoC)” (Parnas, Dijkstra): • realization of problem domain concepts into separate units of software. • Benefits of SoC • Better analysis and understanding of systems • Easy adaptability, maintainability and high degree of reusability. • Low Coupling/High Cohesion • SoC Fundamental to SW Development • Ada95 SoC • Packages, Subprograms, • Tagged Types, Protected Types, Tasks

4. Crosscutting Concerns • Certain properties cannot be localized in single modular units, but their implementation cuts across the decomposition hierarchy of the system. • These properties are called crosscutting concerns, or aspects. • Concern (Requirement) • Functional • Non-functional • Design • Crosscutting Concern • A concern that is implemented in more than one location • security, logging, synchronization, fault tolerance, design by contract

5. Initial Picture of Crosscutting [Constantinides]

6. CORBA Servant Implementation procedure Do_Some(Self: inout Object; Data : in Data_t) is begin Tracer.Enter(Self.TraceId, “Do_Some”); Mutex.Lock(Self.Lock); .... -- Do business-logic --(Also invoking methods across CORBA) .... Fault_Tolerance.Log_State(Make_Stream(Data)); Mutex.Unlock(Self.Lock); Tracer.Exit(Self.TraceId, “Do_Some”); exception when event :others => Mutex.Unlock(Self.Lock); Error_Logger.Log_Error(event, “Unknown Exception in Do_Some”); end Do_Some;

7. Crosscutting identification procedure Do_Some(Self: inout Object; Data : in Data_t) is begin Tracer.Enter(Self.TraceId, “Do_Some”);  Mutex.Lock(Self.Lock); .... -- Do business-logic --(Also invoking methods across CORBA) .... Fault_Tolerance.Log_State(Make_Stream(Data)); Mutex.Unlock(Self.Lock); Tracer.Exit(Self.TraceId, “Do_Some”); exception when event :others => Mutex.Unlock(Self.Lock); Error_Logger.Log_Error(event, “Unknown Exception in Do_Some”); end Do_Some;

8. Symptoms of Crosscutting • Crosscutting imposes two symptoms on software development: • Code scattering: implementation of some concerns not well modularized but cuts across the decomposition hierarchy of the system. • Code tangling: a module may contain implementation elements (code) for various concerns. • Problems • Low cohesion • Strong coupling • Low reusability, adaptability • Difficult comprehensibility

9. AOP Version procedure Do_Some(Self: inout Object; Data : in Data_t) is begin -- Do business-logic --(Also invoking methods across CORBA) end Do_Some; • Aspects • Tracer • Mutex • FT State • Exception handling • Composition rules • Rules for inserting aspect behavior to components

10. AOP Programming Model

11. Aspect Oriented Programming • AOP Complementary to OOP as OOP was to procedural programming • Also applicable to procedural programming • Aspect Languages extends traditional programming languages • Abstractions for representing crosscutting concerns (Aspects) • Composition of Aspects and traditional modules (Weaving) • Improves modularity, adaptability, traceability • AspectJ – Dominant AOP language extension for Java • AspectAda – Our Proposal to extend Ada95 • Influenced by AspectJ

12. Joinpoint • Well defined instant in the execution of a program • Subprogram execution • Finalization, Initialization, Adjust (Controlled Types) • Variable access (Object declarations) • Package body statement block • Named block statements • Named loop statements • Rendezvous/Entry points procedure Do_Some(Self: inout M_Object; Data : in Data_t) is ... begin ... end Do_Some;

13. Pointcuts • Set of joinpoints (object declaration) • Pointcut expression (AspectJ Influenced) • Primitive pointcuts • Call • Execution • Get/Set of variables • Wildcard matching (*, ..) • Composition using and, or, xor, not • When a pointcut is matched, an advice can be executed My_PC : Pointcut := execution Some_Pk.Do_* (inout M_Object; ..) or execution Some_Pk.Set_* (in out M_Object; ..);

14. Advice • Code module (as a subprogram) that attaches to a pointcut • Injects behavior at all joinpoints selected by that pointcut • Three types: • Before (code injected before the joinpoint) • After (code injected after the joinpoint) • Around (code injected around (in place of) code from joinpoint advice Around(Mutex_A : inout Mutex_Aspect) is begin Mutex_A.Mutex.Lock; Proceed; Mutex_A.Mutex.Unlock; whenothers => Mutex_A.Mutex.Unlock; raise; end Around;

15. Aspect Composition rules Generic Aspect Ada95 Modules • A modular unit of crosscutting behavior • Advice type (tagged) • Simple (Performance) • Detailed (Contextual information) • Advice(s) bound to pointcut(s) (Advice clause) • Like a package can have subprograms, types ... • Parameterized to bind to one or more pointcut(s) generic Mutex_P : Pointcut; aspect Mutex_Aspects is type Mutex_Aspect is new Simple_Aspect with record Mutex : Mutex_t; end Mutex_Aspect; advice Around..... for Around’Advice use Mutex_P; end Mutex_Aspects;

16. Logging Example

17. AOP Tracing Example: Aspect Spec with AspectAda; generic Tracer_P : Pointcut; aspect Tracer is type Tracer_Aspect is new Aspect_Ada.Detailed_Aspect with null record; advice Before(Tracer : in Tracer_Aspect); for Before’Pointcut use Tracer_P; advice After(Tracer : in Tracer_Aspect); for After’Pointcut use Tracer_P; end Tracer;

18. AOP Tracing Example: Aspect Body with Ada.Text_IO; use Ada.Text_IO; with Aspect_Ada; use Aspect_Ada; aspectbody Tracer is advice Before(Tracer : in Tracer_Aspect) isbegin Put_Line(“==> “ & Image(Get_Join_Point(Tracer).all)); end Before; advice After(Tracer : in Tracer_Aspect) is begin Put_Line(“<==” & Image(Get_Join_Point(Tracer).all)); end After; end Tracer;

19. AOP Tracing Example: Composition Rules with Tracer; use Tracer; weaver CMS_Proto is Gun_Control_All_PC : Pointcut := execution Gun*.*(..); aspect Gun_Control_Logger is new Tracer_Aspect(Tracer_P => Gun_All_PC); end CMS_Proto;

20. AspectAda Prototype Architecture

21. AspectAda Architecture: Conceptual View [Hofmeister Notation]

22. Weaver Prototype: Modular View Controller Selection Merging ASIS JoinPointModel Aspect Parser Pointcut Parser • ASIS Based (Ada95) • AdaGOOP (Aspects, Pointcuts) • Ada.Containers • Easy to adapt to Ada2005

23. Effects on SW Quality

24. Effects on SW Quality • Cohesion • One concern in Ada95 module • Crosscutting concerns modularized in aspects • Coupling • Minimal coupling modeled using pointcut expressions • Reversed dependency direction • Adaptability • Code comprehensibility • Tradeoff • Traceability

25. Future Work • Extended joinpoint model • Call, Set/Get • Named blocks, named loops • Export of context at Joinpoints (objects, arguments) • Extend GPS Plugin (GNAT Programming System) • Joinpoint model and Ada generics • Increased Aspect reusability • Design by contract support • Open for suggestions

26. Conclusion • Crosscutting concerns • Joinpoint model (joinpoints, pointcuts, advices, aspects) • Tracing using AspectAda • AspectAda Prototype Architecture • Effects on SW Quality • Future Work

27. End www.cs.concordia.ca/~cc/research knuthp@gmail.com WORLD CLASS – through people, technology and dedication