5 Things a Java developer needs to know about Scala

Friday, December 15. 2006

5 Things a Java developer needs to know about Scala

I've spent the last month working with Scala. I'm a hardcore ex-Java guy (I've written hundreds of thousands of lines of Java code over the last 10+ years.) Scala has much of Java's goodness, much of Ruby's goodness, and works with the existing Java infrastructure (Ant, Eclipse plugin, Tomcat, Java class libraries, etc.)

Here's a list of what a Java guy should know about Scala:

Scala programs are byte-code compatible with Java code. Scala code can call Java code, implement Java interfaces, subclass Java classes and can be called from Java code. The guy who wrote the Scala compiler wrote JavaC. Really, they work perfectly together and Scala code runs as fast as Java code.
Scala code is more compact and more expressive. For example: List<Foo> tmp = new ArrayList<Foo>(); for (Other tmpOther : otherList) { tmp.add(new Foo(tmpOther)); } becomes: otherList.map{i => new Foo(i)} The creation of the temporary variable for the returned array is done implicitly (and it's strongly typed.) You worry about how to "map" one array to another rather than spending time declaring temporary variables or describing looping. Note that you didn't have to "type" anything. Scala is strongly typed, just like Java, but if the compiler can figure it out, you don't need to repeat the typing information.
You can write code the way you used to and migrate to "functional" thinking as your brain shifts. It's not a dive into the deep end like Haskell or OCaml. The initial learning curve is short and the continued learning curve is gradual. Plus, most other Java coders can look at your Scala code and understand it until you get into some pretty hardcore Scala constructs.
XML is an integral part of Scala. XML is legal syntax within the language. For example: def addressNode(line1 : String,line2 : String, city : String, state : String, country : String) = { <address> <line>{line1}</line> {if (line2 != null) <line>{line2}</line> else Text("")} <city>{city}</city> <state>{state}</state> <country>{country}</country> </address> } How about counting all the addresses that are from a particular country: def countryCount(toMatch : String, xml : Seq[Node]) = { (for (val addr <- xml \\ "address"; val country <- addr \\ "country" ; country.text == toMatch) yield country).length } Note that other than the "\\" to look for nodes in an XML document, everything else makes "sense." The "\\" "operator" is not part of the language, but a method on XML Nodes (and sequences of Nodes), but the compiler "does the right thing" and makes the 'node \\ string' construct readable and (IMHO) natural. You can look at the code as a Java guy and understand what it does without freaky loop constructs, intermediate variables for XPath, etc.

Put another way, the English description and the code match each other:
- for each of the address tags
- find the country tag
- if the country matches, yield it to the length (count)
Mixins/Traits
Ever wish you could add methods to an interface so that every class that implemented the interface got those methods for free? Interfaces bring constants, but not methods in Java. Scala has "traits" which all your to define functions (what Java calls methods) and variables that get automatically added to classes when you extend the class with the trait. It's an excellent form of code re-use.

So, if you're looking for an alternative to Java because you've reached the limit of what you can do with Java, give Scala a try.

Posted by David Pollak in Scala at 08:52 | Comments (16) | Trackbacks (0)

Trackbacks

Trackback specific URI for this entry

No Trackbacks

Comments

Display comments as (Linear | Threaded)

Cracking start! I would add a little on how constructors work - it's a bit a of a surprise to see that the master constructor is defined as part of the class definition!

#1 Raph (Homepage) on 2006-12-17 06:03 (Reply)

Think of constructors in Scala the way you would arguments to a function. The code inside has access to those values.

#1.1 Chris on 2007-01-05 15:45 (Reply)

I've been using Scala for some time now, and although the language has great ideas it also has quite annoying troubles. The double approach to parametric polymorphism (both OO-style and functional style) means that some type errors are very hard to understand. Views can be very confusing, mixins sometimes seemingly randomly are not allowed and compiler still has bugs in some border cases. The conceptual problems are known and are described in Martin's paper about Scala, while the buggy compiler comes from too small user base.

All in all it's considerably more complex than Java or even Ruby, so there definitely will be some troubles with adoption. You could easily cut down on language features without losing much expressiveness. Case classes and matching are genius, high order functions and closures are a must-have, but the rest of the stuff become increasingly redundant.

Just my 2 cents

#2 Jevgeni Kabanov on 2006-12-18 00:08 (Reply)

Jevgeni,

I've got a ton of respect for what you've done with Aranea http://araneaframework.org/ I want to disagree a bit with you.

Scala's traits rule the universe for me. Traits allow me to compose a lot of complex functionality into classes.

Scala's type inferencing works well for me and cuts down a lot of code clutter. Combined with the parametric polymorphism, I've been able to write a bunch of "duck-type-feeling" code that's actually type-safe.

When I started with Ruby, I wrote Java-style code in Ruby and gradually worked Rubyisms into my code.

I'm early to Scala, but I've been writing Ruby-style code and gradually working into Scala-style code.

IMHO, A developer can write Java-style code in Scala pretty easily. Over time, the developer will become more Scalaish in their constructs.

Thanks for your post!

David

#2.1 David Pollak (Homepage) on 2006-12-18 09:19 (Reply)

Hey, it's a big world and there is enough space for all kinds of approaches. I was just expressing my (personal and limited) experience with Scala. I played with functional languages for quite some time and became a bit bitter about the seemingly beautiful, but rigorous static type systems. At the moment I'm doing research on the soft typing, which is a mixture of dynamic and static typing. I think this is where the future lies -- a language that can be statically typed when possible, and dynamically when not.

Scala is definitely very cool, I loved it when I first have seen it, and I have great respect for its creator. I think that the ideas from Scala will gradually float into Java (e.g. Martin Odersky was one of the guys behind Generics), but I don't believe Scala itself will gain great acceptance. besides I still think that web is inherently Object-Oriented, and functional approach has much more point in the business layer.

In any case it is definitely worth seeing what will come out from your effort. We are welcoming the competition, as our motto is to let programmers use any approach possible in any application

Good luck!

#2.1.1 Jevgeni Kabanov on 2006-12-18 10:01 (Reply)

"Scala code runs as fast as Java code"
"Scala code is more compact and more expressive"

If you read the Scala programs on the computer language shootout you'll see that they drop-back to using while-loops instead of for-comprehensions - just to get the times down.

#3 Isaac Gouy on 2007-01-01 10:04 (Reply)

The Scala programs in the shoot-out were not written by me or other people on the Scala team. I think if they had been written in a tail-recursive style, the times would have been just the same as with while-loops. That said, I don't think shootout data are very significant in any case.

#3.1 martin odersky (Homepage) on 2007-01-05 02:20 (Reply)

"The Scala programs in the shoot-out were not written by me or other people on the Scala team."
True enough, but why is that relevant?

"a tail-recursive style ... just the same as with while-loops"
Would that actually be "more compact" or "more expressive" or would it really be just the same as while-loops?

"I don't think shootout data are very significant in any case"
I whole-heartedly agree

Does that take us further than "your application is the ultimate benchmark"?

#3.1.1 Isaac Gouy on 2007-01-08 10:02 (Reply)

Tail recursive functions are normally compiled into the same bytecodes as while-loops, so the times should be really just the same.

#3.1.1.1 Anonymous on 2007-01-09 06:43 (Reply)

"Tail recursive functions ... the times should be really just the same"
The times of for-comprehensions are not.

#3.1.1.1.1 Isaac Gouy on 2007-01-09 09:52 (Reply)

I have a question.

Scala support Design by Contract?

Thanks

#4 jvel on 2007-01-08 03:20 (Reply)

Not this I know of.

#4.1 David Pollak (Homepage) on 2007-01-08 09:05 (Reply)

Scala defines the characters eol and semicolon as statement separators. So while the Java code below is legal:

interface Foo {
}class test {
}

the following Scala code is not:

trait Foo {
}object test {
}

#5 Stephane Micheloud on 2007-01-08 06:59 (Reply)

2 things a Java Developer should know:

You should try out Groovy. It is far more expressive and you do not need to compile the source code, but you can if you wish.
Many advantages mentioned this article are also valid for Groovy!!!

http://groovy.codehaus.org

if you are still not convinced...

check out: groovy on rails

http://grails.codehaus.org

#6 joe on 2007-11-12 11:58 (Reply)

I tried Groovy and pretty much think it's the worst of all possible worlds. It's got all of Ruby's badness combined with all of Java's badness.

I find Scala to be significantly more expressive than Groovy, especially when dealing with XML and other sets of data. I like lift a whole lot better than Grails because lift abstracts away much more of the HTTP request/response cycle and is a lot more secure (then again... I'm biased

#6.1 David Pollak (Homepage) on 2007-11-15 11:28 (Reply)

(I'm a Scala user)

Good Java developers will write:

List foos = map( others, new Mapper() {
public Foo map(Other other) { return new Foo(other); }
}

and reuse the Mapper.

Cheers
Stephan
http://twitter.com/codemonkeyism

#7 Stephan Schmidt (Homepage) on 2009-04-17 00:34 (Reply)

Add Comment

Name
Email
Homepage
In reply to
Comment	Enclosing asterisks marks text as bold (word), underscore are made via _word_. Standard emoticons like :-) and ;-) are converted to images. To prevent automated Bots from commentspamming, please enter the string you see in the image below in the appropriate input box. Your comment will only be submitted if the strings match. Please ensure that your browser supports and accepts cookies, or your comment cannot be verified correctly. Enter the string from the spam-prevention image above:
	Remember Information? Subscribe to this entry