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. Introducing Scala – Scalable Languages – Scala is a Scripting

language – Scala is Java of future– Scala is OO– Scala is Interoperable

I. Features – Quick comparison

with Java– Function Values and

Closures– Traits– Pattern Matching

I. End Notes- Who is using it ?- Tool support- Learning resources

I. What is FP and OOP?

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

II. Introducing Scala

8

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.

9

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

10

Scala is the Java of the futureIt 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) }}

11

Scala is object-oriented

Every value is an objectEvery operation is a method callExceptions to these rules in Java (such as

primitive types, statics) are eliminated.scala> (1).hashCoderes8: Int = 1

scala> (1).+(2)res10: Int = 3

12

Interoperability

Scala fits seamlessly into a Java environmentCan call Java methods, select Java fields, inherit Java

classes, implement Java interfaces, etc.None of this requires glue code or interface descriptionsJava code can also easily call into Scala codeScala code resembling Java is translated into virtually

the same bytecodes. ⇒ Performance is usually on a par with Java

13

III. Scala Features

14

Scala compared to Java

Scala adds Scala removes

+ a pure object system - static members

+ operator overloading - primitive types

+ closures - break, continue

+ mixin composition with traits

- special treatment of interfaces

+ existential types - wildcards

+ abstract types - raw types

+ pattern matching - enums

15

Scala cheat sheet (1): Definitions

Scala method definitions:

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

def fun = result

Scala variable definitions:

var x: Int = expression

val x: String = expression

Java method definition:

int fun(int x) { return result}

(no parameterless methods)

Java variable definitions:

int x = expression

final String x = expression

16

Scala cheat sheet (2): Objects and Classes

Scala Class and Object

class Sample(x: Int, val p: Int) { def instMeth(y: Int) = x + y}

object Sample { def staticMeth(x: Int, y: Int) = x * y}

Java Class with statics

class Sample { private final int x; public final int p; Sample(int x, int p) {

this.x = x; this.p = p;

} int instMeth(int y) { return x + y; } static int staticMeth(int x, int y) { return x * y; }}

17

Scala cheat sheet (3): Traits

Scala Trait

trait T {

def abstractMth(x: String): Int

def concreteMth(x: String) =

x + field

var field = “!”

}

Scala mixin composition:

class C extends Super with T

Java Interface

interface T { int abstractMth(String x)}

(no concrete methods)

(no fields)

Java extension + implementation:

class C extends Super implements T

18

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;}

19

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 " }}

20

Statics in Scala

21

Higher Order Functions

22

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

23

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 scopeand parameter list.

That’s why they’re called closures.

24

Closures

25

TraitsThey 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

26

Traitstrait 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()

27

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

28

Pattern Matchingobject 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

}

}

29

IV. End Notes

30

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)

31

Who’s using it?Open source projects:

liftwicketNetLogo SPDE: Scala branch for ProcessingIsabelle: GUI and code extractor

Companies:Twitter: infrastructureSony Pictures: middlewareNature.com: infrastructureSAP community: ESME company messagingReaktor: many different projectsMimesis Republic: multiplayer gamesEDF: trading, …

32

Learning ScalaTo 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.

33

34

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

35

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

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

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

Magazine for Scala Programming Communityhttp://www.artima.com/scalazine