This presentation was presented by Meetu Maltiar and Vikas Hazrati @OssCamp on 6th Sep 2009 at Netaji Subash Institute of Technology.

1. Getting Started with Scala
Vikas Hazrati - vhazrati@xebia.com
Meetu Maltiar - mmaltiar@xebia.com
OSScamp Delhi 2009

2. 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

3. I. What is FP and OOP?

4. 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.

5. 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.

6. 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

7. 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.
8

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
9

10. 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

11. 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

12. 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

13. III. Scala Features
13

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 - special treatment of
traits interfaces
+ existential types - wildcards
+ abstract types - raw types
+ pattern matching - enums
14

15. 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

16. 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

17. 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

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

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

20. Statics in Scala
20

21. Higher Order Functions
21

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

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 scope
and parameter list.
That’s why they’re called closures.
23

24. Closures
24

25. 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

26. 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

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
27

28. 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

29. IV. End Notes
29

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)
30

31. 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

32. 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

33. 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
34

35. 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