Scala offers benefits from adopting it such as increased productivity through concise and expressive code, static typing with type inference, support for both object-oriented and functional programming paradigms, and interoperability with Java. Switching from Java to Scala involves some changes like using val for immutable variables and var for mutable, but overall the syntax is quite similar which eases the transition.

1. (How) Can we benefit
from
adopting
Scala
?
Tomasz Wróbel, 2011-01-24

2. in other words what Scala has to offer

3. Few quick facts
• Strong typing
• Static typing
• Can be both interpreted and compiled into
bytecode and run on top of a JVM (among
others)
• Interoperability with Java
• No primitive types – everything is an object

4. Productivity gain
• Concise, expressive → achieve more with less
• Reduced boilerplate code – semicolons, dots,
parentheses, return – these are often optional
(depending on the context)
• Extensive type inference
• ½ LOC at least
• Code is read more frequently than written

5. Support for both functional and
object-oriented programming paradigms
• Code blocks (anonymous functions)
• Higher-order functions (ones that produce or
consume functions)
• Closures
• Sophisticated collection library

6. REPL
Read-Evaluate-Print Loop
scala> val s = "Hello!"
s: java.lang.String = Hello!
scala> println(s)
Hello!

7. REPL
:help print this help message
:load <arg> load and interpret a Scala file
:sh <line> fork a shell and run a command
scala> :sh ls
stdout: List[String] = List(Desktop, Documents,
Downloads, Library, Movies, Music, Pictures, Public,
Sites)

8. How difficult is it to switch?
Java → Scala
// class
public class A {} class A {}
// variable
private int i = 0; private var i: Int = 0;
// function
public String fun(String s) { def fun(s: String): String = {
return s; return s;
} }

9. Variables
• everything is either val or var
• val – immutable
• var – mutable
val x: Int = 1; x = x + 1
var y = 1; y = y + 1
val set = new java.util.HashSet[String]
set.add("abc")

10. Type inference
val i: Int = 1
def upper(s: String): String = s.toUpperCase
val list: List[Int] = List[Int](1,2,3)
note: there are situations where type is required, e.g. recursive methods

11. operators = functions
• 1 + 2 is actually (1).+(2)
• operators overloading
• possibility to define new data types

12. Euro
case class Euro(euros: Int, cents: Int = 0) {
def +(e: Euro) = Euro(
euros + e.euros + ((cents + e.cents) / 100),
(cents + e.cents) % 100
)
}
case class Cent(cents: Int)
assertThat(Euro(5) + Euro(5), is(Euro(10)))
assertThat(Euro(4) + Cent(99), is(Euro(4, 99)))

13. Ranges
val oneToTen = 1 to 10
assertThat(oneToTen.size, is(10))
val evenNumbers = 2 to 10 by 2
assertThat(evenNumbers.size, is(5))
val alphabet = 'a' to 'z'
assertThat(alphabet.size, is(26))

14. Tuples
are typed
scala> val tuple = ("CODE", 31)
tuple: (java.lang.String, Int) = (CODE,31)

15. Tuples
are convenient way to return multiple values from
a function
def analyzeString(s: String): (String, Int) = {
(s.toUpperCase, s.length)
}
scala> val result = analyzeString("abc")
result: (String, Int) = (ABC,3)

16. Controlling executions
for (i <- 0 to 9) {
print(i)
}
for (i <- 0 to 9) {
if (i % 2 == 0) println("even: " + i) else
println("odd: " + i)
}

17. Controlling executions
var i = 0
while (i < 10) {
print(i)
i += 1
}

18. Raw strings
// given
val s = """|first line
|second "B" line
|third line""".stripMargin
// then
assertThat(s, is("first linensecond "B" linenthird
line"))

19. Raw strings
assertThat("1234".matches("""d*"""), is(true))
assertThat("12ab".matches("""d*"""), is(false))
new File("""c:somepathtofile.txt""").exists

20. Making assertions
@Test(expected = classOf[IllegalArgumentException])
def convenientAssertions {
val i = -1
require(i > 0)
}

21. Objects equality
• == is Java's equals()
• eq()is Java's ==

22. Imports
import java.util.Date
import java.text.{DateFormat, SimpleDateFormat}
import java.math._
// static imports
import java.util.Arrays.asList
import java.util.Collections._
// aliasing
import java.sql.{Date => SqlDate}

23. Tail recursion
compiler optimizes tail-recursive functions to
loops → preventing stack overflow errors
@tailrec
final def fact(n: Int, acc: Long = 1): Long = {
if (n < 1) acc else fact(n - 1, n * acc)
}
@tailrec – optional, compiler hints you if on not tail-recursive function

24. There is always an Option
i.e. null alternative
scala> def map = Map("PL" -> "Poland")
scala> val country: Option[String] = map.get("PL")
country: Option[String] = Some(Poland)
scala> val res = country.get
res: String = Poland
scala> val res = country.getOrElse("default")
res: String = Poland
scala> val country: Option[String] = map.get("UK")
country: Option[String] = None
scala> val res = country.getOrElse("default")
res: String = default
scala> val res = country.get
java.util.NoSuchElementException: None.get

25. Implicits
Allow to add functionality to existing classes
val past = 2 days ago // 2.days(ago)
val future = 5 days later // 5.days(later)
println(new java.util.Date)
println(past)
println(future)
Sun Jan 23 22:18:51 GMT 2011
Fri Jan 21 22:18:51 GMT 2011
Fri Jan 28 22:18:51 GMT 2011

26. class, object, trait
• class – holds instance methods and fields
• object – companion object – singleton
object, holds class (static) methods
• trait – partial class implementation or
interface with implementation, it is possible to
mixin multiple traits

27. class and object
class Article private(title: String)
object Article {
def newInstance(title: String) = new Article(title)
}
object App {
def main(args: Array[String]) {
val article = Article.newInstance("a Title")
}
}

28. Traits
trait SingleJournalRelease extends PressRelease {
override def validate = println("articles form the same journal")
}
trait IssueRelease extends PressRelease {
override def header = print("Issue Press Release containing ")
}
trait AopRelease extends PressRelease {
override def header = print("AOP Press Release containing ")
}
class AcademicJournalAopPressRelease extends AopRelease with
SingleJournalRelease
class ResearchJournalIssuePressRelease extends IssueRelease with
SingleJournalRelease

29. Anonymous functions
val list = List(1, 2, 3)
val odds = list.filter((each: Int) => each % 2 != 0)
assertThat(odds, is(List(1, 3)))

30. Functions
Functions can be assigned to variables and be
passed as parameters
val complicatedProcessing = (s: String) =>
s.toUpperCase
assertThat(complicatedProcessing("abc"), is("ABC"))
val list = List("a", "b", "c")
val result = list.map(complicatedProcessing)
assertThat(result, is(List("A", "B", "C")))

31. Local functions
Functions can be nested
def outer {
def inner(s: String) = println("inner " + s)
inner("outer")
}

32. Passing parameters to functions
scala> def fun(s: String) = println(s)
fun: (s: String)Unit
scala> fun("abc")
abc
scala> fun{"abc"}
abc

33. Curried functions
Currying = turning a function that takes two arguments
into a chain of functions that take one argument
def sum(x: Int, y: Int) = x + y
def multiple(x: Int)(y: Int) = x * y
scala> val result = sum(1, 2)
result: Int = 3
scala> val result = multiple(1)(2)
result: Int = 2

34. Adding new control structures
writeToFile("output.txt") {
writer => writer.println("abc")
}
def writeToFile(fileName: String)(block : PrintWriter
=> Unit) = {
val writer = new PrintWriter(new File(fileName))
try { block(writer) } finally writer.close()
}

35. Implementing unless
scala> def unless(cond: => Boolean)(body: => Unit): Unit =
| if (!cond) {
| body
| }
unless: (cond: => Boolean)(body: => Unit)Unit
scala> unless(1 > 2) {
| print("1 is not greater than 2")
| }
1 is not greater than 2

36. Closures
// given
val base = 100
def closeAroundBase(i: Int) = {
i + base
}
// then
assertThat(closeAroundBase(10), is(110))

37. Why is closure useful?
val patternProvidedByUser = "L.*"
val data = List("London", "Oxford", "Leeds")
val result =
data.filter(_.matches(patternProvidedByUser))
result: List[java.lang.String] = List(London, Leeds)

38. Case classes
case class Article(var doi: String, var title: String)
// Provide convenient factory method
val article = Article("10.1038/nature01234", "a Title")
// and implementations for
assertThat("toString", article.toString,
is("Article(10.1038/nature01234,a Title)"))
assertThat("hashCode", article.hashCode,
equalTo( equalArticle.hashCode ))
assertTrue("equals", article == equalArticle)

39. Pattern matching
• match as switch on steroids
• always results in a value
• no “fall through”
• MatchError thrown if no match
• _ is default

40. Matching by constant
def fun(o: Any): Int = o match {
case "abc" => 1
case 1 => 2
case Nil => 0
}

41. Matching by type
(no more instanceof and casting)
def size(o: Any): Int = o match {
case s: String => s.length
case l: List[_] => l.size
case _ => -1
}
assertThat(size("abc"), is(3))
assertThat(size(List(1, 2)), is(2))

42. Matching by tuple
def fun(o: Any): Any = o match {
case (a: Int, b: Int) => a + b
}

43. Matching by constructor
case class Rectangle(a: Int, b: Int)
def identify(r: Rectangle): String = r match {
case Rectangle(2, 4) => "2x4"
case Rectangle(a, b) if a == b => "Square" // pattern guard
case Rectangle(a, b) => "Rectangle " + a + "x" + b
}
assertThat(identify(Rectangle(2, 4)), is("2x4"))
assertThat(identify(Rectangle(1, 1)), is("Square"))
assertThat(identify(Rectangle(1, 2)), is("Rectangle 1x2"))

44. (optional) Exception handling
try {
val f = new FileInputStream("file.txt")
} catch {
case e: IOException => // handle the exception
}
but can be also just:
val f = new FileInputStream("file.txt")

45. Named and default parameters
case class Article(id: Int, doi: String, title:
String)
def make(id: Int = 1, doi: String = "a Doi", title:
String = "a Title") = {
Article(id, doi, title)
}

46. Named and default parameters
Defaulting omitted parameter(s)
val article = make(99, "10.1038/nature01234")
assertThat(article.id, is(99))
assertThat(article.doi, is("10.1038/nature01234"))
assertThat(article.title, is("a Title"))

47. Named and default parameters
Setting parameter by name
val article = make(doi = "10.1038/nature01234")
assertThat(article.id, is(1)) // default
assertThat(article.doi, is("10.1038/nature01234"))
assertThat(article.title, is("a Title")) // default

48. Collections
Easy construction
val aList = List(1, 2, 3)
val aMap = Map("A" -> 1, "B" -> 2, "C" -> 3)
val aSet = Set("a", "b", "c", "b", "a")
scala> val list = List(1) ::: List(2) // concatenate
list: List[Int] = List(1, 2)
scala> val list = List(1) ++ List(2) // concatenate
list: List[Int] = List(1, 2)
scala> val list = 1 :: List(2) // add element (as a first one)
list: List[Int] = List(1, 2)

49. Collections
Iterable - a base trait for iterable collections with ~100 functions
scala> val numbers = List(1, 2, 3, 4, 5)
scala> val negatives = numbers.map(e => -e)
negatives: List[Int] = List(-1, -2, -3, -4, -5)
scala> val even = numbers.filter(n => n % 2 == 0)
even: List[Int] = List(2, 4)
scala> val (even, odd) = numbers.partition(_ % 2 == 0)
even: List[Int] = List(2, 4)
odd: List[Int] = List(1, 3, 5)

50. Collections
scala> val result = numbers.mkString(", ")
result: String = 1, 2, 3, 4, 5
scala> val result = numbers.count(_ > 2)
result: Int = 3
scala> numbers.foreach(print _)
12345

51. Collections
Example for groupBy
scala> case class Article(journal: String, doi: String)
scala> val articles = List(
Article("NATURE", "nature09733"), Article("NMAT", "nmat2937"),
Article("NMAT", "nmat1807"), Article("NPHYS", "nphys1906"))
scala> val result = articles.groupBy(e => e.journal)
scala> val nmat = result("NMAT")
nmat: List[Article] = List(Article(NMAT,nmat2937), Article(NMAT,nmat1807))
scala> val nature = result("NATURE")
nature: List[Article] = List(Article(NATURE,nature09733))
scala> val nphys = result("NPHYS")
nphys: List[Article] = List(Article(NPHYS,nphys1906))

52. XML literals and XPath-like processing
// given
val xml = <article id="1">
<doi>10.1038/nature01234</doi>
<title>A Title</title>
</article>
// then
assertThat(xml "@id" text, is("1"))
assertThat(xml "doi" text, is("10.1038/nature01234"))

53. Evaluating Scala code in XML literal
// given
val tstamp = System.currentTimeMillis
val xml = <timestamp>{tstamp}</timestamp>
// then
xml = <timestamp>1295726256063</timestamp>

54. Loading XML
// given
val xml = XML.loadString("<code>ABC</code>")
// then
assertThat(xml, is(<code>ABC</code>))

55. Pattern matching on XML
val xml = <info>
<message>a message</message>
</info>
val result = xml match {
case <info>{_*}</info> => logInfo(xml)
case <error>{_*}</error> => logError(xml)
}

56. Concurrency – Actor model
• Asynchronous message passing between
actors
• Messages are immutable
• Synchronized mailbox
• Mailbox is read with pattern matching
• No shared state + No locks = Safe concurrency
• Actors are lightweight → millions of them on
regular box

57. Type parameterization
class A
class B extends A
class C extends B
def upperBound[T <: B](o: T) {}
upperBound(new A)
upperBound(new B)
upperBound(new C)

58. Type parameterization
def getSize[T <: { def size: Int }](o: T): Int = {
o.size
}
getSize(List(1, 2, 3))
getSize(new StringBuilder("abc"))
getSize("abc") // String has length() not size()

59. Automatic Resource Management
use of type parameterization and closure
def using[T <: {def close()}](resource: T)(block: T => Unit) = {
try {
block(resource)
} finally {
if (resource != null) {
try resource.close
catch {
case e: Exception =>
}
}
}
}

60. Automatic Resource Management
using(stream) { // where stream is InputStream
res => { val data = res.read }
}
using(resultSet) { // where resultSet is ResultSet
res => {
val data = if (res.next) res.getString("column")
else ""
}
}

61. ScalaTest BDD testing DSL
class StackSpec extends Spec with ShouldMatchers {
describe("A Stack") {
describe("(when empty)") {
val stack = new Stack[Int]
it("should be empty") {
stack should be ('empty)
}
it("should complain when popped") {
evaluating { stack.pop() } should produce [NoSuchElementException]
}
}
}
}

62. Tooling
• Plugins for Eclipse, NetBeans and IDEA
• Support for (some) refactorings, debugging,
code completion, hints, syntax highlighting,
navigation
• maven support (also mix Java/Scala projects)
• sbt – simple build tool

63. Benefits
• Productivity
• Functional aspects
• XML
• DSL
• Concurrency

64. Quirks (functions)
Way functions are declared determines how they can be used
def foo = 1
def bar() = 2
foo
foo()
bar
bar()

65. Warning!
There is a danger that once you start
programming in Scala you may not want to
program in Java anymore!

66. Resources
Scala - http://www.scala-lang.org/
A Tour of Scala - http://www.scala-lang.org/node/104
Scala API - http://www.scala-lang.org/api/current/index.html
New features of Scala 2.8 - http://escalatesoft.com/screencasts
Scala for Java Refugees
http://www.codecommit.com/blog/scala/roundup-scala-for-java-refugees
AlBlue’s Blog - http://alblue.bandlem.com/search/label/scala
Scala Style Guide (good to learn about some Scala quirks) -
http://davetron5000.github.com/scala-style/
Scaling Web Apps with Akka -
http://maciejmatyjas.com/2010/07/scaling-web-apps-with-akka/

67. Resources
Programming in Scala - http://www.artima.com/shop/programming_in_scala
Programming Scala - http://programming-scala.labs.oreilly.com/
Seven Languages in Seven Weeks (chapter, comparison with Java and Ruby)
http://pragprog.com/titles/btlang/seven-languages-in-seven-weeks
Programming Scala - http://pragprog.com/titles/vsscala/programming-scala

68. Scala in London
London Scala User Group
http://www.meetup.com/london-scala/
regular meetups – recorded and available at
http://skillsmatter.com/go/scala
LSUG Scala Dojo

69. Thanks!
http://tomaszwrobel.com
@twr_wrtp