The need for functional programming languages is more important than ever with the current hardware and software trends. Scala has become the number one choice for functional programming languages and is becoming the language of choice for many development teams. But with the introduction of functional programming in Java 8 is Scala still relevant and needed?

1. IN A JAVA 8 WORLD

3. FUNCTIONAL

5. OBJECT ORIENTED

6. JVM
BASED

7. WHY CHOOSE SCALA?

8. SCALA IS
SCALABL
E

9. All logos owned by respective companies.

10. Developers should start
thinking about tens, hundreds,
and thousands of cores now.”
- Intel

11. SCALABIT
Y IS
HARD

13. SIDE EFFECTS
public void setX(int x) {
this.x = x;
}
setX(0)
async { setX(getX() + 1) }
async { setX(getX() * 2) }

14. FUNCTIONAL PROGRAMING

16. PURE FUNCTIONS
def add1(x: Int) : Int = {
x + 1
}
val result = add1(1) + add1(2) // 5
val result = 2 + 3 // 5

18. FIRST CLASS FUNCTIONS
val hello = (name: String) => println(s"Hello $name”)
hello("Joe”)
Hello Joe

19. HIGH ORDER FUNCTIONS

20. HIGH ORDER FUNCTIONS
def greetings(name: String, f: String => String) = {
println(f(name))
}
val hello = (name: String) => s"Hello $name”
val hola = (name: String) => s"Hola $name”
greetings("Joe", hello)
Hello Joe
greetings("Joe", hola)
Hola Joe

21. ISN’T JAVA8
ENOUGH?

22. JAVA8 CAN
BE MADE
SCALABLE

23. IMMUTABLE CLASSES
public class ImmutablePoint {
private final int x;
private final int y;
public ImmutablePoint(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() { return x; }
public int getY() { return y; }
}
Java
Scala case class ImmutablePoint(x: Int, y: Int)

24. IMMUTABLE DATA STRUCTURES
Scala
List(1, 2)
Set(1, 2)
Map(("foo", 1), ("bar", 2))
List<Integer> uList = Arrays.asList(1, 2, 3);
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
Set<Integer> uSet = Collections.unmodifiableSet(set);
Map<String, Integer> map = new HashMap<>();
map.put("foo", 1);
map.put(”bar", 2);
Map<String, Integer> uMap = Collections.unmodifiableMap(map);
Java

25. SCALA IS EXPRESSIVE

27. TRAITS
trait WheelBarrow {
val capacity: Int = 20
def lift() = println("I need to go to the gym")
def roll() = println("Are we there yet")
def dump() = println("Go back for more")
}
trait Bench {
val occupancy: Int = 3
val color: String = "Red”
def sit() = println("Time to rest")
}
class BenchBarrow extends WheelBarrow with Bench

28. NAMED PARAMETERS
public class Person {
private String lastName = "Unknown";
private String firstName = "Unknown";
private String middleName = "Unknown";
private String salutation = "Unknown";
private String suffix = "Unknown";
public Person(String lastName, String firstName, String middleName,
String salutation, String suffix) {
this.lastName = lastName;
this.firstName = firstName;
this.middleName = middleName;
this.salutation = salutation;
this.suffix = suffix;
}
}

29. NAMED PARAMETERS
public class Person {
private final String lastName;
private final String firstName;
private final String middleName;
private final String salutation;
private final String suffix;
private Person(String lastName, String firstName, String middleName,
String salutation, String suffix) {
this.lastName = lastName;
this.firstName = firstName;
this.middleName = middleName;
this.salutation = salutation;
this.suffix = suffix;
}
public static class PersonBuilder {
private String lastName = "Unknown";
private String firstName = "Unknown";
private String middleName = "Unknown";
private String salutation = "Unknown";
private String suffix = "Unknown";
public PersonBuilder lastName(String newLastName) {
this.lastName = newLastName;
return this;
}
public PersonBuilder firstName(String newFirstName) {
this.firstName = newFirstName;
return this;
}
public PersonBuilder middleName(String newMiddleName) {
this.middleName = newMiddleName;
return this;
}
public PersonBuilder salutation(String newSalutation) {
this.salutation = newSalutation;
return this;
}
public PersonBuilder suffix(String newSuffix) {
this.suffix = newSuffix;
return this;
}
public Person build() {return new Person(lastName, firstName, middleName, salutation, suffix); }
}
}

30. NAMED PARAMETERS
case class Person(salutation: String = "Unknown", firstName: String = "Unknown",
middleName: String = "Unknown", lastName: String = "Unknown",
suffix: String = "Unknown")
Person("Mr", "John", "M", "Doe", "Sr")
Person(salutation = "Mr", firstName = "John", lastName = "Doe")
Person(firstName = "John", middleName = "M", lastName = "Doe")
Person(firstName = "John")
Person(lastName = "Doe")
Person(firstName = "John", lastName = "Doe")

31. PATTERN MATCHING
def parseArgument(arg: String, value: String)

32. PATTERN MATCHING
def parseArgument(arg: String, value: String) = (arg, value) match {
}

33. PATTERN MATCHING
def parseArgument(arg: String, value: String) = (arg, value) match {
case ("-h" | "--help", nil) => displayHelp()
}

34. PATTERN MATCHING
def parseArgument(arg: String, value: String) = (arg, value) match {
case ("-h" | "--help", nil) => displayHelp()
case ("-l" | "--log-level", level) => setLogLevel(level)
}

35. PATTERN MATCHING
def parseArgument(arg: String, value: String) = (arg, value) match {
case ("-h" | "--help", nil) => displayHelp()
case ("-l" | "--log-level", level) => setLogLevel(level)
case (bad, _) => badArgument(bad)
}

36. PATTERNS
// Constant patterns
case 0 => "zero”
case true => "true"
case "hello" => "you said hello”
// Data structure patterns
case List(0, _, _) => "a three-element list with 0 as the first element”
case List(1, _*) => "a list beginning with 1, having any number of elements”
// Constructor patterns
case Person(_,_,_,"Smith",_) => "found a Smith”
case Person(_,first,middle,"Smith",_) => s"found $first $middle Smith”

37. SCALA IS EXPRESSIVE

39. GETTING STARTED
• Functional Programming Principles in Scala
– coursera.com
• Introduction to Scala
– bigdatauniversity.com
• Scala Cookbook by Alvin Alexander
• Programming Scala by Dean Wampler & Alex Payne

40. QUESTIONS?