Scala

Andreas Enbohm 2009-03-15 Scala or ” The Free Lunch is Over”

Why Scala
The free lunch is over...
Today – 2 Cores
2010 maybe 12 (AMD), in 5 years maybe 16
Difficult to utilize several CPUs with Java
Huge API in current Java – some argue it may collape due to its own weight
Scala = ScalableLanguage
Designed to fit todays and some of tomorrows programming paradigms
Actors – Easier to utilize than memory synchronization (more about this later)
Nice (less boiler plate code) syntax and ’type safe duck typing’
And much more...

Scala - Features
OO and functional language ” a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way ”
Functional language – (often) no side effect, avoids state and mutable data, i.e functions can run independently and without knowlegde of eachother
Open Source
Compact code, ca 50 % less code than Java
Static typed language (but with ’kind of’ duck typing, more about this later)
Pattern matching, singel inheritance, immutable collections (like Java Strings), XML as FCC
SUnit, Lift (web framework), Support for Maven, Ant, Plugins for Eclipse, Netbeans, IntelliJ
Why not Ruby, Groovy, F#? - Fully interoperable with Java (call Java classes whenever you want) - Refactoring (static typed) - runs on world’s best VM! - very simple to inherit from Java classes - Javas annotations, threads, for each, it all works - Very fast (600x faster than groovy, lift 6x faster than Rails?)
def sum(a:Int,b:Int) = a+b

Scala – Compared to Java
Defining a class
Everything in Scala is an Object! This also includes functions
class Person (var firstName: String, var lastName: String) { } public class Person { private String firstName; private String lastName; public Person(String firstName, String lastName) { this .firstName = firstName; this .lastName = lastName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this .firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this .lastName = lastName; } }

Defining variables - ; and type can often be omitted
Creating objects
List is of type List[String] by default
List objects in Scala contains several useful functions to access elements in the List
Ommiting some dots…
val myInt: Int = 1; val anotherInt = 2 val anObject = Object //Omit () if you want just ’cluttering’ your code val aList = List(”John Doe”, ”Jane Doe”, ”Baby Doe”) println ("Hi, " +aList.tail.head) //Prints “Hi, Jane Doe” List<String> aList = new ArrayList<String>(); //Java syntax for creating a list-object val aList = List //Scala syntax for creating corresponding list val aList = List[String] //Also works, notice just ONE generic definiton import java.util.{Date,Locale} import java.text.DateFormat import java.text.DateFormat._ val now = new Date val df = getDateInstance(LONG, Locale.FRANCE) println ( df format now) //same as df.format(now)

Exceptions - Scala has no checked exception (unlike Java but like C#) - If used with Java, use annotation @throws(classOf[IOException])
Using pattern matching and functions
Scala uses ’ traits’ which can be compared to interfaces. Can have implementations (but no state)
try { doSomething(params) } catch { case ex: IOException => println("Oops! Some file is probably missing") case ex: NullPointerException => println(“Dohh!! Must initialize the variable ") } object MatchTest1 extends Application { def matchTest(x: Int): String = x match { case 1 => "one" case 2 => "two" case _ => "many" } println (matchTest(1)) //Prints “one” println (matchTest(99)) //Prints “many” }

Duck Typing in Scala
” If it walks like a duck and quacks like a duck, then I would call it a duck.” – Wise Guy
Statically typed language don’t offer this flexibility (Java, C#) - i.e. no ’Duck Typing’
Downside – what happens if object does not have a ’quack’-method -> RuntimeException!
In Java, we must add an interface with method ’quack()’ – impossible to add an interface without changing the class!
class Duck { public void quack() { print(”Duck Quacking!”) } class Person { public void quack() { print(”Person Quacking!”) } } Duck d = new Duck(); Person p = new Person(); testQuack(d); testQucak(p); testQuack(duckableObject) { duckableObject.quack(); //Lets hope this work!!! }

Duck Typing in Scala
However Scala offers ’Structual Typing’ – a.k.a. Type safe duck typing
Consider following example (Scala syntax)
Scala offers structual typing, i.e. def getName() in test
The structual type ’getName()’ checks at compile time that ’aFileObject’ has a getName() method if not – compile error
If getName() is needed more than one, use traits.
class File (name: String) { def getName(): String = name def open() { /*..*/ } def close() { println("close file") } } def testPrintName (aFileObject: { def getName(): String }) { println (aFileObject.getName) } testPrintName (new File("test.txt")) testPrintName (new java.io.File("test.txt")) trait HasName { def getName() : String } def testPrintName (HasName f) = { println(f.getName) }

Actors
” Don't bring the grape juice into the living room“ – Brian Goetz
Java threads - shared memory, i.e. only one thread can operate on a shared resource concurrently - expensive to create, i.e. every thread has a high memory consumption - context switch. i.e a Java thread maps to a OS thread (limited numbers ~3K) - context switch make page faults - > slow due to thread needs to re-read data from RAM - difficult to use, i.e. deadlocks, raise conditions, live locks, NASA Mars explorer experied live lock - synchronize, i.e. not just a a monitor/lock but also write to main memory (no registers) ~100 slower! - Java was designed for single processors, not multi-cores!
Actor based concurrency - concurrenct processes communicates by exchanging messages - asynchronous message passing - ’share-nothing’-model - Erlang early to implement this style of concurrency - Erlang based web server ~80000 clients, Apache ~4000 clients
Two flavours in Scala; - Thread based actors – high level abstraction of threads which replaces error-prone shared memory access - Thread less actors – offers enourmous scalability. Lightweight processes are used as actors with much less overhead than a usual thread. ’Piggy-backs’ on calling threads stack trace (continuation closure)

Downsides
” With great power comes great complexity” – James Gosling
New languages difficult to introduce to organisations
Not ready for prime time?

Questions?
http://www.scala-lang.org/

Scala

by Andreas Enbohm on Jun 24, 2010

Accessibility

Upload Details

Usage Rights

Statistics

Scala Presentation Transcript