Scala (programming language)

Scala

File:Scala logo.png
Paradigm	Multi-paradigm: functional, object-oriented, imperative
Appeared in	2003
Designed by	Martin Odersky
Developer	Programming Methods Laboratory of EPFL
Stable release	2.7.7 (October 28, 2009)
Typing discipline	static, strong, inferred, structural
Influenced by	Java, Pizza, Haskell, Erlang, Standard ML, Objective Caml, Smalltalk, Scheme
Website	www.scala-lang.org

Scala (pronounced /ˈskɑːlə, ˈskeɪlə/) is a multi-paradigm programming language designed to integrate features of object-oriented programming and functional programming. The name Scala stands for "scalable language", signifying that it is designed to grow with the demands of its users.

Platforms and license

Scala runs on the Java platform (Java Virtual Machine) and is compatible with existing Java programs. It also runs on Java Platform, Micro Edition Connected Limited Device Configuration. An alternative implementation exists for the .NET platform, but it has not been kept up to date.

Scala has the same compilation model as Java and C# (separate compilation, dynamic class loading), so Scala code can call Java libraries (or .NET libraries in the .NET implementation).

Scala's operational characteristics are the same as Java's. The Scala compiler generates byte code that is nearly identical to the Java compiler. In fact, you can decompile Scala code to readable Java code, with the exception of certain constructor operations. To the JVM, Scala code and Java code are indistinguishable. The only difference is a single extra runtime library, scala-library.jar.

The Scala software distribution, including compiler and libraries, is released under a BSD license.

History

The design of Scala started in 2001 at the École Polytechnique Fédérale de Lausanne (EPFL) by Martin Odersky, following on from work on Funnel, a programming language combining ideas from functional programming and Petri nets. Odersky had previously worked on Generic Java and javac, Sun's Java compiler. Scala was released late 2003 / early 2004 on the Java platform, and on the .NET platform in June 2004. A second version of the language, v2.0, was released in March 2006.

As of Oct 2009, the latest release is version 2.7.7. Features planned for Scala 2.8 include an overhaul of the Scala collections library, named and default parameters for methods, package objects, and continuations.

Object-oriented features

Scala is a pure object-oriented language in the sense that every value is an object. Data types and behaviors of objects are described by classes and traits. Class abstractions are extended by subclassing and by a flexible mixin-based composition mechanism to avoid the problems of multiple inheritance.

Functional programming

Scala also supports functional programming. The language provides a lightweight syntax for defining anonymous functions, supports higher-order functions, allows functions to be nested, and supports currying. Using the keyword "lazy" defers the initialization of a variable until this variable is used. Evaluation of delimited continuations will be supported in version 2.8.

Scala's case classes and its built-in support for pattern matching model Algebraic data types used in many functional programming languages.

Tail call optimization is not supported completely, because the JVM lacks tail call support. In simple cases, the Scala compiler can optimize tail calls into loops.

An implementation of a Quicksort algorithm in functional style, for comparison with the Erlang Quicksort example:

 def qsort(list: List[Int]): List[Int] = 
   list match {
     case Nil => Nil
     case pivot::tail => qsort(tail.filter(_ < pivot)) ::: pivot :: qsort(tail.filter(_ >= pivot))
   }

Static typing

Scala is equipped with an expressive static type system that enforces the safe and coherent use of abstractions. In particular, the type system supports:

• generic classes,
• variance annotations,
• upper and lower type bounds,
• classes and abstract types as object members,
• compound types,
• explicitly typed self references,
• views, and
• polymorphic methods.

Extensibility

The design of Scala acknowledges the fact that, in practice, the development of domain-specific applications often requires domain-specific language extensions. Scala provides a unique combination of language mechanisms that make it easy to smoothly add new language constructs in the form of libraries:

• any method may be used as an infix or postfix operator, and
• closures are constructed automatically depending on the expected type (target typing).

A joint use of both features facilitates the definition of new statements without extending the syntax and without using macro-like meta-programming facilities.

Software using Scala

Lift is a free web application framework that aims to deliver benefits similar to Ruby on Rails. The use of Scala means that any existing Java library and Web container can be used in running Lift applications.

In April 2009 Twitter announced they had switched large portions of their backend from Ruby to Scala and intended to convert the rest. In addition, Wattzon has publicly been noting that its entire platform has been written from the ground up in Scala.

Foursquare (service) uses Scala and Lift.

"Hello world" example

Here is the classic Hello world program written in Scala:

 object HelloWorld extends Application {
   println("Hello, world!")
 }

or

 object HelloWorld {
   def main(args: Array[String]) {
     println("Hello, world!")
   }
 }

Notice how similar it is to the stand-alone Hello World application for Java. A notable difference is that nothing is declared to be static; the singleton created by the object keyword is used instead.

Assuming the program is saved in a file named HelloWorld.scala, it can then be compiled from the command line:

> scalac HelloWorld.scala

To run it:

> scala -classpath . HelloWorld

This is analogous to how a Java "hello world" program is compiled and run. Indeed, Scala's compilation and execution model is identical to that of Java, making it compatible with Java build tools such as Ant.

It is also possible to feed this program directly into the Scala interpreter, using the option -i (to load code from the file) and the option -e (to execute additional code needed to actually invoke the HelloWorld object's method):

> scala -i HelloWorld.scala -e 'HelloWorld.main(null)'

Testing

There are some ways to test code in Scala:

• ScalaTest
• ScalaCheck, a library similar to Haskell's QuickCheck
• specs, a Behavior driven development library for Scala
• JUnit

The built-in Scala library SUnit is deprecated and will be removed in version 2.8.0, see SUnit documentation.

See also

• Lift, a web application framework for scala
• Clojure

Bibliography

• Odersky, Martin; Spoon, Lex; Venners, Bill (November 26, 2008), Programming in Scala: A Comprehensive Step-by-step Guide (1st ed.), Artima Inc, pp. 776, ISBN 0981531601, http://www.artima.com/shop/programming_in_scala 
• Pollak, David (May 25, 2009), Beginning Scala (1st ed.), Apress, pp. 776, ISBN 1430219890, http://www.apress.com/book/view/9781430219897 
• Subramaniam, Venkat (July 28, 2009), Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (1st ed.), Pragmatic Bookshelf, pp. 250, ISBN 193435631X, http://www.pragprog.com/titles/vsscala/programming-scala 
• Wampler, Dean; Payne, Alex (September 25, 2009), Programming Scala (1st ed.), O'Reilly Media, pp. 250, ISBN 9780596157746, http://oreilly.com/catalog/9780596157746/ 

External links

• Scala website
• Simply Scala online version of the Scala REPL - allows you to try out Scala using a web browser
• Scala Wiki
• Literate Programs - Scala
• The Scala Search Engine
• Lift Web Framework
• Podcast Interview with Martin Odersky on Scala
• Scala Presentation From The Googleplex (video) - given by Martin Odersky, creator of the language; accompanying slides from the talk
• Scalaz
• Scala community blogs
• Lift Slides from Pollak's lift video, contains a presentation of Scala
• Scala articles directory
• Scala for Java Refugees