Object Mentor Blog: Traits vs. Aspects in Scala

Traits vs. Aspects in Scala

Dean Wampler — Sat, 27 Sep 2008 22:33:00 -0500

Scala traits provide a mixin composition mechanism that has been missing in Java. Roughly speaking, you can think of traits as analogous to Java interfaces, but with implementations.

Aspects, e.g., those written in AspectJ, are another mechanism for mixin composition in Java. How do aspects and traits compare?

Let’s look at an example trait first, then re-implement the same behavior using an AspectJ aspect, and finally compare the two approaches.

Observing with Traits

In a previous post on Scala, I gave an example of the Observer Pattern implemented using a trait. Chris Shorrock and James Iry provided improved versions in the comments. I’ll use James’ example here.

To keep things as simple as possible, let’s observe a simple Counter, which increments an internal count variable by the number input to an add method.

    
package example

class Counter {
    var count = 0
    def add(i: Int) = count += i
}

The count field is actually public, but I will only write to it through add.

Here is James’ Subject trait that implements the Observer Pattern.

    
package example

trait Subject {
  type Observer = { def receiveUpdate(subject:Any) }

  private var observers = List[Observer]()
  def addObserver(observer:Observer) = observers ::= observer
  def notifyObservers = observers foreach (_.receiveUpdate(this))
}

Effectively, this says that we can use any object as an Observer as long as it matches the structural type { def receiveUpdate(subject:Any) }. Think of structural types as anonymous interfaces. Here, a valid observer is one that has a receiveUpdate method taking an argument of Any type.

The rest of the trait manages a list of observers and defines a notifyObservers method. The expression observers ::= observer uses the List :: (“cons”) operator to prepend an item to the list. (Note, I am using the default immutable List, so a new copy is created everytime.)

The notifyObservers method iterates through the observers, calling receiveUpdate on each one. The _ that gets replaced with each observer during the iteration.

Finally, here is a specs file that exercises the code.

    
package example

import org.specs._

object CounterObserverSpec extends Specification {
    "A Counter Observer" should {
        "observe counter increments" in {
            class CounterObserver {
                var updates = 0
                def receiveUpdate(subject:Any) = updates += 1
            }
            class WatchedCounter extends Counter with Subject {
                override def add(i: Int) = { 
                    super.add(i)
                    notifyObservers
                }
            }
            var watchedCounter = new WatchedCounter
            var counterObserver = new CounterObserver
            watchedCounter.addObserver(counterObserver)
            for (i <- 1 to 3) watchedCounter.add(i)
            counterObserver.updates must_== 3
            watchedCounter.count must_== 6
    }
  }
}

The specs library is a BDD tool inspired by rspec in Rubyland.

I won’t discuss it all the specs-specific details here, but hopefully you’ll get the general idea of what it’s doing.

Inside the "observe counter increments" in {...}, I start by declaring two classes, CounterObserver and WatchedCounter. CounterObserver satisfies our required structural type, i.e., it provides a receiveUpdate method.

WatchedCounter subclasses Counter and mixes in the Subject trait. It overrides the add method, where it calls Counter’s add first, then notifies the observers. No parentheses are used in the invocation of notifyObservers because the method was not defined to take any!

Next, I create an instance of each class, add the observer to the WatchedCounter, and make 3 calls to watchedCounter.add.

Finally, I use the “actual must_== expected” idiom to test the results. The observer should have seen 3 updates, while the counter should have a total of 6.

The following simple bash shell script will build and run the code.

    
SCALA_HOME=...
SCALA_SPECS_HOME=...
CP=$SCALA_HOME/lib/scala-library.jar:$SCALA_SPECS_HOME/specs-1.3.1.jar:bin
rm -rf bin
mkdir -p bin
scalac -d bin -cp $CP src/example/*.scala
scala -cp $CP example/CounterObserverSpec

Note that I put all the sources in a src/example directory. Also, I’m using v1.3.1 of specs, as well as v2.7.1 of Scala. You should get the following output.

    
Specification "CounterObserverSpec" 
  A Counter Observer should
  + observe counter increments

Total for specification "CounterObserverSpec":
Finished in 0 second, 60 ms
1 example, 2 assertions, 0 failure, 0 error

Observing with Aspects

Because Scala compiles to Java byte code, I can use AspectJ to advice Scala code! For this to work, you have to be aware of how Scala represents its concepts in byte code. For example, object declarations, e.g., object Foo {...} become static final classes. Also, method names like + become $plus in byte code.

However, most Scala type, method, and variable names can be used as is in AspectJ. This is true for my example.

Here is an aspect that observes calls to Counter.add.

    
package example

public aspect CounterObserver {
    after(Object counter, int value): 
        call(void *.add(int)) && target(counter) && args(value) {

        RecordedObservations.record("adding "+value);
    }
}

You can read this aspect as follows, after calling Counter.add (and keeping track of the Counter object that was called, and the value passed to the method), call the static method record on the RecordedObservations.

I’m using a separate Scala object RecordedObservations

    
package example

object RecordedObservations {
    private var messages = List[String]()
    def record(message: String):Unit = messages ::= message
    def count() = messages.length
    def reset():Unit = messages = Nil
}

Recall that this is effectively a static final Java class. I need this separate object, rather than keeping information in the aspect itself, because of the simple-minded way I’m building the code. ;) However, it’s generally a good idea with aspects to delegate most of the work to Java or Scala code anyway.

Now, the “spec” file is:

    
package example

import org.specs._

object CounterObserverSpec extends Specification {
    "A Counter Observer" should {
        "observe counter increments" in {
            RecordedObservations.reset()
            var counter = new Counter
            for (i <- 1 to 3) counter.add(i)
            RecordedObservations.count() must_== 3
            counter.count must_== 6
    }
  }
}

This time, I don’t need two more classes for the adding a mixin trait or defining an observer. Also, I call RecordedObservations.count to ensure it was called 3 times.

The build script is also slightly different to add the AspectJ compilation.

    
SCALA_HOME=...
SCALA_SPECS_HOME=...
ASPECTJ_HOME=...
CP=$SCALA_HOME/lib/scala-library.jar:$SCALA_SPECS_HOME/specs-1.3.1.jar:$ASPECTJ_HOME/lib/aspectjrt.jar:bin
rm -rf bin app.jar
mkdir -p bin
scalac -d bin -cp $CP src/example/*.scala 
ajc -1.5 -outjar app.jar -cp $CP -inpath bin src/example/CounterObserver.aj
aj -cp $ASPECTJ_HOME/lib/aspectjweaver.jar:app.jar:$CP example.CounterObserverSpec

The ajc command not only compiles the aspect, but it “weaves” into the compiled Scala classes in the bin directory. Actually, it only affects the Counter class. Then it writes all the woven and unmodified class files to app.jar, which is used to execute the test. Note that for production use, you might prefer load-time weaving.

The output is the same as before (except for the milliseconds), so I won’t show it here.

Comparing Traits with Aspects

So far, both approaches are equally viable. The traits approach obviously doesn’t require a separate language and corresponding tool set.

However, traits have one important limitation with respect to aspects. Aspects let you define pointcuts that are queries over all possible points where new behavior or modifications might be desired. These points are called join points in aspect terminology. The aspect I showed above has a simple pointcut that selects one join point, calls to the Counter.add method.

However, what if I wanted to observe all state changes in all classes in a package? Defining traits for each case would be tedious and error prone, since it would be easy to overlook some cases. With an aspect framework like AspectJ, I can implement observation at all the points I care about in a modular way.

Aspect frameworks support this by providing wildcard mechanisms. I won’t go into the details here, but the * in the previous aspect is an example, matching any type. Also, one of the most powerful techniques for writing robust aspects is to use pointcuts that reference only annotations, a form of abstraction. As a final example, if I add an annotation Adder to Counter.add,

    
package example

class Counter {
    var count = 0
    @Adder def add(i: Int) = count += i
}

Then I can rewrite the aspect as follows.

    
package example

public aspect CounterObserver {
    after(Object counter, int value): 
        call(@Adder void *.*(int)) && target(counter) && args(value) {

        RecordedObservations.record("adding "+value);
    }
}

Now, there are no type and method names in the pointcut. Any instance method on any visible type that takes one int (or Scala Int) argument and is annotated with Adder will get matched.

Note: Scala requires that you create any custom annotations as normal Java annotations. Also, if you intend to use them with Aspects, use runtime retention policy, which will be necessary if you use load-time weaving.

Conclusion

If you need to mix in behavior in a specific, relatively-localized set of classes, Scala traits are probably all you need and you don’t need another language. If you need more “pervasive” modifications (e.g., tracing, policy enforcement, security), consider using aspects.

Acknowledgements

Thanks to Ramnivas Laddad, whose forthcoming 2^nd Edition of AspectJ in Action got me thinking about this topic.

"Traits vs. Aspects in Scala" by backup iphone sms

Wed, 11 Jan 2012 05:25:14 -0600

Take effect to save the file and you can retrieve them when necessary.

"Traits vs. Aspects in Scala" by grad school personal statement

Fri, 23 Dec 2011 09:01:57 -0600

Great blog. All posts have something to learn. Your work is very good and i appreciate you and hoping for some more informative posts. thank you……..

"Traits vs. Aspects in Scala" by tv guide

Sat, 26 Nov 2011 10:07:30 -0600

great stuff. thanks a lot!

"Traits vs. Aspects in Scala" by cheap gucci

Sat, 26 Nov 2011 03:07:25 -0600

art jordan 6 rate, breathing air jordan 2011 , but still in a deep coma jordan release dates 2011 . It is reported that these jordan 3 10 days air jordan 5 and more time,...

"Traits vs. Aspects in Scala" by Cheap Beats By Dr.Dre

Tue, 08 Nov 2011 21:13:34 -0600

And M550i HR tend to music taste and string very good vocal performance voices sweet thick with deep feeling singing nuanced string flavour seemed to be able to smell the violin string the flickering light of loose filled with each frequency band appeal fragrance extension is very good density are first-class More information in the best sound headphones’s official

"Traits vs. Aspects in Scala" by mr school

Tue, 08 Nov 2011 11:00:29 -0600

fuck girl vietnam please visit http://www.xxxgirl.us/2011/11/hoang-thuy-linh-paris-hilton-style-sex.html

"Traits vs. Aspects in Scala" by christian louboutin

Thu, 03 Nov 2011 05:41:56 -0500

Blog posts about wedding and bridal are always rare to find , at least with great quality,you qualify for a great blog post writer title,kep the great job happening

"Traits vs. Aspects in Scala" by canada goose jakke

Fri, 28 Oct 2011 21:08:24 -0500

Berlusconi canada goose jakke sagde ved en nyheder canada goose konference i et par dage siden, Gruppen canada goose outlet af otte topmødet udvides gradvist i de belstaff outlet næste to dage.Alt mere end mere end 30 andre belstaff ledere af nationale og internationale organisationer Canada Goose Chilliwack Parka blev opfordret til forskellige temaer afholdt dialog med lederne af gruppen af otte, involverer Canada Goose Trillium Parka spørgsmål spænder fra globale økonomiske styring, klimaændringer, handel, udvikling og fødevarer Canada Goose Solaris Parka sikkerhed i Afrika.Berlusconi sagde, l ’ Aquila topmødet forventes i år at opnå væsentlige resultater Canada Goose Handsker på en række spørgsmål.

"Traits vs. Aspects in Scala" by Fake Oakley Gascan sunglasses

Tue, 18 Oct 2011 19:41:41 -0500

http://www.oakleyshadestore.com/fake-oakley-gascan-c-29.html

"Traits vs. Aspects in Scala" by Ashley Bowling

Sun, 16 Oct 2011 01:52:14 -0500

“When the stars begin to huddle, the earth will soon become a puddle.”

"Traits vs. Aspects in Scala" by canada goose coat

Thu, 13 Oct 2011 01:38:48 -0500

When it comes to feather dress, what appears in your mind? Which kind brand of down jacket do you like prefer? Though there are many down jackets for you to choose from, on the word, which one you really enjoy? I want to say that canada goose coats is really your best choice. I believe you can’t agree with me any more. When you take the quality into consideration, you will find that it is superior to any other kind of coat. Besides, discount canada goose jackets is a world well-known brand, which has gained high reputation in the world, which has accepted by our customers and some organization. Because of its high quality, some of our loyal customers have promoted it to the people around them. In their opinion, it is good to informing others to know it. Recently, Canada Goose Trillium Parka is on hot sale. What I have to inform you is that all the products there are made by hand, so they are elaborative and elegant enough. It is really beautiful once you dress in. So, if you are a lovely girl or woman, go to the store to buy one for you. You will appreciate it that you have such a coat.In addition, they also have any other products like canada goose Gloves and canada goose jacket supplier.Hope your will like its!

"Traits vs. Aspects in Scala" by Puma espera shoes

Tue, 27 Sep 2011 02:30:47 -0500

Both styles were seen in the World Cup worn by Eusebio da Silva Ferreira and in the Olympics worn by Lee Evans and Thomas Smith. Rudolf passed in 1974 of lung cancer, and his son ran the company. In 1989, Armin and Gerd Dassler sold Puma to Cosa Liebermann for a unknown amount. Since Puma was seen on the soccer field many years ago it’s still very popular with the players and fans. Puma offers tons of styles to pick from and with the basic look they never go out of style. Puma will be around for a very very long time.

"Traits vs. Aspects in Scala" by beats by dre store

Tue, 23 Aug 2011 02:48:40 -0500

I really enjoyed reading it and will certainly share this post with my friends beats by dre sale cheap beats by dre

"Traits vs. Aspects in Scala" by beats by dre store

Tue, 23 Aug 2011 02:46:42 -0500

e, I really enjoyed reading it and will certainly share this post with beats by dre sale cheap beats by dre

"Traits vs. Aspects in Scala" by Crystal Jewellery

Thu, 18 Aug 2011 12:24:57 -0500

Great post! Nice and informative, I really enjoyed reading it and will certainly share this post with my friends . Read everything you ever wanted to know about how to buy gold jewelry

"Traits vs. Aspects in Scala" by Bowtrol

Mon, 08 Aug 2011 16:36:27 -0500

Blog posts about wedding and bridal are always rare to find , at least with great quality,you qualify for a great blog post writer title,kep the great job happening

"Traits vs. Aspects in Scala" by hancy

Sun, 24 Jul 2011 04:30:11 -0500

It’s a lucky day!I get one pair of women heels from http://www.aliexpress.com/fm-store/908014 ! It’s have beautiful appearance and very comfortable! Here’s your first look at the first Women’s Heels that I have ever seen. I do believe this is the first time our store has released a Women’s Heels in a high top form.

"Traits vs. Aspects in Scala" by http://www.coachoutletstore-onlines.com

Thu, 30 Jun 2011 20:48:44 -0500

only do what you want to do

"Traits vs. Aspects in Scala" by cookies gift baskets

Sun, 19 Jun 2011 11:16:15 -0500

it needs a bokmark so i can come back to it later ,nice stuff

"Traits vs. Aspects in Scala" by commission predators

Fri, 17 Jun 2011 11:27:09 -0500

It’s amazing how interesting it is for me to visit you very often.

"Traits vs. Aspects in Scala" by Jewellery

Sat, 04 Jun 2011 05:51:18 -0500

Online UK costume and fashion jewellery shop with,

"Traits vs. Aspects in Scala" by christian louboutin shoes on sale

Fri, 03 Jun 2011 07:09:36 -0500

Have the christian louboutin patent leather pumps is a happy thing. Here have the most complete kinds of christian louboutin leather platform pumps.

"Traits vs. Aspects in Scala" by Monster Beats By Dr. Dre Studio

Sat, 28 May 2011 21:23:42 -0500

The Monster Beats By Dr. Dre Studio Headphones are classic shoes.You will be proud of owning them. Don’t hesitate!Take Monster Beats By Dr. Dre Pro home! Choose our Monster Beats By Dr. Dre Solo Headphones will make you have an amazing discovery.

"Traits vs. Aspects in Scala" by f350 leveling kit

Fri, 13 May 2011 00:44:16 -0500

Your article is so informative and I like it Thanks :-)

"Traits vs. Aspects in Scala" by leveling kit f250

Fri, 13 May 2011 00:43:52 -0500

Your article is so informative and I like it Thanks :-)