Scala for Java Developers - Intro

Scala
WTF is it? The new hotness or yet another functional fad?

1

Scalable Language
That’s why it’s pronounced Ska-Lah ?!??!

2

Hybrid Language:
Object-Oriented + Functional

5

Make Java more DRY

7

Allow easy creation of DSLs

8

Conciseness of Ruby +
Safety of Static Typing

9

No meta-programming but...
very liberal syntax

10

List<String> oyVey = new ArrayList<String>();

18

var hellsYeah = new ArrayList[String];

19

val booyah = 45; // it’s an Int

20

val doh = booyah / 3; // not a Float!!

21

val better:Float = booyah / 3;

22


// return type is java.lang.String
def fullName = { first + “,” + last; }

23



If the type seems obvious to you...

24



If the type seems obvious to you...
Scala can usually ﬁgure it out, too

25

val semicolons = “don’t need ‘em”
val but = “if it’s not clear”; val you = “need them”

27


def braces(b:Boolean) =
if (b)
“needed for multiple expressions”
else
“you don’t need them”

28


def braces(b:Boolean) =
if (b)
“needed for multiple expressions”
else
“you don’t need them”

• if/else is a singular expression

29

class Read(d:Date, val usage:Int) {
def +(other:Int) = new Read(d,usage + other)
override def toString = d + “:” + u

}

30


}

val f = new Read(new Date,10)
val g = f + 20

31


}

val g = f + 20
val gee = f.+(20) // yuck, but legal

32

def later(ms:Int) = new Read(d + ms,usage)
}

val g = f + 20
val gee = f.+(20) // yuck, but legal
val l = f later (3600 * 1000)

33

abstract class SaneCompare[T] {
def <(other:T):Boolean
def >(other:T) = !(this < other)
def <=(other:T) = this == other || this < other
def >=(other:T) = this == other || this > other
}
class Read(d:Date,u:Int) extends SaneCompare[Read] {
val usage = u
def <(other:Read) = usage < other.usage
}
if (someRead >= someOtherRead) println(”finally!”)

35

}
class Read(d:Date,u:Int) extends AbstractEntity {
val usage = u
}
// hmmm....what now?

36

}
val usage = u
}
// AbstractEntity extends SaneCompare?
// God class above AbstractEntity subsumes it?

37

}
val usage = u
}
// AbstractEntity extends SaneCompare?
// God class above AbstractEntity subsumes it?
// these are different concepts entirely

38

trait SaneCompare[T] {
}
class Read(d:Date,u:Int) extends AbstractEntity
with SaneCompare[Read] {
val usage = u
}
// now we have both!

39

Traits

• Separate Concerns

40

Traits

•Separate Concerns
• Precedence is based on declaration order

41

Traits

•Separate Concerns
• Precedence is based on declaration order
• All abstract – just like Java interface
• None abstract – multiple inheritance

42

val reads = getSomeElectricReads // List[Read]

reads.sort( (a,b) => a.date.compareTo(b.date) < 0 )

44



45



def sort(compFunc:(Read,Read) => Boolean)

46




Function2[Read,Read,Boolean]

47




Function2[Read,Read,Boolean]

def sortReads(a:Read,b:Read) =
a.date.compareTo(b.date) < 0

reads.sort(sortReads) // could also use a method
// just keep in mind...

48

Methods are not Functions

49

Methods are not Functions
but can be passed as Functions

50

class State(val code:String,val desc:String)
val states = getAllStates

// returns a List[String] with the codes
states.map( (state) => state.code )

// returns true if any state has a code of “DC”
states.exists( (state) => state.code == “DC” )

// returns the state with the desc of “Hawaii”
states.find( (state) => state.desc == “Hawaii” )

// returns a List[State] if states with descs matching
states.filter( (state) => state.desc.startsWith(”V”) )

// Tons more

52

Complete Access to JDK and Java
libraries

53

val s = new SingletonMetadataAwareAspectInstanceFactory()
val foo = s.getOrderForAspectClass(classOf[FooBar])

54

import java.util.Observer
import java.util.Observable

class AwesomeObserver extends Observer {
def update(o:Observable, arg:Any) =
if (o hasChanged)
println(arg.asInstanceOf[MeterRead].date)
}

55


if (o hasChanged)
}

56


if (o hasChanged)
}

57


if (o hasChanged)
}

58

Goodbye Java’s Baggage

59

Proper F’ing Properties
class ServicePoint(val id:String,var name:String)

val sp = new ServicePoint(”foo”,”The Foo House”)
println(sp.id) // get, but no set
println(sp.name)
sp.name = “Thy Foo Haüs”

61

Proper F’ing Properties
class ServicePoint(val id:String,private var _name:String) {
def name = _name.toUpperCase
def name_=(newName:String) = _name = newName
}

val sp = new ServicePoint(”foo”,”The Foo House”)
sp.name = “Thy Foo Haüs”
println(sp.name) // prints THY FOO HAÜS

62

¡Adiós Checked Exceptions!
def readFile(f:File) = {
val is = new FileInputStream(f)
var ch = f.read
while (ch != -1) {
print(ch)
ch = f.read
}
} // Wow, that was clean!

63

¡Adiós Checked Exceptions!
def readFile(f:File) = {
try {
val is = new FileInputStream(f)
var ch = f.read()
while (ch != -1) {
print(ch)
ch = f.read
}
} catch {
case fnfe:FileNotFoundException =>
println(f + ” not found, dude: ” + fnfe)
} // All others bubble out, even if checked in Java
}

64

Can I get a closure?
class Logger(level:Int) {
def debug(message: => String) = log(20,message)
def info(message: => String) = log(10,message)
def log(logLevel:Int, message: => String) = {
if (level >= logLevel) println(message)
}
}
val log = new Logger(10)
log.debug(“Got read for “ + read.date +
“ with usage “ + read.usage)
read.usage = 44
log.info(if read.usage < 10 “low read”
else “high read”)

65

}
}
read.usage = 44

66

}
}
read.usage = 44

67

}
}
read.usage = 44

68

}
}
read.usage = 44

69

“Literals”
val triStateArea = List(”MD”,”DC”,”VA”)
val theSouth = Map(”MD” -> true,”DC” -> false,
”VA” ->true)
val perlCirca96 = (true,”Tuples rule”)
val (hasTuples,message) = perlCirca96

70

“Literals”
”VA” ->true)

These are actually API calls

71

“Literals”
”VA” ->true)

This is done by the compiler
creates a Tuple2[Boolean, String]

72

“Literals”
class Read(val id:Int, val usage:Int, val age:Int)

object Read {
def apply(id:Int,usage:Int,age:Int) =
new Read(id,usage,age)
}

val read = Read(4,10,33)

73

“Literals”
class Read(val id:Int, val usage:Int, val age:Int)

object Read {
def apply(id:Int,usage:Int,age:Int) =
new Read(id,usage,age)
}

val read = Read(4,10,33) // shortcut via compiler
val read2 = Read.apply(4,10,33)

74

Crazy Awesome - Pattern Matching
def fromEnglish(string:String) = string match {
case “none” => 0
case “one” => 1
case _ => 2
}

75

def toUML(obj:Any) = obj match {
case 0 => “0”
case 1 => “0..1”
case n:Int => “0..” + n
case true => “1”
case false => “0”
case “many” => “0..*”
case _ => “0..*”
}

76

sealed abstract class Read
case class AMIRead(date:Date,usage:Int,duration:Int) extends Read
case class BillingRead(toDate:Date,usage:Int,numDays:Int,charges:Int) extends Read
case class CorrectedRead(read:BillingRead, usage:Int) extends Read

def proRate(read:Read) = read match {
case AMIRead(d,usage,duration) => usage / duration
case BillingRead(d,usage,days,c) => usage / days
case CorrectedRead(BillingRead(d,oldUsage,days,c),usage) =>
(oldUsage + usage) / days
}

77


}
• properties

• equals/toString/hashCode
• “extractor”

• no need for “new”
78


}

79


}

80


}

81


}

82

Crazy Awesome - Implicits

implicit def readToSeconds(r:Read):Int = r.date.getTime / 1000

def areConsecutive(from:Read, to:Read) =
(from - to) <= from.duration

83



(from - to) <= from.duration

Have a Read, but need an Int

84



(from - to) > from.duration

Needs a Read and gives an Int

85



(from - to) > from.duration

• Given this and matching, casting is rarely needed

86

Crazy Awesome - XML Literals
val xml = <html>
<head>
<title>Scala Pronunciation Guide</title>
</head>
<body>
<h1>How to Pronounce It</h1>
</body>
</html>

println(xml)

87

val lang = getLang
val title = translate(”scala.title”,lang)
val xml = <html lang={lang}>
<head>
<title>{title}</title>
</head>
<body>
<h1>{title.toUpperCase}</h1>
</body>
</html>

println(xml)

88

val lang = getLang
val title = translate(”scala.title”,lang)
val xml = <html lang={lang}>
<head>
<title>{title}</title>
</head>
<body>
<h1>{title.toUpperCase}</h1>
</body>
</html>

println(xml)

89

val states = List(”DC”,”MD”,”VA”)
val xml = <html>
<body>
<h1>States</h1>
<ul>
{ states.map( (state) => <li>{state}</li> ) }
</ul>
</body>
</html>

println(xml)

90

Message-passing
immutable objects

93

Message Passing
Immutable objects
“actors” with “mailboxes”

94

case class Accumulate(amount: Int)
case class Reset
case class Total

object Accumulator extends Actor {
def act = {
var sum = 0
loop {
react {
case Accumulate(n) => sum += n
case Reset => sum = 0
case Total => reply(sum); exit
}
}
}
}

object Accumulators extends Application {
Accumulator.start
for(i <- (1 to 100)) {
Accumulator ! Accumulate(i)
}

Accumulator !? Total match {
case result: Int => println(result)
}
}

95

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

96

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

97

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

98

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

99

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

100

case class Reset
case class Total

def act = {
var sum = 0
loop {
react {
}
}
}
}

Accumulator.start
for(i <- (1 to 100)) {
}

}
}

101

There’s a lot more to it

102

Demo
Fill Gaps in Electric Meter Reads

104

6/1 6/2 6/4 6/5 6/8
5 kwh 7 kwh 3 kwh 5 kwh 8 kwh

105

6/1 6/2 6/4 6/5 6/8
5 kwh 7 kwh 3 kwh 5 kwh 8 kwh
6/3 6/6 6/7
?? ?? ??

106

for all consecutive reads r1 and r2
if r2 - r1 > one day
ﬁll gaps for (r1,r2)

107

fill:
for all reads (first,second,List(rest))
if gap(first,second)
fill_gap(first,second) + fill(second + rest)
else
first + fill(second + rest)

108

fill:
for all reads (first,second,List(rest))
if !first || !second
reads
else if gap(first,second)
fill_gap(first,second) + fill(second + rest)
else
first + fill(second + rest)

109

def fillReads(
strategy: (MeterRead,MeterRead) => Seq[MeterRead],
reads:List[MeterRead]):List[MeterRead] =

reads match {
case List() => List()
case first :: List() => List(first)
case first :: second :: rest if gap(first, second) =>
first :: strategy(x,y).toList ::: fillReads(strategy, second :: rest)
case first :: rest => first :: fillReads(strategy,rest)
}

110

def fillReads(

reads match {
}

111

def fillReads(

reads match {
}

112

(demo with code)

113

It’s all happy ﬂowers and meadows?

114

It’s all happy ﬂowers and meadows?
not quite; a few stumbling blocks

115

Generics, type-variance, etc. can
get really confusing at times

116

Library docs not as extensive as
Java’s

117

Still have to compile

118

Symbol Soup sometimes

119

Symbol Soup sometimes
...but it gets easier

120

Static typing sometimes paints you into
a (very dark and confusing) corner

121

sometimes you just need
method_missing

122

sometimes you just need
monkey patching

123

Where is Scala now?

124

mailing lists, irc, a few blogs

126

One good book, a few others

127

Online docs improving, but
scattered

128

Spec is surprisingly readable

129

Java is on the decline

130

Java is on the decline
and Ruby and Python aren’t the
only options

131

Scala for Java Developers - Intro

More Related Content

What's hot

Similar to Scala for Java Developers - Intro

Recently uploaded

Scala for Java Developers - Intro