stepping up : a brief intro to scala
DESCRIPTION
The Scala programming language has been gaining momentum recently as an alternative (and some might say successor) to Java on the JVM. This talk will start with an introduction to basic Scala syntax and concepts, then delve into some of Scala's more interesting and unique features. At the end we'll show a brief example of how Scala is used by the Lift web framework to simplify dynamic web apps.TRANSCRIPT
![Page 1: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/1.jpg)
Stepping Up: A Brief Intro to Scala
Derek Chen-Becker, October 10th, 2009
![Page 2: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/2.jpg)
A little background Scala began around 2003, 2.0 in 2006,
currently at 2.7.5 (stable) Created by Martin Odersky (EPFL), of GJ,
and later Javac v5 fame Compiles to 100% Java Bytecode
Generally works flawlessly with Java Leverages JIT: performance ±5% of Java
Excellent community (mailing lists, IRC) In use at Twitter, Seimens, Xerox, and others
![Page 3: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/3.jpg)
Not quite déjà vu...Scala combines features from many different languages to form a unique hybrid:
Scala is pure OO. Everything is an object, even primitives
Scala has first-class function objects. Much of the library leverages function arguments
Scala has a comprehensive type system and a flexible inheritance mechanism
Method names have less restrictions. This allows for operator overloading and nice DSLs
Immutability is strongly supported and encouraged. This is important for multi-core
![Page 4: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/4.jpg)
Statics and Singletons
Scala makes a distinction between instance and static methods and fields by using a separate “object” entity to represent the latter
Objects are VM singletons Objects can be used to create custom
factories and pattern matching extractors (more in a moment)
![Page 5: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/5.jpg)
public class Bike { private String brand; private int gear;
public Bike(String brand, int gear) { this.brand = brand; this.gear = gear; }
public int getGear() { return gear; }
public void setGear(int gear) { this.gear = gear; }
public String getBrand() { return brand; } public String toString() { return String.format("This is a %s in gear %d", brand, gear); }}
Scala is Succinct
class Bike (val brand : String, var gear : Int) { override def toString = "This is a %s in gear %d" .format(brand, gear)}
![Page 6: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/6.jpg)
Scala has Case Classes
case class Book(title : String, author : String)
val classic = Book("A Tale of Two Cities", "Dickens")
val Book(title,author) = classic
Case classes are defined basically like normal classes
By default are immutable (good!) Constructor parameters are automatically vals Automatically get a companion object with
apply/unapply, as well as overrides for equals, hashCode and toString on the class itself
![Page 7: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/7.jpg)
Scala has Case Classes, part 2
class Vehicle(val description : String, val topSpeed : Long)
case class Airplane(description : String, topSpeed : Long, var fuel : Double) extends Vehicle(description,speed) { def takeOff {...}}
Can inherit from other classes (although inheriting from other case classes is being deprecated)
Can have their own methods just like normal classes
![Page 8: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/8.jpg)
Scala is Functional
Functions in Scala are first-class objects, and can be passed as arguments, assigned to variables, etc.
val printLog =
{ msg : String => // or ⇒ println(System.currentTimeMillis + ":" + msg) }
List("one", "two", "three").foreach(printLog)
![Page 9: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/9.jpg)
Scala is Functional, Part 2
Functions (and Scala's type system) allow you to do things like define new control structures in a type-safe way:
// Structural typing allows any type with a “close” methoddef using[A <: { def close() : Unit }, B] (resource : A ) (f : A => B) : B = try { f(resource) } finally { resource.close } val firstLine = using(new BufferedReader(new FileReader("/etc/hosts"))) { reader => reader.readLine }
![Page 10: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/10.jpg)
Scala has Closures
// Note that this example is not thread-safedef logAndAdd(name : String) = { var counter = 0
val logFunc = { msg : String => println(name + "-" + counter + ":" + msg) counter += 1 }
logFunc}
Closures capture variables in the scope of their definition. These are ideal for callbacks, among other things.
![Page 11: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/11.jpg)
Scala is Higher Level
case class User(name : String, age : Int)val people = List(User("Fred", 35), User("Barney", 32),...)
val sorted = people.sort(_.age < _.age).take(5)
// The same as :val sorted = people.sort({(a,b) => a.age < b.age}).take(5) val under30 = sorted.takeWhile(_.age < 30)
val youngest5 = sorted.take(5)
val oldest5 = sorted.takeRight(5).reverse
In particular, collections support complex operations directly:
![Page 12: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/12.jpg)
Scala has For-Comprehensions
val prefixes = List("/tmp", "/work", System.getProperty("user.home"))
val suffixes = List("txt", "xml", "html") def locateFiles(name : String) : List[String] = for (prefix <- prefixes; suffix <- suffixes; filename <- Some("%s/%s.%s".format(prefix, name, suffix)) if (new File(filename)).exists) yield filename
For-comprehensions provide an elegant construct for tying multiple sources and criteria together to extract information:
![Page 13: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/13.jpg)
Scala does Pattern Matching
def matchIt (in : Any) = in match { case 1 | 14 | "test" => {...} case x : Int => {...} case x : Double if x > 42.0 => {...} case Vehicle(description, _) => {...} case <head>{ stuff }</head> => {...} case _ => {...}}
Like the “switch” statement on steroids Incredibly powerful for expressing
conditional logic Cases are tested in order
![Page 14: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/14.jpg)
Scala does Custom Matching My favorite Scala example (more in the
handout)// Regexps in Scala define a custom unapply to match on groupsval colonSplit = """(\w+)\:(\w+)""".r
// It's easy to define your own as wellobject IntVal { def unapply(in : String) = try { Some(in.toInt) } catch { case _ => None }}
def parts (in : String) = in match {// Matching allows nested use of extractors (here we want Ints) case colonSplit(IntVal(number), value) if number == 14 => {...} case colonSplit(IntVal(number), value) => {...} case colonSplit(key, value) => {...} case _ => {...}}
![Page 15: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/15.jpg)
Scala has Traits At their most basic, traits are 1-to-1 with Java
interfaces Support concrete implementations of methods Support both concrete and abstract
implementations of vals and vars
trait Named { val version = "1.0.0" val name : String def printName { println(name) }}
![Page 16: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/16.jpg)
Scala Enforces Trait Composition
Traits can restrict which classes and traits they can be mixed into
Traits can also define what “this” means
trait CreepyPerson extends Named { self : Person =>
override def printName { println("Creepy! " + name + ", size = " + this._size) }}
class A extends CreepyPerson {} // Error!
![Page 17: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/17.jpg)
Scala Mixes In Traits Classes can have multiple traits mixed in,
but can still only extend one superclass Disambiguation of method calls is done via
a process called “Linearization”. Basically, right-to-left
trait Messageable { def msg (msg : String) }
trait Emailable extends Messageable {...}
trait SMSable extends Messageable {...}
class iPhone extends SMSable with Emailable {...}
![Page 18: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/18.jpg)
Scala has Native XML
XML literals are part of Scala's syntax Xpath-like expressions and pattern
matching supported for extractionval simpleFragment = <entries> <entry><name>Fred</name></entry> <entry><name>Barney</name></entry> </entries>
(simpleFragment \\ "name").toList.map(_.text)
simpleFragment.child.foreach({ case <entry><name>{name}</name></entry> => println(name); case _ => })
![Page 19: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/19.jpg)
Scala has Native XML, Part 2
Values can be embedded in XML literals via braces.
Interpretation of values is via toString, although scala.xml.{PCData,Unparsed} can do special handling
// <name>Fred&Barney</name>val embedFragment = <name>{ "Fred&Barney" }</name> val noEscapes = // <name>Betty&Wilma</name> <name>{ Unparsed("Betty&Wilma") }</name>
![Page 20: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/20.jpg)
Conclusion
Scala lets you write less boilerplate and concentrate on the logic
Interoperates very well with the existing Java ecosystem
IDE support is still not where it needs to be, but it's functional
Odersky, et. al, are committed to long-term growth and stability
![Page 21: Stepping Up : A Brief Intro to Scala](https://reader033.vdocuments.site/reader033/viewer/2022052822/554f3bd2b4c905471e8b4a52/html5/thumbnails/21.jpg)
Further Reading
http://www.scala-lang.org/ http://scala.sygneca.com/ Books:
Programming in Scala by Odersky, Venners & Spoon
Beginning Scala by David Pollak Programming Scala by Wampler & Payne (online) Programming Scala by Venkat Subramaniam Steps in Scala by Loverdos & Syropolous The Definitive Guide to Lift (shameless plug)