Talk am Technologieplauscherl 33, 14.01.2016

1. Why Scala is the better Java
Thomas Kaiser
Technologieplauscherl
14.01.2016

2. Agenda
• Why this talk
• Cool language features
• Pitfalls and how to avoid them
• Resources

3. Quick survey
• Who...
• ... Writes Java code for production?
• ... Has ever written any Scala code?
• ... Has ever written Scala for production?
• Me
• Java background (Spring, Hibernate, Grails, GWT, Android)
• Scala webapp w/ Postgres, Mongo, Play, Angular, REST

4. What is Scala
• JVM based functional/OO language
• Powerful type system
• Traits/mixins
• Higher-order functions
• Pattern matching
• Concurrency abstractions

5. Why this talk
• People are interested in Scala, but also afraid?
• Scala is extremely powerful and flexible
• Syntax
• Huge library
• Lots of ways to do the same thing
• Very intimidating type system
• BUT! You don‘t have to use any of the advanced features and still
benefit massively

6. Why Scala
• Extremely expressive (LOC--)
• Static typing
• Very clean style comes built-in
• Awesome (awesome) library (collections etc)
• Writing Scala code is actually fun!

7. Language features (why I love Scala)
• Tuples
• String concatenation
• Local functions
• Import aliases
• Super-easy collection/map creation
• Powerful collections library
• Traits
• Case classes
• Pattern matching
• Function values/function literals
• Multiple parameter lists
• Option[T]
• For-Comprehensions
• Everything is a value
• Syntax flexibility
• Type inference
• JSON/XML handling
• Scalatest/specs2
• Implicit conversions
• Annymous/structural types, type aliases
• Algebraic data types

8. S vs. J: Boilerplate
public class User {
private String name;
private List<Order> orders;
public User() {
orders = new ArrayList<Order>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Order> getOrders() {
return orders;
}
public void setOrders(List<Order>
orders) {
this.orders = orders;
}
}
public class Order {
private int id;
private List<Product> products;
public Order() {
products = new ArrayList<Product>();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<Product> getProducts() {
return products;
}
public void setProducts(List<Product>
products) {
this.products = products;
}
}
public class Product {
private int id;
private String category;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCategory() {
return category;
}
public void setCategory(String
category) {
this.category = category;
}
}

9. S vs. J: Boilerplate
case class User(name: String, orders: List[Order])
case class Order(id: Int, products: List[Product])
case class Product(id: Int, category: String)

10. S vs. J: Standard use case – extract data
• Get products of a User
public class User {
...
public List<Product> getProducts() {
List<Product> products = new ArrayList<Product>();
for (Order order : orders) {
products.addAll(order.getProducts());
}
return products;
}
}

11. S vs. J: Standard use case – extract data
• Get ordered products of a User
def products = orders.flatMap(o => o.products)

12. S vs. J: Remove x highest values
public static List<Integer> removeHighestValuesJ6(
List<Integer> values, int amount) {
List<Integer> localValues = new ArrayList<>(values);
Collections.sort(localValues);
int toIndex = localValues.size() - amount;
if (toIndex < 0) {
toIndex = 0;
}
return localValues.subList(0, toIndex);
}
public static List<Integer> removeHighestValuesJ8(
List<Integer> values, int amount) {
Collections.sort(values); // in-place! boo!
Collections.reverse(values); // in-place!
List<Integer> result = values.stream()
.skip(amount)
.collect(Collectors.toList());
return result;
}

13. S vs. J: Remove x highest values
def removeHighestValues(list: List[Int], amount: Int) = {
list.sorted.reverse.drop(amount)
}

14. For comprehensions each++
for (i <- 1 to 7) print(i) // 1234567
for (i <- 1 to 7 if i % 2 == 0) print(i) // 246
case class Person(age: Int)
val persons =
for (i <- 20 to 35 by 5) yield Person(i)
// Person(20), Person(25), Person(30), Person(35)

15. Pattern matching
case class Person(name: String, age: Int)
val p1 = Person("thomas", 29)
val p2 = Person("dominik", 32)
p2 match {
case Person("thomas", 29) => "exactly that person"
case Person(_, age) if age > 30 => "anyone over 30"
case p : Person => s"just binding to a variable (${p.name})"
}

16. Pattern matching
val list = List(1, 2, 3)
list match {
case 1 :: 2 :: rest => "list starts with 1,2 and has " + rest.length + " more"
}

17. Everything is a value
val bool = true
val yepNope = if (bool) "yep" else "nope"
case class AuthUser(email: String, roles: Set[String])
val currentUser = AuthUser(”user", Set("ADMIN"))
val isAuthorized = currentUser match {
case AuthUser(_, roles) if roles.contains("ADMIN") => true
case _ => false
}

18. Everything is a value
def russianRoulette() =
if (Random.nextInt(6) == 0)
throw new RuntimeException(“bang“)
else
"phew“
val dangerousResult: String =
try {
russianRoulette()
} catch {
case RuntimeException => "dead :(“
}

19. Implicit conversions
val hello: String = "hello"
hello.emphasize // Error:(32, 8) value emphasize is not a member of String
„Pimp my library pattern“
implicit class PimpedString(base: String) {
def emphasize = base + "!!!11"
}
import PimpedString
val pimpedString = hello.emphasize // hello!!!11

20. Implicit conversions
for (i <- 1 to 7) <=> 1.to(7) <=> val r: Range = new RichInt(1).to(7)

21. DSLs
class HelloWorldSpec extends Specification {
"Hello world" should {
val hw = "Hello world"
“be 11 chars long" in {
hw should have size 11
}
"start with hello" in {
hw should startWith "hello“
}
}
}

22. DSLs
"show off some mocking DSL" in {
val m = mock[List[String]]
m.get(0) returns “0"
// .. code under test ...
there was one(m).get(0)
}

23. DSLs
val messageFlow =
filter { payload: String => payload == "World" }
-->
transform { payload: String => "Hello " + payload }
-->
handle { payload: String => println(payload) }
messageFlow.send("World") // "Hello World"

24. Implicit conversions
for (i <- 1 to 7) <=> 1.to(7) <=> val r: Range = new RichInt(1).to(7)
Map(1 -> "one") <=> 1.->("one") <=> val entry : (Int, String) = new ArrowAssoc[Int](1).->("one”)
val x = Future { ... }
Await.result(x, 5 seconds) <=> new DurationInt(5)

25. Pitfalls
• Implicits can be confusing
• Many different codestyles in the wild
• Hard to understand libraries
• Yet another build tool (SBT)

26. Take away
• Just do it!
• You can always go back or mix Java and Scala code
• ... But you won‘t
• Be wary of advanced language features
• Don‘t be scared, you don‘t have to use anything
• Use it as a very expressive, fun, supercharged Java
• ... And you won‘t look back
• „Scalable language“

27. Resources
• http://scala-lang.org/
• http://docs.scala-lang.org/cheatsheets/
• List of links (!!)
• Learning functional programming without growing a neckbeard
• https://github.com/pocorall/scaloid (Scala4Android, super cool)