CSC/ECE 517 Summer 2008/wiki1 5 a5

Introduction

Ruby has hooks that allows trapping a certain event (e.g., object creation) and running a particular code sequence whenever the event occurs. There's no comparable facility in Java. But both Ruby and Java have support for aspect-oriented programming (AspectR and AspectJ, respectively). What's the difference between simply providing hooks, and supporting full AOP, and why is it more convenient to program this way in Ruby than Java? Give a few code sequences to justify your conclusions.

Hooks

There is a strong desired from developers to have control on object life cycle. They would like to know when an object is created or destroyed, or some specific method is executed. Developers would like to monitor code and look for opportunities to change application behavior or add new functionality without making big changes to the object model already in place. Some programming languages provide hooks to monitor such events. Hooks are a set of code that automatically executes when a particular event is triggered.

Hooks Implementation

Most dynamic languages provide some way to execute custom code at different steps of an object's life cycle. Most of them build this functionality into the language itself. They use the interceptor design pattern as an implementation guideline.

Hooks in Ruby

Ruby is a dynamic and pure object oriented language. It has very strong support for metaprogramming. It provides system hooks for monitoring events like object creation. The technique used by Ruby to provide this functionality is a simple example of the interceptor design pattern. By intercepting calls to system classes developers could modify the system behavior without changing application code.

Example Code:

The following example code from Programming Ruby - The Pragmatic Programmer's Guide (First edition is freely available on web) for hooking an objects creation event. This code modifies two Ruby system classes (Class and Object). It renames and redefines the Class new method and modifies the Object class to store the timestamp.

  class Class 
           alias_method :old_new, new
           def new (*args)
                       result = old_new(*args)
                       result.timestamp = Time.now
                       return result
           end
  end

  class Object
           def timestamp 
                       return @timestamp
           end 
           def timestamp = (aTime)
                       @timestamp = aTime
           end
  end

The following code can be used to check the timestamps recorded by our hooks above:

  class Test
  end

  obj1 = Test.new
  sleep 2           #not needed if executing code using Interactive Ruby
  obj2 = Test.new

  obj1.timestamp 
  obj2.timestamp

obj1.timestamp or obj2.timestamp would look something like: Fri Jun 06 17:29:04 -0400 2008 and Fri Jun 06 17:29:18 -0400 2008 respectively.

Hooks in Java

Java is a statically typed language. It doesn’t provide any language level ability to monitor events like object creation etc. However, the latest JVM version through JVMTI allow some hooks for monitoring performance but there is no way for the developer to change the behavior of an application through the available hooks.

Benefits of Hooks

Hooks are an elegant way of changing application behavior in dynamic languages. It is simple and compatible with the dynamic language philosophy. Since it is usually part of dynamic languages the developer does not have to learn a new API to take advantage of hooks.

Aspect-Oriented Programming

Object-Oriented Programming (OOP) was a big shift from procedural programming. With OOP instead of concentrating on procedures and data separately, developers started working with objects and their interactions with other objects to design more efficient and maintainable applications. This allowed developers to deal with large and more complicated systems and develop them in less time than ever before. Aspect-oriented Programming (AOP) is designed to make developers life even easier by allowing them to dynamically modify the static OO model to create a system that can grow to meet new requirements.

Aspect-Oriented Programming facilitates the developers attempt to reduce the amount of distinct features with overlaping functionality by addressing cross-cutting concerns and facilitating modular programming.

AOP may appear simple but is in fact quite a complex topic. Standard implementations usually make use of the following:

1. Cross-cutting concerns: Even though most classes in an OO model will perform a single, specific function, they often share common, secondary requirements with other classes. For example, we may want to add logging to classes within the data-access layer and also to classes in the UI layer whenever a thread enters or exits a method. Even though the primary functionality of each class is very different, the code needed to perform the secondary functionality is often identical.
2. Advice: This is the additional code that you want to apply to your existing model. In our example, this is the logging code that we want to apply whenever the thread enters or exits a method.
3. Point-cut: This is the term given to the point of execution in the application at which cross-cutting concern needs to be applied. In our example, a point-cut is reached when the thread enters a method, and another point-cut is reached when the thread exits the method.
4. Aspect: The combination of the point-cut and the advice is termed an aspect. In the example below, we add a logging aspect to our application by defining a point-cut and giving the correct advice.

[Reference: Introduction to Aspect-Oriented Programming]

AOP Implementation

For both Java and Ruby multiple implementations of AOP exist. For the purpose of this article we will look at AspectJ for Java and AspectR for Ruby.

AOP in Java

AspectJ adds the concept of a join point to Java as well as a few new constructs: pointcuts, advice, inter-type declarations and aspects. The dynamic parts of AspectJ include: the join point which is a well-defined point in the program flow, the pointcut which picks out certain join points and values at those points, and lastly the advice which is executed when a join point is reached. AspectJ also has different kinds of inter-type declarations that allow the programmer to modify a program's static structure, namely, the members of its classes and the relationship between classes. AspectJ's aspect are the unit of modularity for crosscutting concerns. They behave somewhat like Java classes, but may also include pointcuts, advice and inter-type declarations.

Example Code:

  aspect SimpleTracing {
     pointcut tracedCall():
        call(void FigureElement.draw(GraphicsContext));
  
     before(): tracedCall() {
        System.out.println("Entering: " + thisJoinPoint);
     }
  }

[Reference Development Aspects]

This code is meant to print a line of text everytime a FigureElement receives a draw method call. It does this by creating an aspect called SimpleTracing which uses a pointcut called tracedCall() to capture every draw method call. This in itself would do nothing, so to implement crosscutting behavior Advice is used. That advice basically says print out the name of thisJoinPoint, a special variable, before the actual method starts running, but just after the arguments to the method call are evaluated.

The result would look something like:

  Entering: call(void FigureElement.draw(GraphicsContext))

The main advantage to using this technique is that we did not have to edit the draw method call. We could extend this to report on multiple method calls from one aspect without changing any of the method call definitions.

AOP in Ruby

AspectR is an Aspect-Oriented Programming framework for Ruby. It is similar to AspectJ in implementation of AOP but is not as robust or well documented as AspectJ. AspectR includes a aspects, join points, pointcuts, advice, as well as a method profiler and logger. The authors of the software claim their profiler is much more efficient than Ruby's built in profiler and gives you more relevant information. AspectR is however not a complete implementation of AspectJ, this is due in part to the authors belief that some features do not need to be implemented in Ruby.

For the following example the author of AspectR shows us how to monitor method calls by first creating a new aspect:

Example Code from AspectR Homepage:

  require 'aspectr'
  include AspectR
  class MyAspect < Aspect 
  
     def someAdviceMethod(method, object, exitstatus, *args)
        ...
     end
        ... some other advice methods ...
     end

Now that we have an aspect here are some ways we can use it:

  ma = MyAspect.new
  ma.wrap(someClassorObject, :preAdvice, :postAdvice, ... methods to wrap...)                #Would apply to any spcified method call
  ma.wrap(someClassorObject, :preAdvice, :postAdvice, /patternToWrap/)                       #Specify a pattern instead of the full method name
  AspectR.wrap_classes(ma, :preAdvice, :postAdvice, [Class1, Class2], ...methods to wrap...) #Defines which classes and methods this Aspect would apply to.

As you can see these are several ways AspectR can be used to cross-cut code and implement systems such as loggers without modifying the methods or classes they are supposed to monitor.

Benefits of AOP

Software engineers should take advantage of aspect-oriented programming to reduce the amount of scattered or tangled code within a program. Modular programming techniques such as AOP often allow engineers to fully seperate programming tasks this allows the code to be easier to read and maintain. Similar to the way the OSI Reference Model breaks up networking transmission into layers of related functions. When creating software or hardware for a single layer, engineers must only provide services for the layer above and below the one currently being designed. This allows Application Layer programmers to do their job with little or no concern for what is going on at the Physical Layer.

Using AOP to break down the functions of a program allow software engineers to work on one function without breaking another. While this may seem like common sense, it can be a very difficult task. For example when coding a database update function a few of the considerations include ensuring the user updating the database is authorized to make the change, the data is valid in respect for the field being updated, and that the change is properly logged so that it may be undone if needed later. These concerns along with many others can be properly be encapsulated so that they may be maintained and updated without affecting the various other processes going on along side them.

AOP vs Hooks

From the earliest days of object-oriented programming languages, programmers have been using different techniques to execute code at different phases of the object life cycle. They have successfully used programming concepts like subjects, interception and delegation. Most all modern object-oriented dynamic languages now support hooking mechanism to aid implementation of these techniques.

Aspect Oriented Programming on other hand is a new concept. It provides a more comprehensive solution for dealing with complex requirements related to cross-cutting concerns and modularity. It has its own domain-specific language to deal with such problems. There is no comparison between AOP’s extensive semantics with present hooks implementations. Hooks could be used as AOP implementation mechanisms but they will never be able to compete with the AOP functionality.

It is hard for us to come up with some good examples that shows the limitation of hooks compare to AOP within Ruby. While searching the web we did come across a specification for implementing Cut-based AOP in Ruby. This specification discusses how we could add additional functionality to an existing class without subclassing it. It introduces a new class called Cut. It is used to encapsulate advice for a single class. The following is an example of adding new functionality to the existing class C without subclassing it using the new Cut class,

  class C
  	def f(*args); 1; end	
  	def g(*args): 2; end
  end

In order to add new functionality we would subclass C. i.e.

  class A<C
  	def f
  		print ‘(’, super, ‘)’
  	end
  end

Using AOP extension for Ruby,

  cut A < C
  	def f
  		print ‘(’, super, ‘)’ 
  	end
  end

Now instead of subclassing C “we have cut-across behavior of C with A”.

If we compare the above two examples (Ruby Hook and Java AOP) it is obvious that using AOP is over kill for such a simple problem. Ruby hooks are a more elegant solution in this situation. AOP are more suitable for statically typed languages like Java. Ruby as a dynamic language needs simpler syntax for dealing with simple cross-cutting concern problems. It supports very strong metaprogramming functionalities using interceptors, hotswapping, mixins, and hooks that makes it much easier to inject custom code during runtime. Various Ruby experts also share the same opinion:

“For Ruby developers, AOP is not quite as urgent, because you’ve already got robust tools to deal with these kinds of concerns.” Bruce Tate – Beyond Java.

“A standardized AOP framework has never really taken off in Ruby because the language itself already supports most of the desirable functionality of AOP.” David Heinemeier Hansson – Rail Architect

Other experts do mention that it may take more time for Ruby AOP to become a larger concern, they continue to say that often only enterprise application development warrents AOP and currently Ruby does not have a large enough group of programmers working on these types of applications.

Links

• Ruby
• AspectR
• AspectJ
• Dynamic Languages
• interceptor design pattern
• Programming Ruby - The Pragmatic Programmer's Guide (First edition)
• JVMTI
• Does Ruby need AOP ?
• Aspect Oriented Programming
• Introduction to Aspect-Oriented Programming