Getting Started With Scala

Getting Started with Scala

Vikas Hazrati - vhazrati@xebia.com

Meetu Maltiar - mmaltiar@xebia.com

OSScamp Delhi 2009

Agenda
I. What is FP and OOP? I. Features
– Quick comparison
with Java
I. Introducing Scala – Function Values and
Closures
– Scalable Languages
– Traits
– Scala is a Scripting
language – Pattern Matching
– Scala is Java of future I. End Notes
– Scala is OO - Who is using it ?
– Scala is Interoperable - Tool support
- Learning resources

What is FP
Is a concept where you can pass functions as
arguments, to store them in variables, and to
return them from other functions.

What is OOP?
Object Oriented Programming is
programming which is oriented
around objects

Takes advantage of Encapsulation,
Polymorphism, and Inheritance to
increase code reuse and decrease
code maintenance.

Scala: FP and OOP language
Scala is a object oriented and functional programming
language which is completely interoperable with java

FP: Makes it easy to build interesting things from simple parts, using
– Higher order functions
– Algebraic types and pattern matching
– Parametric polymorphism
OOP: Makes it easy to adopt and extend complex systems using
– Subtyping and inheritance
– Dynamic configurations
– Classes as partial abstractions

Scalable languages

A language is scalable if it is suitable for very small as well as
very large programs.

A single language for extension scripts and the heavy lifting.

Application-specific needs are handled through libraries and
embedded DSL's instead of external languages.

Scala shows that this is possible.

8

Scala is a scripting language
It has an interactive read-eval-print-loop (REPL).
Types can be inferred.
Boilerplate is scrapped.
scala> var capital = Map("US" → "Washington", "France" → "Paris")
capital: Map[String, String] = Map(US → Washington, France →
Paris)
scala> capital += ("Japan" → "Tokyo")
scala> capital("France")
res7: String = Paris

9

Scala is the Java of the future
It has basically everything Java has now.
(sometimes in different form)
It has closures.
(proposed for Java 7, but rejected)
It has traits and pattern matching.
(do not be surprised to see them in Java 8, 9 or 10)
It compiles to .class files, is completely interoperable and runs about as fast as
Java

object App {
def main(args: Array[String]) {
if (args exists (_.toLowerCase == "-help"))
printUsage()
else
process(args)
}
}

10

Scala is object-oriented

Every value is an object
Every operation is a method call
Exceptions to these rules in Java (such as
primitive types, statics) are eliminated.
scala> (1).hashCode
res8: Int = 1
scala> (1).+(2)
res10: Int = 3

11

Interoperability

Scala fits seamlessly into a Java environment
Can call Java methods, select Java fields, inherit Java
classes, implement Java interfaces, etc.
None of this requires glue code or interface descriptions
Java code can also easily call into Scala code
Scala code resembling Java is translated into virtually
the same bytecodes.
⇒ Performance is usually on a par with Java

12

III. Scala Features

13

Scala compared to Java

Scala adds Scala removes
+ a pure object system - static members
+ operator overloading - primitive types
+ closures - break, continue
+ mixin composition with - special treatment of
traits interfaces
+ existential types - wildcards
+ abstract types - raw types
+ pattern matching - enums

14

Scala cheat sheet (1): Definitions

Scala method definitions: Java method definition:

def fun(x: Int): Int = { int fun(int x) {
result return result
} }

def fun = result (no parameterless methods)

Scala variable definitions: Java variable definitions:

var x: Int = expression int x = expression
val x: String = expression final String x = expression

15

Scala cheat sheet (2): Objects and
Classes
Scala Class and Object Java Class with statics

class Sample {
class Sample(x: Int, val p: Int)
{ private final int x;
def instMeth(y: Int) = x + y public final int p;
} Sample(int x, int p) {
this.x = x;
this.p = p;
object Sample {
}
def staticMeth(x: Int, y: Int) int instMeth(int y) {
= return x + y;
x*y }
} static int staticMeth(int x,
int y) {
return x * y;
}
}

16

Scala cheat sheet (3): Traits
Scala Trait Java Interface

trait T { interface T {
def abstractMth(x: String): Int int abstractMth(String x)
def concreteMth(x: String) = }
x + field
(no concrete methods)
var field = “!”
(no fields)
}

Java extension + implementation:
Scala mixin composition:
class C extends Super
class C extends Super with T implements T

17

Scala Compared to Java

class CreditCard(val number: Int, var creditLimit: Int)

javap -private CreditCard

public class CreditCard extends java.lang.Object implements
scala.ScalaObject{
private int creditLimit;
private final int number;
public CreditCard(int, int);
public void creditLimit_$eq(int);
public int creditLimit();
public int number();
public int $tag() throws java.rmi.RemoteException;
}
18

Constructors
class Person(val firstName: String, val lastName: String) {
private var position: String = _
println("Creating " + toString())
def this (firstName: String, lastName: String, positionHeld: String) {
this (firstName, lastName)
position = positionHeld
}
override def toString() : String = {
firstName + " " + lastName + " holds " + position + " position "
}
}

19

Statics in Scala

20

Higher Order Functions

21

Currying & Partial Functions
Currying in Scala transforms a function that takes more than one
parameter into a function that takes multiple parameter lists.

22

Closures

You can create code blocks with variables that are not bound.

You will have to bind them before you can invoke the function; however,
they could bind to, or close over, variables outside of their local scope
and parameter list.

That’s why they’re called closures.

23

Traits
They are fundamental unit for code reuse in Scala

A Trait encapsulates method and field definitions, which can be
reused by mixing them in classes

Unlike class inheritance , in which class must inherit from just one
superclass, a class may mix in any number of Traits

Unlike Interfaces they can have concrete methods

25

Traits
trait Philosophical {
def philosophize() {
println("I consume memory, therefore I am!")
}
}

class Frog extends Philosophical {
override def toString() = "green"
}

val latestFrog = new Frog
println("" + latestFrog)
latestFrog.philosophize()
val phil:Philosophical = latestFrog
phil.philosophize()

26

Pattern Matching

All that is required is to add a single case
keyword to each class that is to be pattern
matchable

Similar to switch expect that Scala compares
Objects as expressions

27

Pattern Matching
object PatternApplication {
def main(args : Array[String]) : Unit = {
println( simplifyTop(UnOperator("-", UnOperator("-", Variable("x")))))
println( simplifyTop(BinOperator("+", Variable("x"), NumberOperator(0))))
println( simplifyTop(BinOperator("*", Variable("x"), NumberOperator(1))))
}

def simplifyTop(expr: Expression): Expression = expr match {
case UnOperator("-", UnOperator("-", e)) => e // Double negation
case BinOperator("+", e, NumberOperator(0)) => e // Adding zero
case BinOperator("*", e, NumberOperator(1)) => e // Multiplying by one
case _ => expr
}
}

28

Tool support
– Standalone compiler: scalac
– Fast background compiler: fsc
– Interactive interpreter shell and script runner: scala
– Web framework: lift
– Testing frameworks:
Specs, ScalaCheck, ScalaTest, SUnit, …
IDE plugins for:
– Eclipse (supported by EDF)
– IntelliJ (supported by JetBrains)
– Netbeans (supported by Sun)

30

Who’s using it?
Open source projects:
lift
wicket
NetLogo
SPDE: Scala branch for Processing
Isabelle: GUI and code extractor

Companies:
Twitter: infrastructure
Sony Pictures: middleware
Nature.com: infrastructure
SAP community: ESME company messaging
Reaktor: many different projects
Mimesis Republic: multiplayer games
EDF: trading, …

31

Learning Scala
To get started:
First steps in Scala, by Bill Venners
published in Scalazine at www.artima.com

Scala for Java Refugees by Daniel Spiewack
(great blog series)

To continue:
Programming in Scala, by Odersky, Spoon,
Venners, published by Artima,com

Other books are in the pipeline.

32

Contact Us
Vikas Hazrati - vhazrati@xebia.com

Meetu Maltiar - mmaltiar@xebia.com

www.xebiaindia.com
www.xebia.com
http://blog.xebia.in
http://blog.xebia.com

34

References
“Programming in Scala” book by Martin Odersky, Lex Spoon and Bill Venners

Presentation by Martin Odersky at FOSDEM 2009
http://www.slideshare.net/Odersky/fosdem-2009-1013261

Online book on Scala by oreilly
http://programming-scala.labs.oreilly.com/

Magazine for Scala Programming Community
http://www.artima.com/scalazine

35

Getting Started With Scala

Recommended

More Related Content

What's hot (16)

Similar to Getting Started With Scala (20)

More from Xebia IT Architects (20)

Recently uploaded (20)

Getting Started With Scala