Scala Introduction

Scala(Or how to have fun again as a server side developer) Adrian Spender

History Lesson: Java• Developed by Sun Microsystems. Released in 1995• Maintained and extended through the JCP process• Values backwards compatibility above all else• Strongly typed and OO• Pace of change is slow and political

The evolution of Java

The evolution of Java Generics Annotation Auto boxing Inner classes Assertions Enumerations Javabeans Swing Dynamic Reg exps Varargs Script RMI Collections proxies XML foreach languagesAWT Reﬂection Concurrency 1.0 1.1 1.2 1.3 1.4 5.0 61996 1997 1998 2000 2002 2004 2006

Java popularity http://www.tiobe.com/index.php/paperinfo/tpci/Java.html

The JVM• Execution environment for the Java bytecode• A speciﬁcation maintained through the JCP• Comes in various implementations for a variety of platforms, but guarantees binary compatibility• Provides garbage collection, code validation and much more• Does not currently provide inherent support for dynamic typing

The JVM runs more than just Java

The JVM runs more than just JavaPHP Javascript (Rhino) JACL C Erlang

History Lesson - Ruby• Java is the compiled OO language of choice for server side development in the enterprise (ignoring MSFT technologies)• PHP, Python and other scripted languages rule the roost in the non- enterprise• Ruby aims to be the best of both worlds • Released in 1996 • Dynamic typing • Memory management • OO, Functional, Imperative, Reﬂective styles • Designed to be fun and productive to write in • Excellent for rapid web apps thanks to the Rails framework

Ruby popularity http://www.tiobe.com/index.php/paperinfo/tpci/Ruby.html

How Twitter killed Ruby (or vice-versa)• Twitter launched in 2006 - written almost entirely in Ruby• Exploded in popularity in 2007 and went supernova in 2008

Ok, so it wasn’t all Ruby’s fault• However, there’s no doubt that Ruby took a hit• People questioned Ruby’s ability to scale • A lot of Twitter’s problems were down to how they had implemented message queues in Ruby. • “Its the heavy lifting, asynchronous processing type of stuff that weve moved away from [Ruby for].” - Alex Payne, Twitter developer http://www.theregister.co.uk/2009/04/01/twitter_on_scala/

What did Twitter move to? http://www.artima.com/scalazine/articles/twitter_on_scala.html

What is Scala?• Designed by Martin Odersky - creator of the javac compiler (from 1.3) and designer of Java’s generics• Developed as an academic project at the Programming Methods Lab at EPFL in Switzerland in 2003/4 • Is un-encumbered by corporate strategy or politics • Is focussed much more on language evolution rather than backwards compatibility • Just received €2.3m in ERC funding to develop language in the area of parallel processing. http:// www.scala-lang.org/node/8579

What is Scala?• Runs on the JVM - compiles into Java bytecode • Fast • Scalable • Interoperable with Java (and therefore any Java technologies such and JDBC, JMS and so on) • General purpose

Scala popularity• In the TIOBE 2010 programming Community Index Scala was the 50th most popular language • By comparison: • 1 - Java • 2-C • 6 - C# • 8 - Objective-C • 10 - Ruby • 11 - Javascript • 23 - Object Pascal!!! • 49 - Visual Basic .NET!!!• But that isn’t the whole story... http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Scala popularity • January 2011 Thoughtworks Radar report identiﬁes Scala as a “trial” technology“Since the last radar we have realizedthat the wider applicability of Scalamakes it more approachable forenterprise developers, and we havewitnessed great successes in theadoption of Scala.” http://www.thoughtworks.com/radar

I can honestly say if someone had shown me theProgramming in Scala book by by Martin Odersky,Lex Spoon & Bill Venners back in 2003 Id probablyhave never created Groovy.James Strachan, creator of Groovy http://macstrac.blogspot.com/2009/04/scala-as-long-term-replacement-for.html Scala, it must be stated, is the current heir apparent to the Java throne. No other language on the JVM seems as capable of being a "replacement for Java" as Scala, and the momentum behind Scala is now unquestionable Charles Nutter, creator of JRuby http://blog.headius.com/2009/04/future-part-one.htmlQ: Which programming language would you now use on top of the JVM,other than Java?James Gosling, creator of Java: Scala http://www.adam-bien.com/roller/abien/entry/java_net_javaone_which_programming

Key characteristics• Pure OO language• Strongly typed, but with type inference• Powerful collections• Encourages immutability (but doesn’t enforce)• Supports imperative and functional styles• First class pattern matching• First class XML types• Concurrency via actors• DSLs• Interoperates fully with Java

Scala > Java?• Elegant, expressive, compact syntax• Less boilerplate code• More productivity• Less maintenance• Fewer runtime errors• Much better concurrency• If stuck, do it in Java - the best of both worlds!

HelloWorld

HelloWorld2.scalaobject HelloWorld2 { def main(args : Array[String]) : Unit = { println("Hello World!") }}

HelloWorld3.scalaobject HelloWorld3 extends Application { println("Hello World!")}

Compiling & Running

How about...

Pure OO• No primitive types • Everything derives from base Any class• No null, void• No operators - just methods • +, !=, :: are all examples of methods• No static members • First class singleton objects• Single inheritance• Traits (think interfaces with method implementations)

Pure OO• Lots of syntactic sugar and magic to help

Pure OO • Lots of syntactic sugar and magic to helpval x = 1val y = x + 1

Pure OO • Lots of syntactic sugar and magic to helpval x = 1val y = x + 1is actuallyval x = 1val y = x.+(1)

Pure OO • Lots of syntactic sugar and magic to helpval x = 1 val square = (x: Int) => x * xval y = x + 1 val x2 = square(2)is actuallyval x = 1val y = x.+(1)

Pure OO • Lots of syntactic sugar and magic to helpval x = 1 val square = (x: Int) => x * xval y = x + 1 val x2 = square(2)is actually is actuallyval x = 1 val square = new Function1[Int, Int]() {val y = x.+(1) def apply(x: Int) : Int = x * x } val x2 = square.apply(2)

Type InferenceJava: List<String> list = new ArrayList<String>(); list.add("A"); list.add("list"); list.add("of"); list.add("strings");

Type InferenceJava: List<String> list = new ArrayList<String>(); list.add("A"); list.add("list"); list.add("of"); list.add("strings");Scala: val list = List("A", "list", "of", "strings")

Type InferenceJava: List<String> list = new ArrayList<String>(); list.add("A"); list.add("list"); list.add("of"); list.add("strings");Scala: val list = List("A", "list", "of", "strings") val list2 = "Another" :: "list" :: "of" :: "strings" :: Nil

Classespublic class Point { private int x; private int y; public Point(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } @Override public String toString() { return "(" + x + ", " + y + ")"; }}

Classespublic class Point { private int x; private int y; public Point(int x, int y) { this.x = x; this.y = y; } class Point (val x: Int, val y: Int) { public int getX() { override def toString(): return x; String = "(" + x + ", " + y + ")"; } } public int getY() { return y; } @Override public String toString() { return "(" + x + ", " + y + ")"; }}

Singletonsimport scala.collection.mutable.Mapobject PersonCache { private val cache = Map[String, Person]() def getPerson(id: String) : Person = { if(cache.contains(id)) cache(id) else { val person = retrievePerson(id) cache += (id -> person) person } } ... }

Companions• A given class can have an associated companion singleton object • Must have the same name, in the same source ﬁle• The companion object has full access to private members of the class• Most common use case is to act as a factory• More advanced uses include deﬁnition of implicit conversions

Traits• Traits are like interfaces• However they can have method implementations• Can be used as mixins• Can do pretty much anything a class can• Become a powerful method of code reuse

Traitstrait Animal { def move() : String def noise() : String def breathe() = "In and out"}trait Swimmer { def swim() = "Splish splosh"}trait Flyer { def fly() = "Flap flap"}trait Walker { def walk() = "One leg in front of the other"}

Traitstrait Animal { class Bird extends Animal with Flyer{ def move() : String def noise() = "Squark" def noise() : String def move() = fly } def breathe() = "In and out"} class Dog extends Animal with Walker { def noise() = "Woof"trait Swimmer { def swim() = "Splish splosh" def move() = walk} }trait Flyer { class Fish extends Animal with Swimmer { def fly() = "Flap flap" def noise() = "Glup glup" } def move() = swimtrait Walker { } def walk() = "One leg in front of the other" class Penguin extends Bird with Swimmer {} override def move() = swim }

Powerful Collections

Functional style• Java is an imperative style• Scala can do imperative but encourages functional • Strongly encourages immutability • If you have vars then you are being imperative • Discourages functions with side effects • If the return is Unit, then the function probably has side effects • Allows currying, higher-order functions, monads, closures, tail recursion etc.

Functions (and closures)Scala: val twoThreeFourFive = oneTwoThreeFour.map(s => s + 1)

Functions (and closures)Scala: val twoThreeFourFive = oneTwoThreeFour.map(s => s + 1)Java: List<Integer> twoThreeFourFive = new ArrayList<Integer>(); for(Integer i : oneTwoThreeFour) { twoThreeFourFive.add(i + 1); }

Imperative v Functional• Task: • Print out num values of the Fibonacci sequence separated by spaces • Example (num = 10): 0 1 1 2 3 5 8 13 21 34

Imperativedef printFibonacci(num: Int) : Unit = { val arr = new Array[BigInt](num) arr(0) = 0 arr(1) = 1 var i=2 while (i < num) { arr(i) = arr(i-1) + arr(i-2) i += 1 } for (x <- 0 until arr.length) print(arr(x) + " ")}printFibonacci(10)

But that is just Javawithout Semicolons

Functionaldef fib(n: Int): BigInt = n match { case 0 => 0 case 1 => 1 case _ => fib(n-1) + fib(n-2)} def genFibonacci(num: Int) : Array[BigInt] = { Array.tabulate(num) (x => fib(x))} val sequence = genFibonacci(10)print(sequence.mkString(" "))

More Functional!lazy val fib: Stream[BigInt] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map( p => p._1 + p._2)))def genFibonacci(num: Int) : Array[BigInt] = { fib.take(num).toArray} val sequence = genFibonacci(10)print(sequence.mkString(" ")) http://www.scala-blogs.org/2007/12/project-euler-fun-in-scala.html

Pattern matching• Already seen one example: def fib(n: Int): BigInt = n match { case 0 => 0 case 1 => 1 case _ => fib(n-1) + fib(n-2) }• Scala can match against any object def toRomanNumeralOne(n: Any): Option[String] = { val numeral = "I" n match { case "I" => Some(numeral) case 1 => Some(numeral) case "one" => Some(numeral) case _ => None } }

Case Classes• A class with the keyword case gets the following for free: • Constructor parameters become public ﬁelds • toString, equals and hashCode implemented • A singleton companion object • Basically a factory • Provides apply and unapply• This makes it easy to deﬁne basic data objects• All this also means they can be used in pattern matching

Remember this?class Point (val x: Int, val y: Int) { override def toString(): String = "(" + x + ", " + y + ")";}val point1 = new Point(1,2)val x = point1.x

Remember this? class Point (val x: Int, val y: Int) { override def toString(): String = "(" + x + ", " + y + ")"; } val point1 = new Point(1,2) val x = point1.xUsing a case class we just need this: case class Point (x: Int, y: Int) val point2 = Point(1,2) val x = point2.x

XML Typescase class Person(firstName: String, lastName:String) { def toXML = <person> <firstName>{ firstName }</firstName> <lastName>{ lastName }</lastName> </person> def fromXML(node: scala.xml.Node): Person = { new Person( (node firstName).text, (node lastName).text) }}

Actors• Java uses a shared memory and lock based concurrency model• Scala uses an Actor based model made popular by Erlang• Actors communicate with each other by passing messages • Each actor receives (or reacts to) messages and can send messages

Snap exampleimport scala.actors.Actorimport scala.actors.Actor._case class Card(num: Int)case object Snapclass Player(stack: Array[Card], player2: Option[Player]) extends Actor { def this(stack: Array[Card], otherPlayer: Player) = this(stack, Some(otherPlayer)) def this(stack: Array[Card]) = this(stack, None) def act() { var round = 0 val name = player2 match { case None => "Player 2" case Some(player) => println("Player 1: Starts the game with " + stack(round)) player ! stack(round) round += 1 "Player 1" } // Cont...

Snap example while (round < stack.length) { receive { case card: Card => if (card == stack(round)) { println(name + ": Snap!") sender ! Snap exit() } else { println(name + ": Plays " + stack(round)) sender ! stack(round) } case Snap => println(name + ": Well Played!") exit() } round += 1 } } // end of act method}

Snap example• Application: object SnapGame { val cards1 = Array(Card(0), Card(1), Card(2)) val cards2 = Array(Card(8), Card(7), Card(2)) val player2 = new Player(cards2) val player1 = new Player(cards1, player2) def main(args : Array[String]) : Unit = { player1.start player2.start } }

Snap example• Output: Player 1: Starts the game with Card(0) Player 2: Plays Card(8) Player 1: Plays Card(1) Player 2: Plays Card(7) Player 1: Plays Card(2) Player 2: Snap! Player 1: Well Played!

DSLs• Domain Speciﬁc Language examples • XSLT • SQL • WebSphere wsadmin• Scala makes it easy to create new DSLs• One good use of internal DSLs is in testing

Baysickobject Lunar extends Baysick { def main(args:Array[String]) = { 10 PRINT "Welcome to Baysick Lunar Lander v0.9" 20 LET (dist := 100) 30 LET (v := 1) 40 LET (fuel := 1000) 50 LET (mass := 1000) 60 PRINT "You are drifting towards the moon." 70 PRINT "You must decide how much fuel to burn." 80 PRINT "To accelerate enter a positive number" 90 PRINT "To decelerate a negative" 100 PRINT "Distance " % dist % "km, " % "Velocity " % v % "km/s, " % "Fuel " % fuel 110 INPUT burn 120 IF ABS(burn) <= fuel THEN 150 130 PRINT "You dont have that much fuel" 140 GOTO 100 150 LET (v := v + burn * 10 / (fuel + mass)) 160 LET (fuel := fuel - ABS(burn)) 170 LET (dist := dist - v) 180 IF dist > 0 THEN 100 190 PRINT "You have hit the surface" 200 IF v < 3 THEN 240 210 PRINT "Hit surface too fast (" % v % ")km/s" 220 PRINT "You Crashed!" 230 GOTO 250 240 PRINT "Well done" 250 END RUN }} http://blog.fogus.me/2009/03/26/baysick-a-scala-dsl-implementing-basic/

Specsclass helloWorld extends Specification { val hw = "hello world" "hello world has 11 characters" in { hw.size must be equalTo(11) } "hello world matches h.* w.*" in { helloWorld must be matching("h.* w.*") }} http://code.google.com/p/specs/

Java interop• Scala code can implement Java interfaces• Scala code can call Java code • This is generally very straightforward• Java code can call Scala code • This is sometimes more tricky if your Scala code uses language features that don’t exist in Java • May also need to understand what bytecode looks like e.g. a + operator method ends up as in Java ( $plus ) • Differences between traits and interfaces • Annotation differences/behaviour • Exception behaviour • Higher order functions

Cache sync examplepackage com.adrianspender.groupsync.java;/** * Provides methods to synchronize data stored locally in a * persistent cache with the authoritative source. */public interface GroupSyncService { /** * Retrieve the groups that the given person ID is in * from the definitive resource, and update the * persistent cache that we use ourselves. * * @param personId the id of the person to sync */ public void syncGroups(String personId); }

Cache sync examplepackage com.adrianspender.groupsync.java;import java.util.Set;/** * Represents some group service e.g. LDAP */public interface AuthoritativeSource { /** * For a given person ID return the list of Group IDs that the person * is in. If the user is in no groups, returns an empty set. * * @param personID the ID of the person * * @return the IDs of the groups the person is in */ public Set<String> getGroups(String personId); }

Cache sync examplepackage com.adrianspender.groupsync.java;import java.util.Set;/** * Represents our persistent cache. This would execute SQL * queries against the DB. */public interface PersistentCache { /** * Retrieve all of the groups that the given person is in, according * to our cache. If the user is in no groups, then return an empty set * * @param personID the personID * * @return the IDs of the groups the cache thinks the person is in */ public Set<String> retrieveAllGroups(String personId); /** * Removes all of the groups from the cache for the given person * * @param personID the personID */ public void removeAllGroups(String personId); // cont...

Cache sync example /** * Adds the newly joined groups to the cache for the given person. * * @param personID the person ID * * @param addedGroups the new groups that the person is in */ public void addNewGroups(String personId, Set<String> addedGroups); /** * Removes the newly removed groups from the cache for the given person. * * @param personID the person ID * * @param removedGroups the groups the person is no longer in */ public void removeGroups(String personId, Set<String> removedGroups); }

Cache sync examplepackage com.adrianspender.groupsync.scala.implimport com.adrianspender.groupsync.java._import scala.collection.JavaConversions._/* * The Scala version of our group sync service.. */class GroupSyncServiceImpl(authoritativeSource: AuthoritativeSource, persistentCache: PersistentCache) extends GroupSyncService { def syncGroups(personId: String): Unit = { val currentGroups = authoritativeSource.getGroups(personId).toSet if (currentGroups.size() == 0) { persistentCache.removeAllGroups(personId) } else { val cachedGroups = persistentCache.retrieveAllGroups(personId).toSet persistentCache.addNewGroups(personId, currentGroups diff cachedGroups) persistentCache.removeGroups(personId, cachedGroups diff currentGroups) } }}

Cache sync example• Scala implementation = 24 lines• Java implementation = 47 lines• Can be tested using JUnit

Tool Support• IDE Support • Eclipse, Intellij IDEA, NetBeans• Build tools • SBT • But also ANT, Maven etc...• Testing • ScalaTest, Specs, ScalaCheck • But also JUnit, EasyMock, Mockito etc...• Web Frameworks • Lift • But also Struts, Spring MVC, Play etc...• Actors • Akka

Bookshttp://www.artima.com/shop/programming_in_scala_2ed http://oreilly.com/catalog/9780596155964 http://apress.com/book/view/9781430219897

Thank you

http://adrianspender.com	236
http://static.slidesharecdn.com	7
http://twitter.com	1
url_unknown	1

Scala Introduction

by Adrian Spender on Feb 17, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

4 Embeds 245

Statistics

Scala Introduction — Presentation Transcript