What is Scala?

• A programming language running on the JVM
• Statically typed, combines object-orientation and functional programming
• Concise
• Fully interoperable with Java
• As fast as Java

History

• "Make Java better"
  • 1997 - Pizza and GJ (Odersky, Wadler)
  • 2000 - Java 5 (generics)
• "Make a better Java"
  • first release 2004
  • adoption begins 2007
  • first Scala conference 2008

Adoption

According to StackOverflow and GitHub Scala is used a lot.

Momentum

• scala-lang.org: >300,000 visitors/month
• >25 books in print
  • Selection on scala-lang.org
• >65 active user groups
  • See scala-tribes.org
  • Including a very active group in Boston!: Boston Area Scala Enthusiasts

Philosophy

• Scalable language
  • same concepts in small and large applications
• Deep rather than broad
  • focus on abstraction and composition
• "Growable language" (Guy Steele)
  • embed DSLs/add new types

First Example

Java

public class Person { public final String name; public final int age; Person(String name, int age) { this.name = name; this.age = age; } }

Scala

class Person(val name: String, val age: Int)

Using arrays in...

... Java:

import java.util.ArrayList; ... Person[] people; Person[] minors; Person[] adults; { ArrayList<Person> minorsList = new ArrayList<Person>(); ArrayList<Person> adultsList = new ArrayList<Person>(); for (int i = 0; i < people.length; i++) (people[i].age < 18 ? minorsList : adultsList) .add(people[i]); minors = minorsList.toArray(people); adults = adultsList.toArray(people); }

... and in Scala:

val people: Array[Person] // a tuple in a pattern match: val (minors, adults) = people partition (_.age < 18) // a lambda

Scala Basics

Running Scala

• Compiled to Java bytecode
  • experimental JavaScript backend: Scala.js
  • experimental LLVM backend: Scala Native
• Read-Eval-Print-Loop (REPL)
  • fast turnaround
  • easy experimentation/testing
  • available within many tools: Eclipse IDE, sbt, Scastie (Scala in the browser), ...

Essentials

• Every value is an object
• Everything is an expression (evaluates to a value)
• Every operation is a method call

Primitives

val x: Int = 10 // type can also be inferred val y = x + 10 // same as x.+(10)

Complex numbers

class Complex(val re: Int, val im: Int) { def +(that: Complex) = new Complex(this.re + that.re, this.im + that.im) // ... override def toString = "%d + %di".format(re, im) } val c1 = new Complex(1, 2) val c2 = new Complex(2, 2) c1 + c2

Everything is an expression

• No statements
• Reduces the need for return and side-effects

Expression examples

def max(x: Int, y: Int) = if (x > y) x else y val res = max(10, 5) var x = 0 val t = { x = x + 10 x - 1 }

What about println?

val x = println("hello, world")

Classes and traits

Classes

When compiled, this class will look and behave exactly like the obvious translation to a Java class. No glue code necessary.

abstract class Node[T](val v: T, next: Node[T]) extends List(v, next) { val cache: Int def first: T def children = List(next) override def toString = "Node " + v }

Traits

• Like Java interfaces, but in addition
  • allow concrete methods, fields, types
• Like Scala classes, but without constructor parameters
• Allow (a form of) multiple inheritance
  • mix-in composition

Trait example

trait Ordered[A] extends java.lang.Comparable[A] { def < (that: A): Boolean = (this compareTo that) < 0 def > (that: A): Boolean = (this compareTo that) > 0 def <= (that: A): Boolean = (this compareTo that) <= 0 def >= (that: A): Boolean = (this compareTo that) >= 0 } case class Person(val name: String, val age: Int) extends Ordered[Person] { def compareTo(that: Person): Int = if (name < that.name) -1 else if (name > that.name) 1 else age - that.age } val p1 = new Person("anton", 10) val p2 = new Person("berta", 5) val p3 = new Person("anton", 9) val ps = List(p1, p2, p3) ps.sorted

Functional Programming

What is FP?

• Use of functions (in the mathematical sense)
  • referential transparency (no side-effects)
• Immutable objects
• Functions are values

Scala as a Functional Programming Language

• Use val instead of var
• Immutable collections in the standard library
• Leverage function literals and closures

Function literals

val succ = (x: Int) => x + 1 succ(1)

Equivalent forms

(x: Int) => x + 1 x => x + 1 // infer type _ + x // placeholder notation

Higher-Order Functions

• Functions that take or return functions
• Almost eliminate the need for loops over collections

Higher-Order Functions: Examples

val xs = List(1, 2, 3, 4, 5) xs.foreach(println) val allLessThanTen = xs.forall(_ < 10) xs.map(_ * 2) def findBelow(limit: Int) = persons.filter(_.age < limit)

Everything is an object

• Closures are objects, too
• Instances of trait Function1[A, B] (compiler generated)

trait Function1[R, A] { def apply(x: A): R }

Syntactic Sugar

• Why can I call succ(10)?
• f(args) is desugared to f.apply(args)
• You can define your own apply methods
• ...can I subclass FunctionN?

Function Subtypes

• Yes! Many collections are functions.
  • Sequences are Int => T
  • Sets are T => Boolean
  • Maps are K => V

val even = Set(2, 4, 6, 8, 10) val res1 = even(4) val res2 = even(3)

Standard Library

Collections

• Generic (List[T], Map[K, V])
• Mutable and immutable implementations (default is immutable)
• Uniform return type principle
• No compiler magic!

Example: Maps

val capitals = Map("France" -> "Paris", "Switzerland" -> "Bern", "Sweden" -> "Stockholm") val someCity = capitals("France") val resOfAdd = capitals + ("Romania" -> "Bucharest") capitals val filtered = capitals.filter(_._2 == "Paris")

For-comprehensions

• More general than for-loops
• Used to iterate, filter and generate new collections

for (p <- persons; pr <- p.projects; if pr.overdue) yield p.name

For-comprehensions

• Translated to calls to filter, map, flatMap
• Readily available to any class implementing those methods
• Can be used to query a database
  • Implement filter, map, flatmap to generate and forward SQL
  • SLICK, Squeryl

Pattern matching

Pattern matching

• A way to match and deconstruct structured data
• A powerful switch statement (expression, really)

// Define a set of case classes for representing binary trees. sealed abstract class Tree case class Node(elem: Int, left: Tree, right: Tree) extends Tree case object Leaf extends Tree // Return the in-order traversal sequence of a given tree. def inOrder(t: Tree): List[Int] = t match { case Node(e, l, r) => inOrder(l) ::: List(e) ::: inOrder(r) case Leaf => List() }

Open-Source Ecosystem

Scala Open Source Project

• Scala compiler, standard library, and modules open-source (BSD license)
  • All source on GitHub: https://github.com/scala/
  • Scala release 2.12.0 has hundreds of contributors
• Contributions
  • Report issues (https://issues.scala-lang.org/)
  • Help with the documentation (http://docs.scala-lang.org)
  • Fix bugs in compiler and other tools
  • Comprehensive contributing guide

Scala modules

• scala-swing
• scala-async
• scala-pickling
• scala-parser-combinators

Building and Testing

• Testing
  • ScalaTest
  • specs2
  • ScalaCheck: generate random test inputs
  • any Java testing framework
• Building
  • Build tools: sbt, Maven, Gradle, ant, ...
  • IntelliJ Survey at Scala Days 2013 (blog):
    

Testing with ScalaTest

import collection.mutable.Stack import org.scalatest._ class ExampleSpec extends FlatSpec with Matchers { "A Stack" should "pop values in last-in-first-out order" in { val stack = new Stack[Int] stack.push(1) stack.push(2) stack.pop() should be (2) stack.pop() should be (1) } it should "throw NoSuchElementException if an empty stack is popped" in { val emptyStack = new Stack[Int] a [NoSuchElementException] should be thrownBy { emptyStack.pop() } } }

ScalaCheck: Property-based testing

import org.scalacheck.Properties import org.scalacheck.Prop.forAll object StringSpecification extends Properties("String") { property("startsWith") = forAll { (a: String, b: String) => (a+b).startsWith(a) } property("concatenate") = forAll { (a: String, b: String) => (a+b).length > a.length && (a+b).length > b.length } property("substring") = forAll { (a: String, b: String, c: String) => (a+b+c).substring(a.length, a.length+b.length) == b } }