The document discusses the benefits of Scala as a programming language. It summarizes Scala's key features as being a functional and object-oriented language that runs on the JVM, provides improved type safety compared to Java/C#, and was designed by Martin Odersky who has deep experience with programming languages and industry. Everything in Scala can be treated as a function, including objects, which allows for more succinct coding patterns using functional idioms like map and filter.

1. The Seductions of
Scala
Dean Wampler
dean@deanwampler.com
@deanwampler
polyglotprogramming.com/talks
April 3, 2011
1

2. <shameless-plug/>
Co-author,
Programming
Scala
programmingscala.com
2

3. Why do we
need a new
language?
3

4. #1
We need
Functional
Programming
…
4

5. … for concurrency.
… for concise code.
… for correctness.
5

6. #2
We need a better
Object Model
…
6

7. … for composability.
… for scalable designs.
7

8. Scala’s Thesis:
Functional Prog.
Complements
Object-Oriented
Prog.
8

9. Scala’s Thesis:
Functional Prog.
Complements
Object-Oriented
Prog.
Despite surface contradictions...
8

10. But we want to
keep our investment
in Java/C#.
9

11. Scala is...
• A JVM and .NET language.
• Functional and object oriented.
• Statically typed.
• An improved Java/C#.
10

12. Martin Odersky
• Helped design java generics.
• Co-wrote GJ that became
javac (v1.3+).
• Understands Computer
Science and Industry.
11

13. Everything can
be a Function
12

14. Objects
as
Functions
13

15. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
14

16. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
15

17. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
class body is the
“primary” constructor
15

18. makes “level” a field
class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
class body is the
“primary” constructor
15

19. makes “level” a field
class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
} method
}
class body is the
“primary” constructor
15

20. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
16

21. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
val error = new Logger(ERROR)
16

22. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
val error = new Logger(ERROR)
…
error("Network error.")
16

23. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
…
error("Network error.")
17

24. class Logger(val level:Level) {
def apply(message: String) = {
// pass to Log4J...
Log4J.log(level, message)
}
}
apply is called “function object”
…
error("Network error.")
17

25. When you put
an arg list
after any object,
apply is called.
18

26. Everything is
an Object
19

27. Int, Double, etc.
are true objects.
20

28. Int, Double, etc.
are true objects.
But they are compiled to primitives.
20

29. Functions
as
Objects
21

30. First, About Lists
val list = List(1, 2, 3, 4, 5)
22

31. First, About Lists
val list = List(1, 2, 3, 4, 5)
The same as this “list literal” syntax:
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
22

32. val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
23

33. “cons”
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
23

34. “cons” empty list
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
23

35. “cons” empty list
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
head
23

36. “cons” empty list
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
head tail
23

37. Baked into the
Grammar?
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
24

38. Baked into the
Grammar?
val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
No, just method calls!
val list = Nil.::(5).::(4).::(
3).::(2).::(1)
24

39. val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
val list = Nil.::(5).::(4).::(
3).::(2).::(1)
25

40. val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
val list = Nil.::(5).::(4).::(
3).::(2).::(1)
Method names can contain almost any
character.
25

41. val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
val list = Nil.::(5).::(4).::(
3).::(2).::(1)
Any method ending in “:” binds to the right!
26

42. val list =
1 :: 2 :: 3 :: 4 :: 5 :: Nil
val list = Nil.::(5).::(4).::(
3).::(2).::(1)
If a method takes one argument, you can drop
the “.” and the parentheses, “(“ and “)”.
27

43. Infix Operator Notation
"hello" + "world"
28

44. Infix Operator Notation
"hello" + "world"
is actually just
"hello".+("world")
28

45. Similar mini-DSLs
have been defined
for other types.
29

46. Similar mini-DSLs
have been defined
for other types.
Also in many third-party libraries.
29

47. Back to
functions as objects...
30

48. Classic Operations on
“Container” Types
List, Map, ... map
filter
fold/
reduce
31

49. val list = "a" :: "b" :: Nil
32

50. val list = "a" :: "b" :: Nil
list map {
s => s.toUpperCase
}
// => "A" :: "B" :: Nil
32

51. list map {
s => s.toUpperCase
}
33

52. map called on list
(dropping the “.”)
list map {
s => s.toUpperCase
}
33

53. map called on list
(dropping the “.”) argument to map
(using “{“ vs. “(“)
list map {
s => s.toUpperCase
}
33

54. map called on list
(dropping the “.”) argument to map
(using “{“ vs. “(“)
list map {
s => s.toUpperCase
}
“function literal”
33

55. map called on list
(dropping the “.”) argument to map
(using “{“ vs. “(“)
list map {
s => s.toUpperCase
}
“function literal”
function
argument list
33

56. map called on list
(dropping the “.”) argument to map
(using “{“ vs. “(“)
list map {
s => s.toUpperCase
}
“function literal”
function function body
argument list
33

57. list map {
s => s.toUpperCase
}
34

58. list map {
s => s.toUpperCase
}
inferred type
34

59. list map {
s => s.toUpperCase
}
inferred type
list map {
(s:String) => s.toUpperCase
}
Explicit type
34

60. So far,
we have used
type inference
a lot...
35

61. How the Sausage Is Made
class List[A] {
…
def map[B](f: A => B): List[B]
…
}
36

62. How the Sausage Is Made
Parameterized type
class List[A] {
…
def map[B](f: A => B): List[B]
…
}
36

63. How the Sausage Is Made
Parameterized type
class List[A] {
Declaration of map
…
def map[B](f: A => B): List[B]
…
} The function map’s return type
argument
36

64. How the Sausage Is Made
trait Function1[-A,+R] {
def apply(a:A): R
…
}
37

65. How the Sausage Is Made
like an “abstract” class
trait Function1[-A,+R] {
def apply(a:A): R
…
}
37

66. How the Sausage Is Made
like an “abstract” class
trait Function1[-A,+R] {
def apply(a:A): R
…
} No method body:
=> abstract
37

67. How the Sausage Is Made
“contravariant”,
like an “abstract” class
“covariant” typing
trait Function1[-A,+R] {
def apply(a:A): R
…
} No method body:
=> abstract
37

68. What the Compiler Does
(s:String) => s.toUpperCase
new Function1[String,String] {
def apply(s:String) = {
s.toUpperCase
}
}
38

69. What the Compiler Does
(s:String) => s.toUpperCase
What you write.
new Function1[String,String] {
def apply(s:String) = {
s.toUpperCase
} What the compiler
} generates
An anonymous class
38

70. What the Compiler Does
(s:String) => s.toUpperCase
What you write.
new Function1[String,String] {
def apply(s:String) = {
s.toUpperCase
} What the compiler
} generates
No “return”
needed An anonymous class
38

71. Recap
val list = "a" :: "b" :: Nil
list map {
s => s.toUpperCase
}
// => "A" :: "B" :: Nil
39

72. Recap
val list = "a" :: "b" :: Nil
list map {
s => s.toUpperCase
} Function “object”
// => "A" :: "B" :: Nil
39

73. Recap
val list = "a" :: "b" :: Nil
list map { {…} ok, instead of (…)
s => s.toUpperCase
} Function “object”
// => "A" :: "B" :: Nil
39

74. More
Functional
Hotness
40

75. Avoiding Nulls
sealed abstract class Option[+T]
{…}
case class Some[+T](value: T)
extends Option[T] {…}
case object None
extends Option[Nothing] {…}
41

76. Avoiding Nulls
sealed abstract class Option[+T]
{…}
case class Some[+T](value: T)
extends Option[T] {…}
case object None
extends Option[Nothing] {…}
41
An Algebraic Data Type

77. // Java style (schematic)
class Map[K, V] {
def get(key: K): V = {
return value || null;
}}
42

78. // Java style (schematic)
class Map[K, V] {
def get(key: K): V = {
return value || null;
}}
42

79. // Java style (schematic)
class Map[K, V] {
def get(key: K): V = {
return value || null;
}}
// Scala style
class Map[K, V] {
def get(key: K): Option[V] = {
return Some(value) || None;
}}
Which is the better API?
42

80. In Use:
val m =
Map("one" -> 1, "two" -> 2)
…
val n = m.get("four") match {
case Some(i) => i
case None => 0 // default
}
43

81. In Use:
val m = Literal syntax for map creation
Map("one" -> 1, "two" -> 2)
…
val n = m.get("four") match {
case Some(i) => i
case None => 0 // default
}
Use pattern matching to extract the value (or not)
43

82. Option Details: sealed
sealed abstract class Option[+T]
{…}
44

83. Option Details: sealed
sealed abstract class Option[+T]
{…}
All children must be defined
in the same file
44

84. Case Classes
case class Some[+T](value: T)
45

85. Case Classes
case class Some[+T](value: T)
●Provides factory method, pattern
matching, equals, toString, etc.
●Makes “value” a field without val
keyword.
45

86. Object
case object None
extends Option[Nothing] {…}
46

87. Object
case object None
extends Option[Nothing] {…}
A “singleton”. Only one instance will exist.
46

88. Nothing
case object None
extends Option[Nothing] {…}
47

89. Nothing
case object None
extends Option[Nothing] {…}
Special child type of all other
types. Used for this special
case where no actual
instances required.
47

90. Succinct Code
48

91. Succinct Code
A few things we’ve seen so far.
48

92. Infix Operator
Notation
"hello" + "world"
49

93. Infix Operator
Notation
"hello" + "world"
same as
"hello".+("world")
49

94. Type Inference
// Java
HashMap<String,Person> persons =
new HashMap<String,Person>();
50

95. Type Inference
// Java
HashMap<String,Person> persons =
new HashMap<String,Person>();
vs.
// Scala
val persons
= new HashMap[String,Person]
50

96. Type Inference
// Java
HashMap<String,Person> persons =
new HashMap<String,Person>();
vs.
// Scala
val persons
= new HashMap[String,Person]
51

97. Type Inference
// Java
HashMap<String,Person> persons =
new HashMap<String,Person>();
vs.
// Scala
val persons
= new HashMap[String,Person]
51

98. // Scala
val persons
= new HashMap[String,Person]
52

99. // Scala
val persons
= new HashMap[String,Person]
no () needed.
Semicolons inferred.
52

100. User-defined Factory
Methods
val words =
List("Scala", "is", "fun!")
53

101. User-defined Factory
Methods
val words =
List("Scala", "is", "fun!")
no new needed.
Can return a subtype!
53

102. class Person {
private String firstName;
private String lastName;
private int age;
public Person(String firstName, String lastName, int age){
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public void String getFirstName() {return this.firstName;}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public void String getLastName() {return this.lastName;}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public void int getAge() {return this.age;}
public void setAge(int age) {
this.age = age;
}
} 54

103. class Person {
private String firstName;
private String lastName;
private int age;
public Person(String firstName, String lastName, int age){
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public void String getFirstName() {return this.firstName;}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public void String getLastName() {return this.lastName;}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public void int getAge() {return this.age;}
public void setAge(int age) {
this.age = age;
} Typical Java
} 54

104. class Person(
var firstName: String,
var lastName: String,
var age: Int)
55

105. class Person(
var firstName: String,
var lastName: String,
var age: Int)
Typical Scala!
55

106. class Person(
var firstName: String,
var lastName: String,
var age: Int)
56

107. Class body is the
“primary” constructor
Parameter list for c’tor
class Person(
var firstName: String,
var lastName: String,
var age: Int)
No class body {…}.
Makes the arg a field nothing else needed!
with accessors
56

108. Even Better...
case class Person(
firstName: String,
lastName: String,
age: Int)
57

109. Even Better...
case class Person(
firstName: String,
lastName: String,
age: Int)
Constructor args are automatically
vals, plus other goodies.
57

110. Scala’s Object
Model: Traits
58

111. Scala’s Object
Model: Traits
Composable Units of Behavior
58

112. We would like to
compose objects
from mixins.
59

113. Java: What to Do?
class Server
extends Logger { … }
60

114. Java: What to Do?
class Server
extends Logger { … }
“Server is a Logger”?
60

115. Java: What to Do?
class Server
extends Logger { … }
“Server is a Logger”?
class Server
implements Logger { … }
Logger isn’t an interface!
60

116. Java’s object model
61

117. Java’s object model
• Good
• Promotes abstractions.
• Bad
• No composition through
reusable mixins.
61

118. Traits
Like interfaces with
implementations,
62

119. Traits
… or like
abstract classes +
multiple inheritance
(if you prefer).
63

120. Logger as a Mixin:
trait Logger {
val level: Level // abstract
def log(message: String) = {
Log4J.log(level, message)
}
}
64

121. Logger as a Mixin:
trait Logger {
val level: Level // abstract
def log(message: String) = {
Log4J.log(level, message)
}
} Traits don’t have
constructors, but
you can still
define fields.
64

122. Logger as a Mixin:
trait Logger {
val level: Level // abstract
…
}
65

123. Logger as a Mixin:
trait Logger {
val level: Level // abstract
…
}
val server =
new Server(…) with Logger {
val level = ERROR
}
server.log("Internet down!!")
65

124. Logger as a Mixin:
trait Logger {
val level: Level // abstract
…
} mixed in Logging
val server =
new Server(…) with Logger {
val level = ERROR
}
server.log("Internet down!!")
65

125. Logger as a Mixin:
trait Logger {
val level: Level // abstract
…
} mixed in Logging
val server =
new Server(…) with Logger {
val level = ERROR abstract
} member defined
server.log("Internet down!!")
65

126. Actor
Concurrency
66

127. When you
share mutable
state...
67

128. When you
share mutable
state...
Hic sunt dracones
(Here be dragons)
67

129. Actor Model
• Message passing between
autonomous actors.
• No shared (mutable) state.
68

130. Actor Model
• First developed in the 70’s by
Hewitt, Agha, Hoare, etc.
• Made “famous” by Erlang.
• Scala’s Actors patterned
after Erlang’s.
69

131. 2 Actors:
“self” Display
draw
draw
??? error!
“exit” exit
70

132. package shapes
case class Point(
x: Double, y: Double)
abstract class Shape {
def draw()
}
Hierarchy of geometric shapes
71

133. package shapes
case class Point(
x: Double, y: Double)
abstract class Shape {
def draw() abstract “draw” method
}
Hierarchy of geometric shapes
71

134. case class Circle(
center:Point, radius:Double)
extends Shape {
def draw() = …
}
case class Rectangle(
ll:Point, h:Double, w:Double)
extends Shape {
def draw() = …
}
72

135. case class Circle(
center:Point, radius:Double)
extends Shape {
def draw() = … concrete “draw”
} methods
case class Rectangle(
ll:Point, h:Double, w:Double)
extends Shape {
def draw() = …
}
72

136. package shapes
import akka.actor._
class ShapeDrawingActor
extends Actor {
def receive = {
…
}
}
Actor for drawing shapes
73

137. Use the “Akka”
package shapes Actor library
import akka.actor._
class ShapeDrawingActor
extends Actor {
def receive = {
…
}
}
Actor for drawing shapes
73

138. Use the “Akka”
package shapes Actor library
import akka.actor._
class ShapeDrawingActor Actor
extends Actor {
def receive = {
receive and handle
…
each message
}
}
Actor for drawing shapes
73

139. Receive
receive = { method
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
Actor for drawing shapes
74

140. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
Actor for drawing shapes
75

141. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.") pattern
case "exit" => matching
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
Actor for drawing shapes
75

142. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.") pattern
case "exit" => matching
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
Actor for drawing shapes
75

143. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.") pattern
case "exit" => matching
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
Actor for drawing shapes
75

144. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
76

145. receive = { draw shape
case s:Shape => & send reply
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
76

146. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
done
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
76

147. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
unrecognized message
76

148. receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
76

149. package shapes
import akka.actor._
class ShapeDrawingActor extends Actor {
receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
}
77

150. package shapes
import akka.actor._
class ShapeDrawingActor extends Actor {
receive = {
case s:Shape =>
print("-> "); s.draw()
self.reply("Shape drawn.")
case "exit" =>
println("-> exiting...")
self.reply("good bye!")
case x => // default
println("-> Error: " + x)
self.reply("Unknown: " + x)
}
}
Altogether
77

151. import shapes._
import akka.actor._
import akka.actor.Actor
object Driver {
def main(args:Array[String])={
val driver = actorOf[Driver]
driver.start
driver ! "go!"
}
}
class Driver … 78

152. import shapes._
import akka.actor._
import akka.actor.Actor
a “singleton” type to hold main
object Driver {
def main(args:Array[String])={
val driver = actorOf[Driver]
driver.start
driver ! "go!"
}
}
class Driver … driver to try it out
78

153. import shapes._
import akka.actor._
import akka.actor.Actor
a “singleton” type to hold main
object Driver {
def main(args:Array[String])={
val driver = actorOf[Driver]
driver.start
driver ! "go!"
}
}
class Driver … driver to try it out
78

154. import shapes._
import akka.actor._
import akka.actor.Actor
a “singleton” type to hold main
object Driver {
def main(args:Array[String])={
val driver = actorOf[Driver]
driver.start
driver ! "go!" ! is the message
} send “operator”
}
class Driver … driver to try it out
78

155. …
class Driver extends Actor {
val drawer =
actorOf[ShapeDrawingActor]
drawer.start
def receive = {
…
}
}
driver to try it out
79

156. Its “companion” object Driver
… was on the previous slide.
class Driver extends Actor {
val drawer =
actorOf[ShapeDrawingActor]
drawer.start
def receive = {
…
}
}
driver to try it out
79

157. def receive = {
case "go!" =>
drawer ! Circle(Point(…),…)
drawer ! Rectangle(…)
drawer ! 3.14159
drawer ! "exit"
case "good bye!" =>
println("<- cleaning up…")
drawer.stop; self.stop
case other =>
println("<- " + other)
} driver to try it out
80

158. def receive = {
case "go!" => sent by main
drawer ! Circle(Point(…),…)
drawer ! Rectangle(…)
drawer ! 3.14159
drawer ! "exit"
case "good bye!" =>
println("<- cleaning up…")
drawer.stop; self.stop
case other =>
println("<- " + other)
} driver to try it out
80

159. def receive = {
case "go!" => sent by main
drawer ! Circle(Point(…),…)
drawer ! Rectangle(…)
drawer ! 3.14159
drawer ! "exit" sent by
case "good bye!" => drawer
println("<- cleaning up…")
drawer.stop; self.stop
case other =>
println("<- " + other)
} driver to try it out
80

160. case "go!" =>
drawer ! Circle(Point(…),…)
drawer ! Rectangle(…)
drawer ! 3.14159
drawer ! "exit"
// run Driver.main (see github README.md)
-> drawing: Circle(Point(0.0,0.0),1.0)
-> drawing: Rectangle(Point(0.0,0.0),
2.0,5.0)
-> Error: 3.14159
-> exiting... “<-” and “->” messages
<- Shape drawn. may be interleaved!!
<- Shape drawn.
<- Unknown: 3.14159
<- cleaning up...
81

161. …
// ShapeDrawingActor
receive = {
case s:Shape =>
s.draw()
self.reply("…")
case …
case …
}
82

162. …
// ShapeDrawingActor
Functional-style
receive = {
pattern matching
case s:Shape =>
s.draw()
self.reply("…")
case …
case …
}
82

163. …
// ShapeDrawingActor
Functional-style
receive = {
pattern matching
case s:Shape =>
s.draw() Object-
self.reply("…") oriented-style
polymorphism
case …
case …
}
“Switch” statements
are not evil!
82

164. Recap
83

165. Scala is...
84

166. 85

167. a better
Java and C#,
85

168. 86

169. object-oriented
and
functional,
86

170. 87

171. succinct,
elegant,
and
powerful.
87

172. Thanks!
dean@deanwampler.com
@deanwampler
polyglotprogramming.com/talks
programmingscala.com
thinkbiganalytics.com
88

173. Extra Slides
89

174. Modifying
Existing
Behavior
with Traits
90

175. Example
trait Queue[T] {
def get(): T
def put(t: T)
}
91

176. Example
trait Queue[T] {
def get(): T
def put(t: T)
}
A pure abstraction (in this case...)
91

177. Log put
trait QueueLogging[T]
extends Queue[T] {
abstract override def put(
t: T) = {
println("put("+t+")")
super.put(t)
}
}
92

178. Log put
trait QueueLogging[T]
extends Queue[T] {
abstract override def put(
t: T) = {
println("put("+t+")")
super.put(t)
}
}
93

179. Log put
trait QueueLogging[T]
extends Queue[T] {
abstract override def put(
t: T) = {
println("put("+t+")")
super.put(t)
}
}
What is “super” bound to??
93

180. class StandardQueue[T]
extends Queue[T] {
import ...ArrayBuffer
private val ab =
new ArrayBuffer[T]
def put(t: T) = ab += t
def get() = ab.remove(0)
…
}
94

181. class StandardQueue[T]
extends Queue[T] {
import ...ArrayBuffer
private val ab =
new ArrayBuffer[T]
def put(t: T) = ab += t
def get() = ab.remove(0)
…
}
Concrete (boring) implementation
94

182. val sq = new StandardQueue[Int]
with QueueLogging[Int]
sq.put(10) // #1
println(sq.get()) // #2
// => put(10) (on #1)
// => 10 (on #2)
95

183. val sq = new StandardQueue[Int]
with QueueLogging[Int]
sq.put(10) // #1
println(sq.get()) // #2
// => put(10) (on #1)
// => 10 (on #2)
Example use
95

184. val sq = new StandardQueue[Int]
with QueueLogging[Int]
sq.put(10) // #1
println(sq.get()) // #2
// => put(10) (on #1)
// => 10 (on #2)
96

185. Mixin composition;
no class required
val sq = new StandardQueue[Int]
with QueueLogging[Int]
sq.put(10) // #1
println(sq.get()) // #2
// => put(10) (on #1)
// => 10 (on #2)
Example use
96

186. Like Aspect-Oriented
Programming?
Traits give us advice,
but not a join point
“query” language.
97

187. Traits are a powerful
composition
mechanism!
98

188. Functional
Programming
99

189. What is
Functional
Programming?
100

190. What is
Functional
Programming?
Don’t we already write “functions”?
100

191. y = sin(x)
101

192. y = sin(x)
Based on Mathematics
101

193. y = sin(x)
102

194. y = sin(x)
Setting x fixes y
∴ variables are immutable
102

195. 20 += 1 ??
103

196. 20 += 1 ??
We never modify
the 20 “object”
103

197. Concurrency
104

198. Concurrency
No mutable state
∴ nothing to synchronize
104

199. When you
share mutable
state...
105

200. When you
share mutable
state...
Hic sunt dracones
(Here be dragons)
105

201. y = sin(x)
106

202. y = sin(x)
Functions don’t
change state
∴ side-effect free
106

203. Side-effect free functions
• Easy to reason about behavior.
• Easy to invoke concurrently.
• Easy to invoke anywhere.
• Encourage immutable objects.
107

204. tan(Θ) = sin(Θ)/cos(Θ)
108

205. tan(Θ) = sin(Θ)/cos(Θ)
Compose functions of
other functions
∴ first-class citizens
108

206. Even More
Functional
Hotness
109

207. For “Comprehensions”
val l = List(
Some("a"), None, Some("b"),
None, Some("c"))
for (Some(s) <- l) yield s
// List(a, b, c)
110

208. For “Comprehensions”
val l = List(
Some("a"), None, Some("b"),
None, Some("c"))
for (Some(s) <- l) yield s
// List(a, b, c)
Pattern match; only
take elements of “l”
No “if ” statement that are Somes.
110