Java to Scala with the Help of Experts

Many leading experts in the industry have recognised the importance of Scala and are enthusiastic to help others appreciate the language. They have written excellent reviews and teaching materials that range from broad evaluations of the language to detailed cook-books on how to use the scala language. Each one comes from a different programming background and quite likely you will find one like your own. At times we all get stuck on learning a specific topic, just don't seem to get it. We need to take a look from a fresh point of view to gain the insight we need. Here are some people who can help you do just that.

Ted Neward [1], Daniel Spiewak [2], Bill Venners [3], Dean Wampler [4]

James Iry [5], Joakim Ohlrogge [6], Dave Orme [7], A. Sundararajan [8]

Mario Gleichman [9]

There are lots of other experts in the Scala community and Scala user groups that are there ready to help you too. For example, there is a community web site for Scala, the Scala Wiki [10], where you will find information and advice from many other programmers. There you will find programming tips and links to other useful sites.

There is a growing list of books [11] on programming in Scala too.

If you find other material helpful as you moved from Java to Scala or from other languages please let us know so we can share it with other first time Scala programmers. Now some experts:-

EPFL

You will find some introductory material but mostly more advanced material written by the research team of EPFL here [12].

Dean Wampler (Object Mentor) Aspect Research Associates

Dean Wampler gives a practical introduction to the Scala programming language from the view of an experienced programmer moving from Java to Scala. You will find an excellent summary of the main capabilities of the language in his series “The Seductions of Scala”. The series is in three parts and he introduces in the following way:-

“I decided to learn Scala … 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.”

He presents key concepts clearly and then gives examples of the typical code you may write. You will find it a fun way to get started on Scala.

The Seductions of Scala

Part 1 Introduction to Language Features [13]
Part 2 Functional Programming [14]
Part 3 Concurrent Programming [15]

Bill Venners Artima

Is President of Artima and one of the co-athors of the "Programming Scala" book. He is a respected expert on the topic of Java and Scala.

In “First Steps to Scala” [16] you will be shown how you can quickly use the Scala interpreter to try out small scala programs. If you are familiar with Java it is an excellent place to start. If you are already a frequent user of one of the Java IDEs (e.g. Eclipse, NetBeans or Intellij) then you may prefer to use the development tools here [17].

This is how Bill introduces gets you started with the interpreter:

An easy way to get started with Scala is by using the Scala interpreter, which is an interactive “shell” for writing Scala expressions and programs. Simply type an expression into the interpreter and it will evaluate the expression and print the resulting value. The interactive shell for Scala is simply called scala. You use it like this:

$ scala
This is an interpreter for Scala.
Type in expressions to have them evaluated.
Type :help for more information.
scala> 
After you type an expression, such as 1 + 2, and hit return: 
scala> 1 + 2
The interpreter will print: 
unnamed0: Int = 3

You will find the complete article, First Steps to Scala, here [16].

Daniel Spiewak

Is an experienced software developer who has worked with Java, Ruby, Scala, SQL, C, C++, ML, and other languages.

Scala for Java Refugees

In this series of articles Daniel Spiewak takes a Java programmer through a carefully thought out tour of the Scala language. The journey takes you through first steps to writing sophisticated programs. Then you are taken into the fun and rewarding parts of the Scala language. The tour finishes with a thorough exploration of the unrivalled interoperability of Scala and Java. You see how to leverage existing Java libraries and switch smoothly between Java and Scala in your applications.

Some aspects have changed in the year since his first articles appeared. Tools like, Eclipse for example, have undergone major revision work adding features and stability. Frameworks such as Lift have appeared on the scene to provide significant productivity gains.

Part 1: main(String[]) – Getting started [18]
Part 2: Basic OOP - Syntax and Import [19]
Part 3: Methods and Statics – Concepts and Singleton [20]
Part 4: Pattern Matching and Exceptions – A post that draws lots of interest from readers [21]
Part 5: Traits and Types – Alternatives to interfaces. [22]
Part 6: Getting Over Java – The fun parts of Scala [23]
Part 7: Interop Between Java and Scala – The simplicity of interoperability. [24]

Ted Neward Neward & Associates

Ted Neward is the principal of Neward & Associates, where he consults, mentors, teaches, and presents on Java, Scala, .NET, XML Services, and other platforms.(ted@tedneward.com),

In his series of articles on IBM.com, “The busy Java developer’s guide to Scala”, Ted Neward shows you why he has moved on from Java, his first love, to Scala. In this series of articles he compares the traditional Java code style with what he now finds the much more concise and expressive Scala language.

What you will enjoy is the way he shows examples of everyday Java code alongside their equivalent in Scala. He will take you all the way from first steps to the hot problems of concurrency. Following him you too will see why he has found a new soul-mate in Scala.

The busy Java developer’s guide to Scala

Part 1 Functional programming for the object oriented [25]
Part 2 Class action [26]
Part 3 Don’t get thrown for a loop [27]
Part 4 Of traits and behaviors [28]
Part 5 Dead like COBOL [29]
Part 6 Implementation inheritance [30]
Part 7 Collection types [31]
Part 8 Packages and access modifiers [32]
Part 9 Building a calculator, Part 1 [33]
Part 10 Building a calculator, Part 2 [34]
Part 11 Building a calculator, Part 3 [35]
Part 12 Scala and servlets [36]
Part 13 Explore Scala concurrency [37]
Part 14 Dive deeper into Scala concurrency [38]
Part 15 Scala + Twitter = Scitter [39]
Part 16 Enhancing the Scitter library [40]

Mario Gleichmann blog Brain Driven Development

Mario gives a systematic introduction to the Scala programming language for beginners who have some programming experience. You will find a good tour of the basic language features with emphasis on the functional programming style. There are seven articles in the series.

Functional Scala

Part 1 Introduction [41]
Part 2 Functions [42]
Part 3 Functions as objects as functions [43]
Part 4 Closures [44]
Part 5 Comprehending comprehensions [45]
Part 6 Higher order functions [46]
Part 7 Functional Scala lambdas and other shortcuts [47]

A. Sundararajan Weblog

Here you will find a very useful reference for Java programmers moving to Scala. He provides a very practical mapping from Java language structures to Scala ones. In his own words it provides a “Head-Start” for anyone making the transition. As you know it normally takes a little while to become fluent in the syntax of a new language. This handy list of mappings provides a quick way to remind you of the specific syntax for equivalent language features in Java and Scala.

You will find the mapping table here [48].

Joakim Ohlrogge

In a series of posts Joakim, a Scala programmer in Sweden, shares his experiences, both the frustrating ones and the joys of discovering Scala. In the process he gives many tips and examples that are valuable to anyone learning Scala.

Phasing over from Java to Scala, his experience.

Part 1 Convert pet project to Scala [49]
Part 2 Buildr [50]
Part 3 What about tests? [51]
Part 4 Writing Specs with specs [52]
Part 5 A retrospective view [49]

In his posts Joakim also provides tips for using the Scala “nuggets”:

Post 1 Making SWT shine with Scala [53]
Post 2 Pattern Matching and Lists [54]
Post 3 Drying up widget creation [55]
Post 4 Implicits make Java blend into Scala [56]

Dave Orme

Builds on the work of Joakim to 'radically' simplify the use of SWT. In the last step of this transformation he introduces a new domain-specific language (DSL) written in Scala called XScalaWT, which is a successor to the XML-based XSWT project.

Simplifying SWT with Scala [57]

James Iry

James Iry provides a lighthearted yet provocative context to think about some advanced topics and the deeper parts

of Scala.

The Kingdom of Nerbs: [58] Discusses the relationship between objects and functions.
Martians vs Monads: Null Considered Harmful: [59] Compares Java’s null with Scala’s Option type.

Monads are Elephants (An introduction to monads in Scala.)

Part 1 [60]
Part 2 [61]
Part 3 [62]

Links:
[1] http://www.scala-lang.org/node/960#Ted
[2] http://www.scala-lang.org/node/960#Daniel
[3] http://www.scala-lang.org/node/960#Bill
[4] http://www.scala-lang.org/node/960#Dean
[5] http://www.scala-lang.org/node/960#James
[6] http://www.scala-lang.org/node/960#Joak
[7] http://www.scala-lang.org/node/960#Dave
[8] http://www.scala-lang.org/node/960#Sund
[9] http://www.scala-lang.org/node/960#Mario
[10] http://scala.sygneca.com/
[11] http://www.scala-lang.org/node/959
[12] http://www.scala-lang.org/node/197
[13] http://blog.objectmentor.com/articles/2008/08/03/the-seductions-of-scala-part-i
[14] http://blog.objectmentor.com/articles/2008/08/05/the-seductions-of-scala-part-ii-functional-programming
[15] http://blog.objectmentor.com/articles/2008/08/14/the-seductions-of-scala-part-iii-concurrent-programming
[16] http://www.artima.com/scalazine/articles/steps.html
[17] http://www.scala-lang.org/node/91#ide_plugins
[18] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-1
[19] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-2
[20] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-3-methods-and-statics
[21] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-4
[22] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5
[23] http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-6
[24] http://www.codecommit.com/blog/java/interop-between-java-and-scala
[25] http://www.ibm.com/developerworks/java/library/j-scala01228.html?S_TACT=105AGX02&S_CMP=EDU
[26] http://www.ibm.com/developerworks/java/library/j-scala02198.html?S_TACT=105AGX02&S_CMP=EDU
[27] http://www.ibm.com/developerworks/java/library/j-scala03268.html?S_TACT=105AGX02&S_CMP=EDU
[28] http://www.ibm.com/developerworks/java/library/j-scala04298.html?S_TACT=105AGX02&S_CMP=EDU
[29] http://www.ibm.com/developerworks/java/library/j-cobol.html?S_TACT=105AGX02&S_CMP=EDU
[30] http://www.ibm.com/developerworks/java/library/j-scala05298.html
[31] http://www.ibm.com/developerworks/java/library/j-scala06278.html
[32] http://www.ibm.com/developerworks/java/library/j-scala07298.html
[33] http://www.ibm.com/developerworks/java/library/j-scala08268.html
[34] http://www.ibm.com/developerworks/java/library/j-scala10248.html?S_TACT=105AGX02&S_CMP=EDU
[35] http://www.ibm.com/developerworks/java/library/j-scala11218.html?S_TACT=105AGX02&S_CMP=EDU
[36] http://www.ibm.com/developerworks/java/library/j-scala12228.html?S_TACT=105AGX02&S_CMP=EDU
[37] http://www.ibm.com/developerworks/java/library/j-scala02049.html?S_TACT=105AGX02&S_CMP=EDU
[38] http://www.ibm.com/developerworks/java/library/j-scala04109.html?S_TACT=105AGX02&S_CMP=EDU
[39] http://www.ibm.com/developerworks/java/library/j-scala05059.html?S_TACT=105AGX02&S_CMP=EDU
[40] http://www.ibm.com/developerworks/java/library/j-scala06029.html?S_TACT=105AGX02&S_CMP=EDU
[41] http://gleichmann.wordpress.com/2010/10/28/functional-scala-introduction/
[42] http://gleichmann.wordpress.com/2010/10/31/functional-scala-functions/
[43] http://gleichmann.wordpress.com/2010/11/08/functional-scala-functions-as-objects-as-functions/
[44] http://gleichmann.wordpress.com/2010/11/15/functional-scala-closures/
[45] http://gleichmann.wordpress.com/2010/11/21/functional-scala-comprehending-comprehensions/
[46] http://gleichmann.wordpress.com/2010/11/28/high-higher-higher-order-functions/
[47] http://gleichmann.wordpress.com/2010/12/05/functional-scala-lambdas-and-other-shortcuts/
[48] http://blogs.sun.com/sundararajan/entry/scala_for_java_programmers
[49] http://johlrogge.wordpress.com/2008/10/01/phasing-over-from-java-to-scala-retrospect-1/#more-102
[50] http://johlrogge.wordpress.com/2008/09/02/phasing-over-from-java-to-scala-pt-2-buildr/
[51] http://johlrogge.wordpress.com/2008/09/10/phasing-over-from-java-to-scala-pt-3-what-about-the-tests/
[52] http://johlrogge.wordpress.com/2008/09/14/phasing-over-from-java-to-scala-pt-4-writing-specs-with-specs/#more-80
[53] http://johlrogge.wordpress.com/2009/01/06/making-swt-shine-with-scala/#comment-150
[54] http://johlrogge.wordpress.com/2008/10/06/scala-nugget-pattern-matching-and-lists/
[55] http://johlrogge.wordpress.com/2009/01/14/drying-up-widget-creation/#more-143
[56] http://johlrogge.wordpress.com/2008/09/11/scala-nugget-implicits-to-make-java-blend-into-scala/
[57] http://www.coconut-palm-software.com/the_new_visual_editor/doku.php?id=blog:simplifying_swt_with_scala
[58] http://james-iry.blogspot.com/2007/08/kingdom-of-nerbs.html
[59] http://james-iry.blogspot.com/2007/08/martians-vs-monads-null-considered.html
[60] http://james-iry.blogspot.com/2007/09/monads-are-elephants-part-1.html
[61] http://james-iry.blogspot.com/2007/10/monads-are-elephants-part-2.html
[62] http://james-iry.blogspot.com/2007/10/monads-are-elephants-part-3.html