Object Mentor Blog: The Seductions of Scala, Part I

The Seductions of Scala, Part I

Dean Wampler — Sun, 03 Aug 2008 15:30:00 -0500

(Update 12/23/2008: Thanks to Apostolos Syropoulos for pointing out an earlier reference for the concept of “traits”).

Because of all the recent hoo-ha about functional programming (e.g., as a “cure” for the multicore problem), I decided to cast aside my dysfunctional ways and learn one of the FP languages. The question was, which one?

My distinguished colleague, Michael Feathers, has been on a Haskell binge of late. Haskell is a pure functional language and is probably most interesting as the “flagship language” for academic exploration, rather than production use. (That was not meant as flame bait…) It’s hard to underestimate the influence Haskell has had on language design, including Java generics, .NET LINQ and F#, etc.

However, I decided to learn Scala first, because it is a JVM language that combines object-oriented and functional programming in one language. At ~13 years of age, Java is a bit dated. Scala has the potential of replacing Java as the principle language of the JVM, an extraordinary piece of engineering that is arguably now more valuable than the language itself. (Note: there is also a .NET version of Scala under development.)

Here are some of my observations, divided over three blog posts.

First, a few disclaimers. I am a Scala novice, so any flaws in my analysis reflect on me, not Scala! Also, this is by no means an exhaustive analysis of the pros and cons of Scala vs. other options. Start with the Scala website for more complete information.

A Better OOP Language

Scala works seamlessly with Java. You can invoke Java APIs, extend Java classes and implement Java interfaces. You can even invoke Scala code from Java, once you understand how certain “Scala-isms” are translated to Java constructs (javap is your friend). Scala syntax is more succinct and removes a lot of tedious boilerplate from Java code.

For example, the following Person class in Java:

    
class Person {
    private String firstName;
    private String lastName;
    private int    age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName  = lastName;
        this.age       = age;
    }

    public void setFirstName(String firstName) { this.firstName = firstName; }
    public void String getFirstName() { return this.firstName; }
    public void setLastName(String lastName) { this.lastName = lastName; }
    public void String getLastName() { return this.lastName; }
    public void setAge(int age) { this.age = age; }
    public void int getAge() { return this.age; }
}

can be written in Scala thusly:

    
class Person(var firstName: String, var lastName: String, var age: Int)

Yes, that’s it. The constructor is the argument list to the class, where each parameter is declared as a variable (var keyword). It automatically generates the equivalent of getter and setter methods, meaning they look like Ruby-style attribute accessors; the getter is foo instead of getFoo and the setter is foo = instead of setFoo. Actually, the setter function is really foo_=, but Scala lets you use the foo = sugar.

Lots of other well designed conventions allow the language to define almost everything as a method, yet support forms of syntactic sugar like the illusion of operator overloading, Ruby-like DSL’s, etc.

You also get fewer semicolons, no requirements tying package and class definitions to the file system structure, type inference, multi-valued returns (tuples), and a better type and generics model.

One of the biggest deficiencies of Java is the lack of a complete mixin model. Mixins are small, focused (think Single Responsibility Principle ...) bits of state and behavior that can be added to classes (or objects) to extend them as needed. In a language like C++, you can use multiple inheritance for mixins. Because Java only supports single inheritance and interfaces, which can’t have any state and behavior, implementing a mixin-based design has always required various hacks. Aspect-Oriented Programming is also one partial solution to this problem.

The most exciting OOP enhancement Scala brings is its support for Traits, a concept first described here and more recently discussed here. Traits support Mixins (and other design techniques) through composition rather than inheritance. You could think of traits as interfaces with implementations. They work a lot like Ruby modules.

Here is an example of the Observer Pattern written as traits, where they are used to monitor changes to a bank account balance. First, here are reusable Subject and Observer traits.

    
trait Observer[S] {
    def receiveUpdate(subject: S);
}

trait Subject[S] { 
    this: S =>
    private var observers: List[Observer[S]] = Nil
    def addObserver(observer: Observer[S]) = observers = observer :: observers

    def notifyObservers() = observers.foreach(_.receiveUpdate(this))
}

In Scala, generics are declared with square brackets, [...], rather than angled brackets, <...>. Method definitions begin with the def keyword. The Observer trait defines one abstract method, which is called by the Subject to notify the observer of changes. The Subject is passed to the Observer.

This trait looks exactly like a Java interface. In fact, that’s how traits are represented in Java byte code. If the trait has state and behavior, like Subject, the byte code representation involves additional elements.

The Subject trait is more complex. The strange line, this: S => , is called a self type declaration. It tells the compiler that whenever this is referenced in the trait, treat its type as S, rather than Subject[S]. Without this declaration, the call to receiveUpdate in the notifyObservers method would not compile, because it would attempt to pass a Subject[S] object, rather than a S object. The self type declaration solves this problem.

The next line creates a private list of observers, initialized to Nil, which is an empty list. Variable declarations are name: type. Why didn’t they follow Java conventions, i.e., type name? Because this syntax makes the code easier to parse when type inference is used, meaning where the explicit :type is omitted and inferred.

In fact, I’m using type inference for all the method declarations, because the compiler can figure out what each method returns, in my examples. In this case, they all return type Unit, the equivalent of Java’s void. (The name Unit is a common term in functional languages.)

The third line defines a method for adding a new observer to the list. Notice that concrete method definitions are of the form

    
def methodName(parameter: type, ...) = {
    method body
}

In this case, because there is only one line, I dispensed with the {...}. The equals sign before the body emphasizes the functional nature of scala, that all methods are objects, too. We’ll revisit this in a moment and in the next post.

The method body prepends the new observer object to the existing list. Actually, a new list is created. The :: operator, called “cons”, binds to the right. This “operator” is really a method call, which could actually be written like this, observers.::(observer).

Our final method in Subject is notifyObservers. It iterates through observers and invokes the block observer.receiveUpdate(this) on each observer. The _ evaluates to the current observer reference. For comparison, in Ruby, you would define this method like so:

    
def notifyObservers() 
    @observers.each { |o| o.receiveUpdate(self) }
end

Okay, let’s look at how you would actually use these traits. First, our “plain-old Scala object” (POSO) Account.

    
class Account(initialBalance: Double) {
    private var currentBalance = initialBalance
    def balance = currentBalance
    def deposit(amount: Double)  = currentBalance += amount
    def withdraw(amount: Double) = currentBalance -= amount
}

Hopefully, this is self explanatory, except for two things. First, recall that the whole class declaration is actually the constructor, which is why we have an initialBalance: Double parameter on Account. This looks strange to the Java-trained eye, but it actually works well and is another example of Scala’s economy. (You can define multiple constructors, but I won’t go into that here…).

Second, note that I omitted the parentheses when I defined the balance “getter” method. This supports the uniform access principle. Clients will simply call myAccount.balance, without parentheses and I could redefine balance to be a var or val and the client code would not have to change!

Next, a subclass that supports observation.

    
class ObservedAccount(initialBalance: Double) extends Account(initialBalance) with Subject[Account] {
    override def deposit(amount: Double) = {
        super.deposit(amount)
        notifyObservers()
    }
    override def withdraw(amount: Double) = {
        super.withdraw(amount)
        notifyObservers()
    }
}

The with keyword is how a trait is used, much the way that you implement an interface in Java, but now you don’t have to implement the interface’s methods. We’ve already done that.

Note that the expression, ObservedAccount(initialBalance: Double) extends Account(initialBalance), not only defines the (single) inheritance relationship, it also functions as the constructor’s call to super(initialBalance), so that Account is properly initialized.

Next, we have to override the deposit and withdraw methods, calling the parent methods and then invoking notifyObservers. Anytime you override a concrete method, scala requires the override keyword. This tells you unambiguously that you are overriding a method and the Scala compiler throws an error if you aren’t actually overriding a method, e.g., because of a typo. Hence, the keyword is much more reliable (and hence useful…) than Java’s @Override annotation.

Finally, here is an Observer that prints to stdout when the balance changes.

    
class AccountReporter extends Observer[Account] {
    def receiveUpdate(account: Account) =
        println("Observed balance change: "+account.balance)
}

Rather than use with, I just extend the Observer trait, because I don’t have another parent class.

Here’s some code to test what we’ve done.

    
def changingBalance(account: Account) = {
    println("==== Starting balance: " + account.balance)
    println("Depositing $10.0")
    account.deposit(10.0)
    println("new balance: " + account.balance)
    println("Withdrawing $5.60")
    account.withdraw(5.6)
    println("new balance: " + account.balance)
}

var a = new Account(0.0)
changingBalance(a)

var oa = new ObservedAccount(0.0)
changingBalance(oa)
oa.addObserver(new AccountReporter)
changingBalance(oa)

Which prints out:

    
==== Starting balance: 0.0
Depositing $10.0
new balance: 10.0
Withdrawing $5.60
new balance: 4.4
==== Starting balance: 0.0
Depositing $10.0
new balance: 10.0
Withdrawing $5.60
new balance: 4.4
==== Starting balance: 4.4
Depositing $10.0
Observed balance change: 14.4
new balance: 14.4
Withdrawing $5.60
Observed balance change: 8.8
new balance: 8.8

Note that we only observe the last transaction.

Download Scala and try it out. Put all this code in one observer.scala file, for example, and run the command:

    
scala observer.scala

But Wait, There’s More!

In the next post, I’ll look at Scala’s support for Functional Programming and why OO programmers should find it interesting. In the third post, I’ll look at the specific case of concurrent programming in Scala and make some concluding observations of the pros and cons of Scala.

For now, here are some references for more information.

The Scala website, for downloads, documentation, mailing lists, etc.
Ted Neward’s excellent multipart introduction to Scala at developerWorks.
The forthcoming Programming in Scala book.

"The Seductions of Scala, Part I" by d

Sat, 21 Jan 2012 10:02:19 -0600

"The Seductions of Scala, Part I" by Computer repair 89147

Sat, 14 Jan 2012 11:14:03 -0600

First, a few disclaimers. I am a Scala novice, so any flaws in my analysis reflect on me, not Scala

"The Seductions of Scala, Part I" by most fuel efficient suv

Sat, 14 Jan 2012 01:36:21 -0600

This is programming is a good source of learning too i appreciate this very much. Nissan Pathfinder Concept SUV 2013 is a new concept of 2013 which is expected to sell very large numbers.

"The Seductions of Scala, Part I" by Breguet watches

Fri, 23 Dec 2011 21:18:34 -0600

you have made

"The Seductions of Scala, Part I" by Cheap Oakley Sunglasses Outlet

Fri, 23 Dec 2011 03:26:54 -0600

Oakley Sunglasses Hut has provided the environment for a variety of colors mountain light lens coating, with Iridium? Cheap Oakley Sunglasses Outlet with the use of harsh sunlight and reduce the balance of light transmission, so that the light reaching the eyes of athletes precisely adjusted to produce the best visual . Our G30?Best Oakley Sunglasses Lens color is popular favorite athletes want to enhance the visual contrast of a choice. Oakley VR28?Oakley Lifestyle Sunglasses Has proven to be versatile lens colors, widely used in various light conditions.Discount Oakley Sunglasses Outlet

"The Seductions of Scala, Part I" by Sale Ladies Leather Handbags

Fri, 23 Dec 2011 03:24:46 -0600

Allow phonetic typingMost of this season’s no longer the exclusive expedition Sale Ladies Leather Handbags workplace ‘Skeleton’, Black Leather Handbags they seem to be for those who like slow-paced, understand humor, and occasionally a big love like a baby girl tailor-made. . Relax pastoral style Replaced with a small square bag, Previous broad-brush woven bag,Make this a more refined shape,Striking Chromic gentle, sweet,Material is also the finest ostrich and nubuck leather treated,Ladies Leather Handbags From the inside filled with feelings of holiday joy,Gold is still the preferred destination for summer magic light,This year the popular rock but not metal, the metal line of luxury.

"The Seductions of Scala, Part I" by Gadget Bologna

Mon, 19 Dec 2011 16:08:05 -0600

thank you from Italy!

"The Seductions of Scala, Part I" by belstaff

Wed, 30 Nov 2011 19:27:10 -0600

Christopher Parr, Pursuitist belstaff CEO & EIC, is included on this great list, which also includes Luis Fernandez, Timo Weiland, Michael Macko, James Andrew and Ryan Cook. The bloggers, designers and ?? luxury marketing gurus showcased on the list share their favorite fashion brands and style advice. Parr, our very own EIC, shares his go-to style staples — which ??????? includes J.Crew, Louis Vuitton, Burberry, Belstaff, TAG Heuer, Cole Haan — adding“When traveling, I grab my Belstaff jacket and go with a belstaff jacket Barbour bag tossed over my shoulder — it’s stocked with my iPad 2, a few Cuban cigars and Johnnie Walker Black flask.”

"The Seductions of Scala, Part I" by ????

Wed, 30 Nov 2011 03:13:50 -0600

good #@@!!!!

"The Seductions of Scala, Part I" by tv show

Sat, 26 Nov 2011 10:08:47 -0600

thanks for sharing. great stuff!

"The Seductions of Scala, Part I" by koko

Fri, 25 Nov 2011 18:38:44 -0600

oakley mens antix sunglassesoakley batwolf sunglassesdiscount oakley batwolf sunglassesoakley batwolf sunglasses saleoakley mens batwolf sunglassesoakley dispatch sunglassesdiscount oakley dispatch sunglassesoakley dispatch sunglasses saleoakley mens dispatch sunglassesoakley fives squared sunglassesdiscount oakley fives squared sunglassesoakley fives squared sunglasses saleoakley mens fives squared sunglassesoakley fuel cell sunglassesdiscount oakley fuel cell sunglassesoakley fuel cell sunglasses saleoakley mens fuel cell sunglassesoakley gascan sunglassesdiscount oakley gascan sunglassesoakley gascan sunglasses saleoakley mens gascan sunglassesoakley half wire sunglassesdiscount oakley half wire sunglassesoakley half wire sunglasses saleoakley mens half wire sunglassesoakley hijinx sunglassesdiscount oakley hijinx sunglassesoakley hijinx sunglasses sale

"The Seductions of Scala, Part I" by Professional Resume

Wed, 23 Nov 2011 23:46:15 -0600

Thank you for sharing this insightful article.Also, there are lot of ways to cook and execute the all-good Professional Resume.

"The Seductions of Scala, Part I" by belstaff jackets

Tue, 08 Nov 2011 20:16:00 -0600

A star: do you believe I one day only sleep for an hour? Reporter: that you other 23 hours doing? Star: falling asleep.

"The Seductions of Scala, Part I" by Ventless Gas Logs

Sun, 06 Nov 2011 20:09:23 -0600

Such a post is what I’ve been looking for as you have detailed the necessary information on the topic.Hope I could also find articles on Ventless Gas Logs.

"The Seductions of Scala, Part I" by Calculus For Dummies

Wed, 02 Nov 2011 22:58:00 -0500

I liked how the thoughts and the insights of this article is well put together and well-written. Hope to see more of this soon like Calculus For Dummies perhaps.

"The Seductions of Scala, Part I" by erewr

Sun, 30 Oct 2011 20:26:29 -0500

Now what do you feel? Chelseajeremy scott shoes
and Manchester City are certainly no problem, Manchester United? With experience, with the coach ’s ability, it’s not a big problem, four years accounted for three, the remaining one, as I now see it, most likely for the Tottenham and Liverpool, Arsenal need to pay several times in the opponent’s ability is possible.jeremy scott wings

"The Seductions of Scala, Part I" by erfwe

Sun, 30 Oct 2011 20:23:34 -0500

onitsuka tiger mexico 66 baja

"The Seductions of Scala, Part I" by christian louboutin

Sun, 30 Oct 2011 03:36:32 -0500

Good artical,I learn something!

"The Seductions of Scala, Part I" by tv guide listings

Sat, 29 Oct 2011 03:19:13 -0500

Good article! keep up the good work!

"The Seductions of Scala, Part I" by Anna

Thu, 27 Oct 2011 03:11:30 -0500

Hm there seems to be a problem loading the images on your site, I don’t know what it is but it looks kind of strange right now. Like, text only. Maybe it’s just temporary I don’t know, but you might want to check it out…

"The Seductions of Scala, Part I" by Dirt Cheap Cameras

Tue, 25 Oct 2011 22:46:25 -0500

Such a post is what I’ve been looking for as you have detailed the necessary information on the topic.Hope I could also find articles on Dirt Cheap Cameras.

"The Seductions of Scala, Part I" by real haunted places

Tue, 25 Oct 2011 15:01:11 -0500

I have been reading about this lately but found it hard to understand. This is easier to follow so I thank you for helping clear up my confusion.

"The Seductions of Scala, Part I" by cheap north face

Tue, 25 Oct 2011 04:28:36 -0500

It is really a nice post, it is always great reading such posts, this post is good in regards of both knowledge as well as information.

"The Seductions of Scala, Part I" by north face coats

Tue, 25 Oct 2011 04:27:53 -0500

There is actually some good points on this blog some of my readers may find this useful, I must send a link, many thanks.

"The Seductions of Scala, Part I" by wordpress installation service

Fri, 21 Oct 2011 17:35:38 -0500

When it comes to feather dress, what appears in your mind? Which kind brand of down jacket do you like prefer?