Slides from my presentation on getting started with Scala

1. Starting with Scala
Frontier Developers' Meetup
December 9th, 2010
Boulder, CO
Derek Chen-Becker
Senior Network Engineer
CPI Corporation

2. Scala's Pedigree
Created by Martin
Odersky (EPFL), of GJ,
and later Javac v5
fame

3. Scala's History
Scala History
2.8.1
2.8.0
2.7.0
2.6.0
2.5.0
2.7.1 - 2.7.7
2.4.0
2.3.0
2.2.0
2.1.0
1.4.0.0
1.3.0.2
1.2.0.0
1.1.1.0
Jan 04 Jan 05 Jan 06 Jan 07 Jan 08 Jan 09 Jan 10

4. More Info on Scala
Home page: http://www.scala-lang.org/
Excellent community
scala-user@listes.epfl.ch
irc://chat.freenode.net/scala
http://scala.sygneca.com/ (Wiki)

5. Scala in Print

6. Scala in the Real World

7. Scala and the JVM
Compiles to 100% Java Bytecode
Generally works flawlessly with Java
Leverages JIT: performance ±5% of
Java
Full access to existing Java ecosystem
CLR (.Net) port in progress

8. About This Talk
Scala 2.8.0+
Significant changes to library
I'm still coming up to speed on
them
This is not a lecture

9. Act I
No Time Like the Present

10. The Scala REPL
Read, Evaluate, Print, Loop
You need a JVM (1.6+ preferred) with
“java” in your path or JAVA_HOME set
Download the latest binaries from
http://www.scala-lang.org/downloads
Unpack wherever, go to bin subdirectory
Type “scala<enter>”

11. Play Along at Home!
http://www.simplyscala.com/

12. Act II
So, What is Scala?

13. Three Very Common Keywords
val – defines an immutable
value or reference
var – defines a mutable value
def – defines a
function/method

14. Scala is Concerned with Mutability
Immutable data structures reduce
(but not eliminate) concurrency
issues
Combined with actors make a
powerful approach to parallel tasks
Strong library and language support

15. Scala is Strongly Typed...
val foo : Int = 12
var bar : String = "twelve"
def baz (in : Int) : Double =
in.toDouble

16. ...But Can Usually Figure Types Out
val foo = 12
var bar = "twelve"
def baz (in : Int) =
in.toDouble

17. Scala is Generic
val primes : List[Int] =
List(2,3,5,7,11)
scala> primes.grouped(2).toList
res16: List[List[Int]] =
List(List(2, 3), List(5, 7),
List(11))

18. Scala is Object­Oriented
class Foo {
def bar () = {
"bat"
}
}
val f = new Foo

19. I Mean Really Object­Oriented
st
Primitives are treated as 1 class objects
scala> (12.5).min(47)
res17: Double = 12.5
scala> 3825.toHexString
res18: String = ef1
scala> '5'.isWhitespace
res19: Boolean = false

20. Scala is Functional
val greet =
(name : String) =>
"Hello, %s!".format(name)
greet(“Fred”)
res27: String = Hello, Fred!
val greet =
"Hello, %s!".format(_ : String)

21. Scala is Functional Everywhere
def doubleMe (f : () => Any) {
println(f()); println(f());
}
scala>
doubleMe(System.nanoTime)
1588504517303734
1588504517365296

22. Scala is Closurific
def counter (name : String) = {
var i = 0;
{ () =>
i += 1
name + ":" + i
}
}

23. Scala is Concise...
public class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
} case class Person(name : String,
VS var age : Int)
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int hashCode() {...}
public String toString() {...}
public boolean equals() {...}
}

24. ...But Maintains Uniform Access
case class Person(val name : String,
private var curAge : Int) {
def age = curAge
def age_= (a : Int) { curAge = a }
}

25. Scala is DSL­Friendly (be reasonable)
class Vector[T](data : Array[T]){
def + (that : Vector[T]) = {}
def - (that : Vector[T]) = {}
...
def ⊗ (that : Vector[T]) = {}
}
val product = A ⊗ B
val product = A.⊗(B)

26. Scala is Optional
val exists: Option[Int]= Some(42)
val notHere: Option[Int] = None
scala> exists.map(_ * 2).getOrElse(12)
res0: Int = 84
scala> notHere.map(_ * 2).getOrElse(12)
res1: Int = 12

27. Scala Likes Tuples (Heterogeneous)
scala> val state = (12, "Empty", RED)
state: (Int, java.lang.String, java.awt.Color)
= (12,Empty,java.awt.Color[r=255,g=0,b=0])
scala> val (count, description, color) = state
count: Int = 12
description: java.lang.String = Empty
color: java.awt.Color =
java.awt.Color[r=255,g=0,b=0]

28. Scala is XML­Friendly
def personToXml(p : Person) =
<person name={p.name}
age={p.age.toString} />

29. Scala is High­Level...
val people = List(Person("Fred", 30),
Person("Ted", 25),
Person("Ed", 41))
people.foreach (println)

30. Letting You Get to the Real Work
// One line of magic...
implicit val orderPeople =
Ordering.by((_:Person).age)
// ...allows powerful constructs
val (oldest,youngest) =
(people.max,people.min)

31. Act III
Scala OO Fundamentals

32. Packages
package net.foo {
...
}
package net.foo

33. Imports
import java.io.File
import java.net._
import java.awt.{Image,
Color => JCol, Dialog => _}

34. Packages Nest...
package net.foo
==
package net {
package foo {
...
}
}

35. Sometimes in Unexpected Ways (< 2.8)
package net.foo {
import java.net.URL
}

36. The Scala OO Quadfecta
trait
class object
case class/
object

37. Traits Are Good
Somewhat analogous to interfaces...
trait Comparable[T] {
def < (that : T) : Boolean
def <= (that : T) : Boolean
def > (that : T) : Boolean
def >= (that : T) : Boolean
}

38. Traits are Really Awesome
...But they can carry implementation
trait Comparable[T <: Comparable[T]] {
self : T =>
def < (that : T) : Boolean
def <= (that : T) = this < that ||
this == a
def > (that : T) = that < this
def >= (that : T) = that <= this
}

39. Traits can be Composed
trait A
trait B
trait C
class Base extends A with B
with C

40. Class Linearization : Base Trait
trait Pet {
def greeting : String
def eat() : Unit
}

41. Class Linearization : Extension Traits
trait Dog extends Pet {
def greeting = "Woof"
def eat() {...}
}
trait Mute extends Pet {
override val greeting = ""
}

42. Class Linearization : Composition
class Dingo extends Dog
with Mute
scala> (new Dingo).greeting
res0: java.lang.String =

43. Scala Objects
“An object definition defines a single
object of a new class” (Scala Reference,
§5.4
object Friendly {
var publicInt = 0
def hi = println("Hi!")
}

44. Objects hold Static Methods
object MyApp {
def main (args : Array[String]) {
...
}
}

45. Objects are Scoped VM Singletons
class Outer {
object Inner {
var foo = "foo"
}
}

46. Objects as Factories
object Person {
def apply(name : String,
age : Int) : Person =
new Person(name,age)
}
val fred = Person("Fred", 20)

47. Objects as Factories, Continued
object Person {
...
def apply(name : String) : Person =
new Person(name, 1)
}
val babyFred = Person("Fred")

48. Named and Default Arguments
object Person {
def apply(name : String,
age : Int = 1) : Person =
new Person(name,age)
}
val fredBaby = Person(name = "Fred")

49. Case Classes (and Objects)
case class Car (name : String,
gears : Int)
scala> val myCar = Car("Corolla", 4)
myCar: Car = Car(Corolla,4)
scala> myCar.name
res0: String = Corolla

50. Case Class Automation
Factory method (apply)
toString
hashCode
equals (and therefore ==)
Constructor params become vals,
can be turned into vars

51. Case Class Bonii : Copy
scala> val myCar = Car("Corolla", 4)
myCar: Car = Car(Corolla,4)
scala> val myOtherCar =
myCar.copy(name = "Forester")
myOtherCar: Car = Car(Forester,4)

52. Case Class Bonii : Extraction
scala> val myCar = Car("Corolla", 4)
myCar: Car = Car(Corolla,4)
// “_” here means “don't bother”
scala> val Car(_,gears) = myCar
gears: Int = 4

53. Act IV
Functional is Your Friend

54. Start With Some Basic Functions
foreach
map
flatMap
filter
exists
takeWhile
dropWhile

55. Composing Functions == Power
people.flatMap(first =>
people.filter(_ != first).
map(List(first,_)))

56. For Comprehensions
for (first <- people;
second <- people
if first != second)
yield List(first,second)

57. Currying
Provide N argument lists, but only use 1
to N-1 of them to define a new function
def scaler (factor : Int)
(value : Int) =
factor * value
val times2 = scaler(2) _
times2(12) // == 24

58. “By Name” Arguments
def myWhile (condition : => Boolean)
(f : => Unit) {
if (condition) {
f; myWhile(condition)(f)
}
}

59. “By Name” Use Case : Logging
if (logger.isDebugEnabled) {
logger.debug("Foo: " + foo)
}

60. “By Name” Use Case : Logging
THIS
if (logger.isDebugEnabled) {
logger.debug("Foo: " + foo)
}
SUCKS

61. “By Name” to the Rescue
def debug (msg : => String) {
if (this.debugEnabled) {
println(msg)
}
}
https://github.com/weiglewilczek/slf4s

62. Pattern Matching : Switch on Steroids
“case _” here is the default case
def literalMatch (in: Any) {
in match {
case 1 => doBar("One")
case "test" => doBar("test")
case 'x' => doBar("x")
case 2.2f => doBar("float")
case _ => doBar("lemon curry?")
}
}

63. Pattern Matching : Alternate Matches
Using “|” allows multi-match cases
def literalMatch (in: Any) {
in match {
case 1 | 2 | 3 => doBar("One to three")
case "this" | "that" => doBar("the other")
case _ => doBar("lemon curry?")
}
}

64. Pattern Matching : XML
def xmlMatch (in : Any) = in match {
case <people>{bar @ _*}</people> =>
bar.foreach(println)
case _ => // NOOP
}

65. Pattern Matching : Case Classes
def caseMatch (a : Any) = a match {
case Person(name, age) =>
println("%s is %d”.
format(name,age))
}

66. Pattern Matching : Type Matches
def typeMatch (in: Any) {
in match {
case i : Int => doBar("Int : " + i)
case s : String => doBar(s)
case _ => // NOOP
}
}

67. Pattern Matching : Generics
Erasure is not your friend
def typeMatch (in: Any) {
in match {
case ls : List[String] => doBar("danger!")
case li : List[Int] => doBar("never happens")
case _ => // NOOP
}
}

68. Pattern Matching : Guards
def guardMatch (in: Any) {
in match {
case i : Int
if i > 12 && i < 47 =>
doBar("Int : " + i)
case _ => // NOOP
}
}

69. Pattern Matching : Generics Workaround
Like duck tape : ugly, but effective
def typeMatch (in: Any) {
in match {
case ls : List[_]
if ls.forall(_.isInstanceOf[String]) =>
doBar("Strings!")
case li : List[_] => doBar("Some kind of List")
case _ => // NOOP
}
}

70. More More Info on Scala
Home page: http://www.scala-lang.org/
Excellent community
scala-user@listes.epfl.ch
irc://chat.freenode.net/scala
http://scala.sygneca.com/ (Wiki)