Docstoc

ACME

Document Sample
ACME Powered By Docstoc
					 Automating Crosscutting
      Modification




By Michael Kleyman
       When AOP is Used?
 It is usually said that aspects represent
  crosscutting concerns.
 No clear definition of such a concern.
 AOP can be dangerous when overused.
          Trivial Examples
 Logging
 Authorization
         Telecom Example
 Calls, messaging etc. are the core concepts
 Represented by classes, such as Call or
  Connection
 Billing is the crosscutting concern,
  represented by an aspect.
 Payment calculation initiated in advices to
  methods of the core classes.
 When AOP is helpful, but not
          used
 Corporate policies do not allow use of
  experimental, immature technologies
 An aspect allows rapid modification of
  existing code, but the resulting program
  structure is not the best possible structure
 Crosscutting modification as opposed to
  crosscutting concern
    Example: Object Pooling
 Goal: reuse objects instead of creating new
  ones
 Can be represented by a factory class.
 Introducing object pooling into existing
  system is difficult.
 AspectJ allows an easy but controversial
  solution
           What is ACME
 Convert AspectJ solution to pure Java
 Prove of concept
 Based on specific examples
 Additional examples may be covered later
               Key Goals
 Java code must produce exactly the same
  results as the aspect code.
 Java code should not be significantly longer
  than the aspect code.
 The produced code should be easily
  modified and used.
     Key Goals (Continued)
 The generated code must look similar to
  code written by a human programmer.
 Based on commonly used patterns and
  idioms.
    ACME vs. AspectJ Compiler
 Must not support the entire language
 Must generate meaningful names (possibly
  with user’s help)
 May not use some complicated structures
  used in the compiler.
      Workflow with ACME
 Implement the required modification using
  aspects
 Test the implementation
 When the result is satisfactory, run ACME
  to generate pure Java code with same
  functionality
    Creating Singleton Class
 Aspect interacts with other code through
  pointcuts on functions of a single class.
 Aspect is converted to a class automatically.
 All calls that are advised by the aspect are
  replaced by calls to the singleton.
 Example: object pooling.
       Inlining Aspect Code
 Aspect may be used to modify both
  interface and behavior of an existing class.
 Involves both advises and inter-type
  member declarations.
 Example: modification of the Point class.
 Example: introduction of transactions
      Automatic Modification
 Add the member introduced by the inter-
  type declaration to the class
 Add a function for each advice
 Replace all calls advised by the aspect by
  calls to the new functions
        Aspect Hierarchies
 Allow code reuse in several aspects
 Typically involve abstract pointcuts and
  concrete implementation of the advices
 Transformed into hierarchies of classes
  where the leaves are implemented as
  singletons.
       When ACME helps?
 Evolution aid: test before changing the
  system.
 Refactoring
 Eases adoption of aspect technology
               When not?
 Aspect represent crosscutting concerns
 Aspects used as a configuration tool for
  different application of the system
     Unsupported Language
           Features
 Wildcards
 Type-dependent pointcut definitions
 Implicit type casting
 Compile-time applications of aspects, such
  as “declare error”
 Execution pointcuts
More on execution join points
 Require replacing the implementation of
  functions, not the calls to them.
 With inheritance require replacing several
  functions for each advice.
 Anything but the simplest around advice
  must be transformed to very complicated
  code
 Very limited benefit
             Case Study
 ACME was applied to Shay Raz’s work on
  system scaling with aspects.
 Some aspects required cosmetic changes
  before processing.
 Some can not be processed because they
  involve implicit type casting.
 Possible solution: rewrite the aspects,
  removing abstract pointcuts from the base
  aspect.
     Implementation Details
 Built as an Eclipse plugin
 Uses JDT library for Java source
  manipulation
 There is no such library for AspectJ code
           Algorithm Steps
 Parse the AspectJ files
 Create new classes for “singleton” aspects.
 Add new members to existing classes
 Find advised function calls (using JDT)
 Replace these calls by calls to generated
  functions

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:9
posted:10/19/2012
language:English
pages:22