An Introduction to the Scala Programming Language

# An Introduction to the Scala Programming Language

Oct 18, 2013

Tobias Pfeiffer

<small>*These slides: http://tinyurl.com/scala-talk-jp*</small>

---

# Contents

1. Background
2. Scala in the Java World
3. Scala Core Concepts
4. Selected Scala Language Features

---

# 1. Background

---

# History

* Developed since 2001 at EPFL (École polytechnique fédérale de Lausanne), Switzerland  
  <img src="figs/640px-Swiss_army_knife_closed_20050612.jpg" style="height:150px;" alt="" />
  <img src="figs/800px-Victorinox_Swiss_Army_Men's_241424_Dive_Master_500_Chrono_Black_Dial_Watch-16.jpg" style="height:150px;" alt="" />  
  <small class="imgsource">Source: Wikimedia</small>
* Project Head: Martin Odersky (father of Java Generics)  
  <img src="figs/martin.jpg" style="height:180px;" alt="" />  
  <small class="imgsource">Source: epfl.ch</small>
* Odersky-founded *Typesafe Inc.* provides support, training, consulting, ...

---

# History

* Developed since 2001 at EPFL (École polytechnique fédérale de Lausanne), Switzerland (with a bit of German horsepower)  
  <img src="figs/640px-Swiss_army_knife_closed_20050612.jpg" style="height:150px;" alt="" />
  <img src="figs/800px-Victorinox_Swiss_Army_Men's_241424_Dive_Master_500_Chrono_Black_Dial_Watch-16.jpg" style="height:150px;" alt="" />
  <img src="figs/800px-BMW_320d_Luxury_Line.jpg" style="height:150px;" alt="" />  
  <small class="imgsource">Source: Wikimedia</small>
* Project Head: Martin Odersky (father of Java Generics)  
  <img src="figs/martin.jpg" style="height:180px;" alt="" />  
  <small class="imgsource">Source: epfl.ch</small>
* Odersky-founded *Typesafe Inc.* provides support, training, consulting, ...

---

# Learning Scala

## Online

* [scala-lang.org](http://www.scala-lang.org/) has documentation, API docs, tutorials, ...
* List of books about Scala at [scala-lang.org/old](http://www.scala-lang.org/old/node/959)

## Offline

---

# Users

## Who uses Scala?

* Twitter  
  (for concurrent systems, storage, search, ...)
* LinkedIn  
  (concurrency using Actors)
* Sony Pictures Imageworks  
  ("middle-tier software to manage terabytes of digital assets")
* Foursquare  
  (Lift-powered website)

---

# 2. Scala in the Java World

---

# Scala in the Java ecosystem

* Scala is compiled to JVM bytecode ("write once, run everywhere"):
  <table class="small-code">
<thead>
<tr><th>Java</th><th>Scala</th></tr>
</thead>
<tbody>
<tr>
<td>
```bash
$ javac HelloWorldJavaApp.java```
</td>
<td>
```bash
$ scalac HelloWorldScalaApp.scala```
</td>
</tr>
<tr>
<td>
```bash
$ java HelloWorldJavaApp
Hello World!```
</td>
<td>
```bash
$ java HelloWorldScalaApp
Hello World!```
</td>
</tr>
</tbody>
</table>
* Full two-way compatibility with Java libraries
* Build tools such as Maven can be used
* Scala also comes with a REPL (read–eval–print loop) for interactive development

---

# Scala *can* look like Java

<table class="smaller-code">
<thead>
<tr><th>Java</th><th>Scala</th></tr>
</thead>
<tbody>
<tr>
<td class="add-right-space">  
```java
class ComplexJ {
  public double real, imag;
  // Constructor
  public ComplexJ(double r, double i) {
    real = r;    imag = i;
  }
  // Add other Complex and return new
  public ComplexJ add(ComplexJ other) {
    return new ComplexJ(real + other.real,
            imag + other.imag);
  }
}

class ComplexJRunner {
  public static void main(String args[]) {
    // add random complex numbers 
    ComplexJ x = new ComplexJ(0, 0);
    for (int r = 1; r <= 3; r++) {
      double i = Math.random() * 5;
      x = x.add(new ComplexJ(r, i));
    }
    System.out.println("Result: " +
      "(" + x.real + "+" + x.imag + "i)");
  }
}
```
</td>
<td>
```scala
class ComplexS(var real: Double,
               var imag: Double) {        //(1)
  // This is actually the constructor.
  // real and imag are now public members. 
  // Don't think about this for now.

// Add other Complex and return new
  def add(other: ComplexS): ComplexS = {  //(2)
    return new ComplexS(real + other.real,
            imag + other.imag);
  }
}

object ComplexSRunner {
  def main(args: Array[String]): Unit = { //(3)
    // add random complex numbers 
    var x: ComplexS = new ComplexS(0, 0);
    for (r <- 1 to 3) {                   //(4)
      var i: Double = Math.random() * 5;
      x = x.add(new ComplexS(r, i));
    }
    println("Result: " +
      "(" + x.real + "+" + x.imag + "i)");
  }
}
```
</td>
</tr>
</tbody>
</table>

---

# ... with less clutter

<table class="smaller-code">

<tbody>
<tr>
<td class="add-right-space" style="vertical-align:top;">  
```java
class ComplexJ {
  public double real, imag;
  // Constructor
  public ComplexJ(double r, double i) {
    real = r;    imag = i;
  }
  // Add other Complex and return new
  public ComplexJ add(ComplexJ other) {
    return new ComplexJ(real + other.real,
            imag + other.imag);
  }
}

class ComplexJRunner {
  public static void main(String args[]) {
    // add random complex numbers 
    ComplexJ x = new ComplexJ(0, 0);
    for (int r = 1; r <= 3; r++) {
      double i = Math.random() * 5;
      x = x.add(new ComplexJ(r, i));
    }
    System.out.println("Result: " +
      "(" + x.real + "+" + x.imag + "i)");
  }
}
```
</td>
<td>
```scala
class ComplexS(var real: Double,
               var imag: Double) {
  // Add other Complex and return new
  def add(other: ComplexS) = {           // (1)
    new ComplexS(real + other.real,      // (2)
            imag + other.imag)
  }
}

object ComplexSRunner {
  def main(args: Array[String]) = {
    // add random complex numbers 
    var x = new ComplexS(0, 0)
    for (r <- 1 to 3) {
      var i = Math.random * 5            // (3)
      x = x add new ComplexS(r, i)       // (4)
    }
    println("Result: " +
      "(" + x.real + "+" + x.imag + "i)")
  }
}
```
<small>
<ol start="0" style="margin:0;">
<li>Drop semicolons (yay!)</li>
<li>Use type inference</li>
<li>Omit `return`, use last statement instead</li>
<li>Drop brackets for no-argument methods</li>
<li>Drop brackets and dot for one-argument methods</li>
</ol>
</small>
</td>
</tr>
</tbody>
</table>

---

# 3. Scala Core Concepts

---

# Embrace Functional Programming Concepts

* A *function* *f* maps one *value* *x* to another *value* *f(x)*.
* It does not change *x* or anything in the global state.
* Embrace **immutable state** and **functions without side effects** to
  * argue about program correctness
  * make testing easier
  * parallelize execution.
* Prefer `val`s over `var`s:
  ```scala
val x = 5
x = 3  // does not compile
```

---

# Use Statement Return Values

* **All** statements have well-typed return values. (But some return `Unit`.)
  ```scala
5                                  // returns Int
a == 0                             // returns Boolean
List(1, 2.5, 3L)                   // returns List[Double]
List(false, 1, "two")              // returns List[Any]
if (a % 2 == 0) "even" else "odd"  // returns String
println("hello")                   // returns Unit
```
* Initialization instead of reassignment:  
  <table>
<thead>
<tr><th>Bad</th><th>Good</th></tr>
</thead>
<tbody>
<tr>
<td class="add-right-space">  
```scala
var x = 0
if (...)   x = 7
else       x = 8
```
</td>
<td>  
```scala
val x =
  if (...) 7
  else     8
```
</td>
</tr>
<tr>
<td class="add-right-space">
```scala
var list: List[Int] = Nil
for (i <- 1 to 10)
  list = list :+ someFun(i)
```
</td>
<td>
```scala
val list =
  for (i <- 1 to 10)
  yield someFun(i)
```
</td>
</tr>
</tbody>
</table>

---

# Functions as First Class Citizens

* Functions are values like everything else.
* Return functions, pass them as parameters, store functions in arrays, ...
* Dangerous: You get used to it ;-)

```scala
// define function and assign to variable
val f = (x: Int) => x * x  // f has type (Int => Int)
f(4)  // 16

// very shorthand notation for one-parameter functions
val g: Int => Int = _ % 3
g(4)  // 1

// pass function as a parameter
def doSomethingWithFive(h: Int => Int) = h(5)
doSomethingWithFive(f)  // 25

// default and named arguments in methods
def sum(a: Int, b: Int = 7, c: Int = 8) = a + b + c
sum(3, c=5)  // = sum(3, 7, 5) = 15
doSomethingWithFive(sum(_))  // = sum(5) = sum(5, 7, 8) = 20
```

---

# Application: List Transformations

* Filtering and transforming lists gets plain fun:
  ```scala
val list = List(2.3, -7.1, 8.9, -4.0)
   
  list.sortBy(i => i.abs)  // List(2.3, -4.0, -7.1, 8.9)
  // List[A].sortBy[B](f: A => B with Ordering): List[A]

list.map(i => i * i)     // List(5.29, 50.41, 79.21, 16.0)
  // List[A].map[B](f: A => B): List[B]

list.filter(_ > 0)       // List(2.3, 8.9)
  // List[A].filter(f: A => Boolean): List[A]

list.partition(_ > 3)    // (List(8.9),List(2.3, -7.1, -4.0))
  // List[A].partition(f: A => Boolean): (List[A], List[A])
```
* Sometimes list comprehensions might be more readable, though:
  ```scala
for (x <- list) yield x * x        // same as .map() above
for (x <- list if x > 0) yield x   // same as .filter() above
```

---

# Pure Object-Oriented Language

* Every value is an object.
* Every operation on a value is a method call.
* (Java counter-examples: `1 + 2` or `list[i]`)
* This concept is made usable via:
  1. Allow special characters in method names:  
    It is possible to define methods `+`, `/`, `+=`, `==` etc.
  2. Drop brackets and dot for one-argument methods. (remember?)
 
 ```scala
(6.+(5)).==(11)  // equivalent to: 6 + 5 == 11
list.apply(3)    // equivalent to: list(3)
```
* **NB.** There is *no* rule saying: "You *have* to use special characters"!  
  (Some library developers got that wrong...)
  ```scala
:/("localhost", 8080) / "api" <<?
  Map("key" -> "val") <:<
  Map("Accept" -> "text/xml") >>>
```

---

# 4. Selected Scala Language Features

---

# Immutable Objects: Case Classes

* Assumption: Immutable objects only defined by constructor arguments.
* Get `==`, `hashCode`, `toString` etc. for free.
* Maybe the "better tuples".
* Perfectly suited for pattern matching

```scala
case class User(age: Int, name: String)
val u = User(27, "name")  // no "new" necessary!
if (u.age >= 18)
  println("user " + u.name + " is over 18")
```

---

# Compose Functionality: Traits

* Traits marry interfaces with partial implementations.
* Ideal for cross-cutting concerns, or to avoid complex inheritance hierarchies.

<div class="small-code">
```scala
abstract class Bird

trait Swimming {
  def swim() = println("I'm swimming")
}
class Penguin     extends Bird with Swimming

trait Flying {
  def flyMessage: String  // needs to be implemented in subclasses
  def fly() = println(flyMessage)
}
class Frigatebird extends Bird with Flying {
    val flyMessage = "I'm an excellent flyer"
}

class Pigeon      extends Bird with Swimming with Flying {
    val flyMessage = "I'm a good flyer"
}

def catchBird(bird: Flying) = { ... }  // Penguin can't go in here
```
</div>
<small class="imgsource">from http://joelabrahamsson.com/learning-scala-part-seven-traits/ </small>

---

# XML as a Native Data Type

```scala
val username = "a>&b"

val xml = <div><a href="/login">Hello {username}!</a></div>
  // <div><a href="/login">Hello a&gt;&amp;b!</a></div>

xml \ "a" \ "@href" map (_.text)  // List("/login")
```

---

# Options

Many functions return an `Option[A]` if there is *maybe* a value.

An `Option[A]` is either a `Some[A]` or `None`.

```scala
val head: Option[Int] = List(1, 2, 3).headOption

if (head.isDefined) println("head: " + head.get)  // be careful

head.getOrElse(27)           // nice for assuming default value

head.map("head: " + _)                        // Option[String]
```

---

# Pattern Matching <small>"`switch` on Steroids"</small>

<div class="small-code">
```scala
abstract class User
case class NormalUser(age: Int, name: String) extends User
case class AdminUser(name: String) extends User
val users: List[User] = List(NormalUser(14, "alice"), NormalUser(24, "bob"),
                             AdminUser("charlie"))

// check if Option[A] is Some[A] or None
users.headOption match {
  case Some(user)  =>  println("the first item is: " + user)
  case None        =>  println("the list is empty")
}

// type checking without typeOf
users foreach {
  case NormalUser(age, name) if age >= 18 =>  println(name + " is adult")
  case NormalUser(age, name)              =>  println(name + " is a child")
  case AdminUser(name)                    =>  println(name + " is an admin")
}

// Regular Expressions
val bday = "([12][0-9]{3})/([0-9]{2})/.+".r
"2001/02/17" match {
  case bday(year, month)  =>  println("birthday is in " + month + "/" + year)
  case _                  =>  println("no valid date")
}
```
</div>

---

# Other Language Features (in Short)

* built-in singleton objects:  
  `object Singleton { ... }`
* class names are independent of file names
* lazy evaluation (compute values on first access):  
  `lazy val x = ...`
* fancy type parameters ("covariance & contravariance")
* execute long-running code in a non-blocking way:  
  `val result: Future[Int] = future{ someHeavyComputing() }`
* parallel collections:  
  `list.par.foreach(...)`
* `Actor`s for concurrent, distributed, fault-tolerant systems, communicating via message passing

---

# Summary

* If you like Scala's features, but your project is on Java, better stay.
  * Java 8 will have inline functions, higher-order functions, parallel collections, trait-like constructs etc.
  * Code conversion to Scala with a Java architecture is maybe not worth the effort.
* If you start a new project and want
  * well-performing
  * concise
  * type-safe

code that is
  * easy to argue about,
  * easy to parallelize,
  * fun to write,

give it a try! :-)

---

# Thanks for your Attention!

# Questions?