Scala 101: Introduction

• integrated. Scala code can be executed in the Java VM. Existing Java source code can be used with Scala. Instead of reinventing the wheel Scala bases on established technologies.
  

• Object oriented. Scala is a object oriented programming language. But the possibilities goes beyond what Java offers.
  

• Functional and imperativ. Scala combines aspects of functional and imperative programming languages. The programmer can choose between the two depending on his current needs
  

• Concise. Typical Scala source code is shorter than the homologous Java code. This means less writing and reading for the programmer. If necessary it's possible to write more verbose source code, for example in complex parts of aprogram.
  

• Customizable. Scalas syntax has been developed to allow easy customisations which nicely integrate into the language. It's possible to create constructs which are similair to the language's keywords. Scala is very suitable for the development of domain specific languages (DSLs).
  

On the one hand Scala's syntax is terse, on the other hand it's powerful. In comparision with Java less source code has to be written to express the same idea.

Example 2. Output of the primes between 1 and 100

object SyntaxDemo {
  def isPrime(n: Int) = (1 to n).toList.count(n % _ == 0) == 2

  def main(args: Array[String]): Unit =
        (1 to 100).filter(isPrime).foreach(println)
}

	Note
	Of course, there are far better methods to find primes than this naive implementation. The example's purpose is to show that it's possible to write easy to understand and in comparision with Java shorter source code.

Scala is a type safe language. This means that It's necessary to write down types for variables, parameters, etc. Often this information is redundant, though. In Scala you only need to write down the really necessary type information, Scala is infering the left out parts for you. This feature is called type inference.

val v = "Hey, Scala knows that I'm a String"
println(v) 

If you wish you can write down the optional type information. In complicated parts of a program this helps to improve the readability. Besides it can help the compiler to infer the types of complicated expressions.

val v : String = "Hey, Scala knows that I'm a String"
println(v) 

In Java there are classes and interfaces. In Scala there are classes, modules and traits.

The so called "case class" is a simplification of a certain use case of classes. Often classes with read-only access to certain information are needed which offer additional operations to work with the data.

public class JavaPerson{
    private final String firstname;
    private final String lastname;

    public JavaPerson(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }

    public String getFirstname() {
        return firstname;
    }

    public String getLastname() {
        return lastname;
    }
} 

The Java class above can be replaces by a simple case class. The following case class has the same functionality as the example above:

case class ScalaPerson(firstname:String, lastname:String)
                        

In functional languages functions play a central role. In imperative languages like Java data takes this role. Scala interweaves both worlds to one.

Scala allows to reference functions. For example it's possible to hand functions over to other functions as parameter. Anonymous functions are possible, as well. The following example demonstrates the use of functions in Scala:

object FoodDemo {
  val food = "Bananas" :: "Bred" :: "Orange juice" :: Nil

  def main(args:Array[String]) = {
    food.foreach(thing => println("Please buy " + thing))
  }
}
                        

The construct thing => println("Please buy " + thing) isa (anonymous) function, which is applied to every element of the list food. The output of the program is:

Please buy Bananas
Please buy Bred
Please buy Orange juice
                    

Scala's standard library offers an elegant concept of parallel programming. Messages are exchanged between several actors / participants. The messages of each participant are collected and worked on one after another. Two actors can work in parallel on their messages.

It's interesting that usually locks are not needed. This reduces the vulnerability to failures. And it eases the development of event driven applications.

case class Add(n:Int)
case class Substract(n:Int)
case class Print()
case class Shutdown()

class CalculatingActor extends Actor {
  import Actor._

  var result : Int = 0

  def act() = loop{
    react{
      case Add(n:Int) => result = result + n
      case Substract(n:Int) =>  result = result - n
      case Print() => println(result)
      case Shutdown() => exit()
    }
  }
} 

This simple actor shows how Scala's concept of actors can help to develop asynchronous, message based systems. In the example add and substraction tasks are submitted and calculated asynchronously.

The following web sites contain important information about Scala and related topics.

This is a list of the books which are about Scala. Some of them are still under development but will be available soon.