Why Scala is the better Java

Why Scala is the better Java
Thomas Kaiser
Technologieplauscherl
14.01.2016

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

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

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

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

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

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

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

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)

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

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

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

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

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)

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})"
}

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

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
}

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 :(“
}

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

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

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

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

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

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)

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

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“

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)

Why Scala is the better Java

More Related Content

What's hot (17)

Viewers also liked (14)

Similar to Why Scala is the better Java (20)

Recently uploaded (20)

Why Scala is the better Java

Editor's Notes