Gentle Introduction to Scala

A Gentle Introduction
to Scala and FP
1/50

Hi, I'm Anton!
Functional
programmer
Scala enthusiast
Applications engineer
at Rakuten
@a7emenov
Find me on ,
and
Twitter
Telegram Github
2/50

Agenda
Introduce Scala as a language
Give examples of universal FP constructs
Show beneﬁts of those constructs
Compare Scala to other languages
3/50

What is Scala as
a language?
4/50

Scala combines object-
oriented and functional
programming in one
concise, high-level
language.
5/50

What lies at the core of FP?
6/50

Absence of side-effects in
computations
6/50

computations
Function composition
6/50

computations
Immutable data
6/50

computations
Immutable data
Dark magic
6/50

computations
Immutable data
Dark magic
?
6/50

computations
Immutable data
Dark magic
All of it
7/50

Functional programming is a
way of solving problems which
centers around combining
side-effect-free constructs in a
declarative manner
8/50

Declarative vs. imperative
Imperative
for (int i = 1; i 5; i ) {
int temp = i * 2;
if (temp < 6) {
System.out.println(temp);
}
}
Declarative
(1 to 5)
.map(_ * 2)
.ﬁlter(_ < 6)
.foreach(println)
9/50

Deep dive
FP & Scala
Immutability
Pure functions
Referential transparency
Algebraic data types
Pattern matching
Recursion
10/50

Value mutation
Variables
Can be changed anytime
Can be changed from
any place that has a
reference
Exposing private state
requires explicit copying
Immutable values
Can't be changed
Create new values
instead of changing
the old ones
No mutable state
11/50

Value mutation
Variables Immutable values
12/50

Immutable values
Beneﬁts
Reduce concurrency
issues
No shared mutable
state
Easier local reasoning
Drawbacks
Extra memory allocations
13/50

Pure functions
Side-effect freeSide-effect free - everything that a function does can be
observed in its return value:
TotalTotal - return values for every possible input
DeterministicDeterministic - given same inputs, return same
outputs
Locally scopedLocally scoped - no effect on the state outside of the
function's scope
14/50

All calls to a function
can be substituted
with its return value
15/50

Not transparent
def getInt(l: Int, r: Int): Int =
Random.between(l, r)
def increment(x: Int): Int = {
val res = x + 1
destroyTheWorld()
res
}
Transparent
def fact(n: Int): Int = {
var res = 1
var i = 1
while (i n) {
res = res * i
i = i + 1
}
res
}
16/50

Business value with pure functions
How can programs be
useful without any
side-effects?
17/50

Describe side-effecting computations
instead of instantly running them
Combine all side-effects to produce a
single description
Run the resulting computation in the
main method
18/50

def saveValue(key: String, value: Int): IO[Unit] = ?
def getValue(key: String): IO[Option[Int]] = ???
def rateLimit[A](program: IO[A]): IO[A] = ???
val program: IO[Option[Int]] =
ratelimit(
saveValue("key", 1) >> getValue("key")
)
val result: Option[Int] = program.runSyncUnsafe()
19/50

def saveValue(key: String, value: Int): IO[Unit] = ???
ratelimit(
)
19/50

ratelimit(
)
19/50

Pure functions
Beneﬁts
Ultimate local
reasoning
Parallelizable
execution
Easy testing
Drawbacks
Extra object allocations
Require an effect system
or a library to operate
mutable state
20/50

Product typesProduct types - define how to create a value
(“has a field” relationship)
Sum typesSum types - define the range of values
(“is one of” relationship)
Product types + Sum types =
21/50

Product types
Traditional classes
public class Person {
// Which is the primary constructor?
// Are the constructors related?
public Person(Age age,
Year birthYear)
{ /* ... */ }
public Person(Year currentYear,
Age age)
{ /* ... */ }
Year birthYear)
{ /* ... */ }
}
22/50

Product types
Traditional classes
public class Person {
// Which is the primary constructor?
// Are the constructors related?
public Person(Age age,
Year birthYear)
{ /* ... */ }
Age age)
{ /* ... */ }
Year birthYear)
{ /* ... */ }
}
Product types
// Primary constructor deﬁnes the product
case class Person(age: Age,
birthYear: Year) {
// Supplementary constructors
// must use the primary constructor
def this(currentYear: Year, age: Age)
{ this(age, currentYear - age) }
def this(currentYear: Year, birthYear: Year
{ this(currentYear - birthYear, birthYear
}
22/50

Sum types
Traditional interfaces
public interface User
{ /* Common methods */ }
public class Client implements User
{ /* Client-speciﬁc methods */ }
public class Admin implements User
{ /* Admin-speciﬁc methods */ }
void process(User user) {
// How can this function reason about a
// possible implementations of User?
}
23/50

Sum types
Traditional interfaces
public interface User
public class Client implements User
public class Admin implements User
void process(User user) {
// How can this function reason about a
// possible implementations of User?
}
Sum types
// "Sealed" allows the compiler to ﬁnd
// all descendants of User
sealed trait User
case class Client extends User
case class Admin extends User
def process(user: User): IO[Unit] = {
// The function now has knowledge that
// there are only 2 options for "user"
}
23/50

Pattern matching
Data construction
sealed trait User
case class Client(email: String
role: String)
extends User
case class Admin(name: String,
scopes: List[String])
extends User
val client: User =
Client("test@email.com", "manager")
val admin: User =
Admin("Jane", List("emails", "orders")
Data deconstruction
def process(u: User): IO[Unit] = u match {
case Client(email, "manager")
logManager(email)
case Admin(name, Nil)
logAdmin(name, "No scopes")
case Admin(name, List("emails"))
logAdmin(name, "Only 'emails' scope")
case Admin(name, scopes)
if scopes.contains("orders")
logAdmin(name, "Has 'orders' scope")
case _
logDefault("Default action")
}
24/50

Pattern matching
Beneﬁts
Compile-time type
checks
Exhaustiveness checks
Enhanced code
readability
Extensible
Drawbacks
Extra memory allocations
25/50

Recursion
Declarative
Native mapping to
many real-world
problems
Can be as efﬁcient as a
loop*
import scala.annotation.tailrec
@tailrec
def foldLeft[R](list: List[Int])
(acc: R)
(f: (R, Int) R): R =
list match {
case Nil
acc
case head :: tail
foldLeft(tail)(f(acc, head))(f)
}
// "12345"
foldLeft(List(1, 2, 3, 4, 5))(acc = "") {
(acc, num) acc + num.toString
}
26/50

FP in Scala - covered points
Immutability
Pure functions
Pattern matching
Recursion over iteration
27/50

Scala
language
features
Higher-kinded types
For-comprehensions
Implicit values
Syntax extension
Macros
28/50

Higher-kinded types
Simple types:Simple types:
Int, String, User
Unary typeUnary type
constructors:constructors:
List[A], Future[A]
Binary typeBinary type
constructors:constructors:
Either[A, B], Tuple[A, B]
Higher-kinded typesHigher-kinded types:
trait Processor[L[_]] {
def run[A](l: L[A]): Unit
}
val listP = new Processor[List] {
def run[A](l: List[A]): Unit =
l.foreach(println)
}
listP.run(List(1, 2, 3))
listP.run(List("a", "b", "c"))
29/50

For comprehensions
def getProfile(userName: String): Option[Profile] = ???
def getComments(profile: Profile): Option[List[Comment]] = ???
def getBonus(profile: Profile): Option[Int] = ???
val updatedComments = for {
profile getUserProfile("Jack")
comments getComments(profile)
bonus getBonus(profile)
} yield comments.take(10)
.map( .increaseRating(bonus))
30/50

For comprehensions
Deﬁne coherent syntax for sequential
composition
Syntactic sugar for every type with map,
ﬂatMap and withFilter methods
Can be used with any type supplying these
methods
Take advantage of pattern matching
31/50

Implicit values
Provide automatic
value forwarding
Resolved at compile-
time
Can be derived from
existing context
case class Foo(id: Int)
object Foo {
implicit val o: Ordering[Foo] =
Ordering.by(_.id)
}
def sortFoo(foos: List[Foo])
(implicit o: Ordering[Foo]) =
foos.sorted(o)
sortFoo(
32/50

Syntax extensions
Allow to create ad-hoc
methods for code
reuse and readability
Can be used for types
imported from other
projects/libraries
implicit class StringSyntax
(s: String) {
def filterDigits: String =
s.filter(_.isDigit)
}
// "123"
"1a2b3c".filterDigits
33/50

Macros
Eliminate boilerplate
code
Provide
implementations in
compile time
Allow to extract code
meta data
import io.circe._
import io.circe.generic.semiauto.
case class Foo(a: Int, b: String)
case class Bar(
id: Option[String], foo: Foo
)
val barDecoder: Decoder[Bar] =
deriveDecoder[Foo].map(foo
Bar(id = None, foo = foo)
)
34/50

Scala language - covered points
Higher-kinded types
For-comprehensions
Implicit values
Syntax extensions
Macros
35/50

Scala in
numbers
Development and
adoption rates
Effect on productivity
Performance
36/50

Scala adoption rates
Maintained intense release
schedule for over 15 years
Development of the
language is supported by the
European government and
enterprise investors[1]
As popular as Kotlin for
backend development[2] and
is 20% more widespread
company-wise[3]
1.
2.
3.
bit.ly/2Xr3bnH
bit.ly/2rPlUgW
api.github.com
stackshare.io/scala
37/50

Scala adoption rates
StackOverﬂow 2019[1] survey claims that
almost 60% of respondents have tried
Scala and are interested in working
with it
Approximately 4% of developers are use
Scala as their main language at work[2]
Source: insights.stackoverﬂow.com/survey/2019
38/50

Scala and productivity
Source: bit.ly/2qombqM
39/50

Scala’s functional programming style
allows writing 2 times less code[1]
Reading Scala code is 2 times faster on
average[1]
Research data[2] shows that Scala
projects need ~30% less bug ﬁxes
1.
2.
bit.ly/37eiWTH
arxiv.org/pdf/1901.10220.pdf
40/50

Scala's performance
Uses JVM as the main
runtime platform
Can be compiled to a native
binary
Up to 35% performance
increase with GraalVM[1]
Utilizes incremental
compilation for only a few
seconds delay per build
1.
2.
graalvm.org/scala
bit.ly/330Ugue
41/50

Scala is a rapidly developed
language used and supported
by many, that can offer
substantial productivity
beneﬁts while keeping
reasonable performance
42/50

Scala in real
world
Areas of application
Scala vs. Java & Kotlin
Scala vs. Python
Scala vs. Golang
Future prospects
43/50

Areas of application
ML pipelines
Resilient applications
Distributed systems
Small or simple systems
Low-level manipulation
UI-centered applications
44/50

Scala vs. Java & Kotlin
Java & Kotlin
Vast amount of libraries
for different needs
Reasonable performance
for most programming
tasks
Object-oriented
approach
JVM as runtime platform
Scala
Fully compatible with Java
and Kotlin libraries
Performance competitive
with Java/Kotlin
Allows for both FP and OOP
Target JVM, browser and
native environments
45/50

Scala vs. Python
Python
Ad-hoc Spark & Hadoop
integration
Easy to prototype ideas
Great number of math
and visualisation libraries
Relatively slow on big
volumes on data
Scala
Native Spark & Hadoop
integration
Compile-time veriﬁcation
Mainly ML-oriented libraries
Performs well on terabytes
of data
46/50

Scala vs. Golang
Golang
Fixed imperative style
Blazing fast speed
Concurrency primitives
on the language level
Scala
Extensible declarative style
Reasonable performance
Libraries for scalability
47/50

Future prospects
Next major version of Scala is
coming at the end of 2020.
Take a look at:
dotty.epﬂ.ch
48/50

Thank you for
your
attention!
Any
questions?
@a7emenov
Find me on ,
and
Twitter
Telegram Github
50/50

Gentle Introduction to Scala

More Related Content

What's hot (20)

Similar to Gentle Introduction to Scala (20)

More from Fangda Wang (11)

Recently uploaded (20)

Gentle Introduction to Scala