BCS SPA 2010 - An Introduction to Scala for Java Developers

An Introduction to Scala
for Java Developers

Miles Sabin, Chuusai Ltd.
http://www.chuusai.com/

http://uk.linkedin.com/in/milessabin
http://twitter.com/milessabin

Outline
●
Background
●
Cleaning up Java
●
Going Beyond Java
●
Lab 1
●
Functional Focus
●
Lab 2
●
Roadmap

Background
●
Designed by Martin Odersky (Pizza, GJ and
Java 5) of EPFL as the successor to Funnel
●
Objectives,
●
Blend object-oriented and functional styles
●
Seamless interoperability with Java (and .Net?)
●
Project started in 2003
●
First public release in 2004
●
Currently at 2.7.7
●
2.8 release due very soon

Why Mix OO and FP?
●
Each has complementary strengths —
●
OO provides excellent support for,
– Subtyping and inheritance
– Modular components
– Classes as partial abstractions
●
FP provides excellent support for,
– Higher order functions
– ADTs, structural recursion and pattern matching
– Parametric polymorphism
●
They've been converging for a while now

Scala is the Future of Java
●
Scala can be thought of as a superset of
current Java
●
It has all the object-oriented features of
current Java (some in a slightly different and
improved form)
●
It already has many of the most desirable
proposed extensions to Java (eg. true closures)
●
Nevertheless, it compiles to Java bytecode
●
Flawless interopability with Java, leverages the
mature Hotspot JIT

Interoperbility with Java
●
There are many alternative JVM languages.
Some are also strongly “Java-compatible”
●
Close source and binary mapping to Java
– Scala, Groovy, JavaFX, AspectJ
●
For these, prospect is that most Java tools,
libraries and frameworks will Just Work, or
work with only minor adaptation
●
Additional promise of gradual migration of
existing Java projects

Tools and Frameworks
●
Idiomatic testing frameworks —
●
Specs, ScalaTest, ScalaCheck
●
Idiomatic web frameworks —
●
Lift
●
Wicket and Play recently added Scala support
●
IDE support — the big three (Eclipse,
Netbeans, IDEA) all actively developed

Who's Using It?
●
A rapidly growing list of companies and
projects,
●
Twitter (infrastructure)
●
Foursquare (front-end, infrastructure)
●
LinkedIn (analytics, infrastructure)
●
EDF Trading (analytics, infrastructure)
●
Sony Pictures Imageworks (infrastructure)
●
SAP/Siemens (ESME, enterprise messaging)
●
Novell (Pulse, enterprise messaging)

Scala has a REPL
●
Common in scripting and functional
languages
●
Great for exploratory programming
●
We'll be using it as we go along

Resources

●
http://www.chuusai.com/spa2010
●
CDs and Memory Stick circulating
●
Let me know if you have difficulties

Scala Cleans Up Java Syntax
●
Semi-colons are optional
●
equals is ==, == is eq
●
Periods are optional where unambiguous,
scala> val s = "Hello world"
s: java.lang.String = Hello world

scala> s length
res8: Int = 11

●
Binary method invokations can be written
in operator form,
scala> s substring 6
res9: java.lang.String = world

Scala Cleans Up Java Syntax
●
All statements are expressions and have a
value,
val m = if (n % 2 == 0) n/2 else n*3+1

val pow4 = { val sqr = n*n ; sqr*sqr }

val n =
try { s toInt }
catch { case _ : NumberFormatException => 0 }

●
Method bodies are expressions and curly
braces are optional
def findSlash(s : String) : Int = s indexOf '/'

Statically Typed with Inference
●
Type inference eliminates the most
annoying explicit typing annotations
●
All definitions must have a static type
val m : Map[Int, String]

●
However these types are typically inferred
scala> val m = Map(1 -> "one", 2 -> "two")
m : Map[Int, String] = Map(1 -> one, 2 -> two)

●
Method return types are also inferred
scala> def twice(i : Int) = i*2
twice: (i: Int)Int

Vals, Vars and Uniform Access
●
Scala simplifies immutable definitions,
val s : String = "Hello immutable world"
s = "Bye ..." // Error
var t : String = "Hello mutable world"
t = "Bye ..." // OK

●
(Im)mutable properties can be
implemented by vals, vars or methods
class User {
val name : String // Immutable
var email : String // Mutable
def pass : String // Computed
def pass_=(s : String) //
}

user.pass = "<secret>" // Sugar for user.pass_=("<secret>")

Case Classes are Lightweight
●
Eliminate a lot of the boilerplate associated
with Java implementations of simple data
types
public class User {
private final String name;
private final String pass;
public User(String name_, String pass_) {
name = name_;
pass = pass_;
}
public String getName() { return name; }
public String getPass() { return pass; }
public boolean equals(Object other) { ... }
public int hashCode() { ... }
public String toString() { ... }
}

Case Classes are Lightweight
●
The Scala equivalent,
case class User(name : String, pass : String)

●
Accessors, toString and correct equals
and hashCode provided automatically
●
“new” omitted
val joe = User("Joe Bloggs", "<secret>")

●
“Copy with changes” supports immutable
functional objects
val joeUpdated = joe.copy(pass = "<still secret>")

No Statics
●
No static fields or methods
●
Instead "object” entities similar to singletons
// Java
public class User {
public static newUser(String name, String pass) {
return new User(name, pass);
}
// Non-static methods ...
}

// Scala
object User /* extends ((String, String) => User) */{
def apply(name : String, pass : String) =
new User(name, pass)
}
val joe = User("Joe Bloggs", "<secret>")

Scala is Object Oriented
●
Scala has a uniform object model: no
primitive types

Scala is Object Oriented
●
Operators aren't special, they're methods
like any other,
x + 1 // equivalent to x.+(1)

●
Classes can define methods which can
invoked in operator form,
case class Complex(val re : Double, val im : Double) {
def +(rhs : Complex) = Complex(re+rhs.re, im+rhs.im)
def *(rhs : Complex) =
Complex(re*rhs.re-im*rhs.im, im*rhs.re+re*rhs.im)
}
val c1 = Complex(1.0, 1.0) ; val c2 = Complex(2.0, 3.0)
c1+c2 // == Complex(3.0, 4.0)
c1*c2 // == Complex(-1.0, 5.0)

Named and Default Arguments
●
Arguments can be specified at call sites by
name
def coord(x : Double, y : Double)
coord(y = 1.0, x = 0.7)

Allows them to be provided naturally for
the call site, and eliminates ambiguity
●
Arguments can also be given default values
def printList(l : List[Int], sep : String =", ") { ... }

val l = List(1, 2, 3)
printList(l) // equivalent to printList(l, ", ")

Tuples
●
Scala has tuple types and literals
val coord : (Double, Double) = (1.0, 0.5)
println(

Pattern Matching
●
Case classes model ADTs from functional
languages and support pattern matching
sealed trait Tree[T]
case class Leaf[T](elem: T) extends Tree[T]
case class Node[T](l: Tree[T], r: Tree[T]) extends Tree[T]

def find[T](tree : Tree[T], elem : T) : Boolean =
tree match {
case Node(l, r) => find(l, elem) || find(r, elem)
case Leaf(`elem`) => true
case _ => false
}

val t = Node(Node(Leaf("bar"), Leaf("baz")), Leaf("foo"))
find(t, "baz") // true

●
Matching is the inverse of construction

Mixin Composition
●
Java interfaces are replaced by traits and
mixin composition
●
Traits can provide method implementations
●
Traits can provide fields
trait UserId {
val name : String
var pass : String = "change me"
def display = name+":"+pass
}
class User(val name : String) extends UserId

val joe = new User("Joe Bloggs")
println(joe.display)

Mixin Composition
●
Traits support multiple inheritance whilst
avoiding the problems of “diamond”
inheritance
trait Email {
val address : String
def send(msg : String) {
println(

Laziness and By-Name Args
●
Values can be declared to be initialized
lazily
val (title, givenName, surname) = ("Mr.", "John", "Smith")
lazy val fullName = title+" "+givenName+" "+surname

The value is computed the first time it is
used (if at all)
val displayName = if (full) fullName else givenName

●
Create circular structures without update,
abstract class Link { val next : Link }
val (a : Link, b : Link) =
(new Link { lazy val next = b },
new Link { lazy val next = a })

Laziness and By-Name Args
●
Arguments can be passed by name
●
Similar to laziness in that evaluation is
deferred until use
●
Can be used to build specialized control
structures and enables internal DSLs
def locked[T](l : Lock)(op : => T) = {
l.lock
try { op } finally { l.unlock }
}
val lock = new ReentrantLock
var shared = ...
locked(lock) {
/* Use shared while holding lock */
}

Structural Typing
●
Scala has a form of statically checkable
duck-typing
●
We can use this to generalize libraries to
pre-existing types
type Closeable = { def close() }

def using[R <: Closeable, T](res : R)(op : R => T) =
try { op(res) } finally { res.close() }

val b = using(new FileInputStream("test.txt")) { _.read }

Implicit Conversions
●
Implicit functions provide a way to attach
new behaviours to exisiting types
●
Invoked if needed to typecheck
trait Closeable { def close : Unit }

def using[R <% Closeable, T](res : R)(op : R => T) =
try { op(res) } finally { res.close() }

implicit def InputStreamIsCloseable(is : InputStream) =
new Closeable { def close = in.close }

val b = using(new FileInputStream("test.txt")) { _.read }

●
Provides Haskell-like ad hoc polymorphism

The Scala IDE for
Eclipse

Main Features
●
Extends the JDT to support mixed
Scala/Java projects
●
Semantically aware editor
●
Project and source navigation
●
Incremental builder
●
Integrated debugger
●
Free, open source ...

Participate!
●
The Scala IDE for Eclipse's home
http://www.scala-ide.org/
●
Wiki, git repository, bugs
http://scala-ide.assembla.com/
●
Mailing lists
http://groups.google.com/group/scala-ide-user
http://groups.google.com/group/scala-ide-dev
●
Follow @ScalaIDE on Twitter

First-Class Functions
●
Scala allows the definition of functions
def plusOne(x : Int) = x+1

●
Functions can be arguments and results
def applyTwice(x : Int, f : Int => Int) = f(f(x))
applyTwice(3, plusOne) // == 5

●
Can be anonymous and close over their
environment
def twice(f : Int => Int) = (x : Int) => f(f(x))
twice(plusOne)(3) // == 5

●
Function literal syntax is concise
twice(_+1)(3) // == 5

Higher-Order Functions
●
Higher-order functions are used
extensively in Scala's standard library
List(1, 2, 3).map(_*2) // == List(2, 4, 6)

List(1, 2, 3, 4).find(_%2 == 0) // Some(2)

List(1, 2, 3, 4).filter(_%2 == 0) // List(2, 4)

def recip(x : Int) = if(x == 0) None else Some(1.0/x)

scala> List(0, 1, 2, 3).flatMap(recip)
res0: List[Int] = List(1.0, 0.5, 0.3333333333333333)

The Option Type
●
“Null References: The Billion Dollar
Mistake” — Tony Hoare
●
Scala provides a safe alternative
scala> List(1, 2, 3) find (_ == 2)
res0: Option[Int] = Some(2)

scala> List(1, 2, 3) find (_ == 4)
res0: Option[Int] = None

●
Option interacts nicely with matching
List(1, 2, 3) find (_ == 2) match {
case Some(i) => println("Found "+i)
case None => println("Not found")
}

For Comprehensions
●
Scala's “for comprehensions” capture
common patterns of use of map, flatMap
and filter
val l1 = List(0, 1)
val l2 = List(2, 3)

scala> for (x <- l1; y <- l2) yield (x, y)
res0: List[(Int, Int)] = List((0,2), (0,3), (1,2), (1,3))

The for expression desugars to,
l.flatMap(x => l2.map(y => (x, y))

●
These patterns are the monad laws for the
subject type

For Comprehensions
●
Option implements map, flatMap and Filter
so works nicely with for comprehensions
def goodPair(x : Int, y : Int) =
for(fst <- recip(x); snd <- recip(y))
yield (x, y)

scala> goodPair(1, 2)
res0: Option[(Int, Int)] = Some((1,2))

scala> goodPair(1, 0)
res0: Option[(Int, Int)] = None

●
Using Option rather than null has clear
benefits when used in this way

Roadmap
●
Upcoming releases,
●
Release Candidate 2 of 2.8 now available
●
2.8 Final expected July/August
●
Subsequent 2.8-series releases will
continue current exploratory work,
●
Type specialization (still needs library support)
●
Continuations (currently a compiler plugin)
●
Linear/immutable/non-null types

Find Out More
●
Scala's home at EPFL
http://www.scala-lang.org
●
See also the scala and scala-user mailing list
●
The London Scala Users' Group
http://www.meetup.com/london-scala
●
Publications
●
Programming in Scala
Odersky, Venners and Spoon
●
Programming in Scala
Wampler and Payne

BCS SPA 2010 - An Introduction to Scala for Java Developers

Recommended

More Related Content

What's hot (18)

Viewers also liked (9)

Similar to BCS SPA 2010 - An Introduction to Scala for Java Developers (20)

BCS SPA 2010 - An Introduction to Scala for Java Developers