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

Scala – Compared to Java 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)

Scala – Compared to Java 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

More Related Content

What's hot (19)

Viewers also liked (6)

Similar to Scala (20)

Scala

Editor's Notes