Intro to Functional Programming

Introduction to
Functional
Programming

hello!
Jordan Parmer
@ProfParmer

What is Functional
Programming?

“We are builders first;
technologists second

“The better builders we are, the
more value we provide.

1.
What is Functional
Programming?

What Does It Mean to be Imperative?

What Are The Most
Common Problems In
Imperative OOP Code?

Null Pointer Exceptions
Concurrency Errors With Shared State
Broad Context of Reasoning
Deep Inheritance Chains
Mutable State

What is the emphasis
with imperative OOP
code?

Inheritance over composition
Abstraction by Inheritance
Internal class state and encapsulation
Imperative state mutations

“A functional programming language is
a language that emphasises
programming with pure functions and
immutable data

Functional Programming
Declarative
Describe what, not how
Expressions over statements
Idempotent
Immutability
Functions are without side-effects
Results deterministic
Referentially Transparent
Any expression can be replaced with
the results of its value
Algebraic
Types, equality, expressions
Category theory
Functionally Composable
Separate behavior from data
Small functions composed together
to make small building blocks
Parallelizable
Idempotent code by nature enables
local and distributed parallelization

Myths
✘Requires a math degree to understand
✘Targets only math/science problems
✘Only relevant in academic circles
✘Not for “Line of Business” or “Form Over Data” apps

Shocking Adjustments
✘No Null
✘Recursion over looping
✘Avoidance of if-statements
✘Map/filter/fold over iterating
✘Monadic I/O
✘Lots of foreign mathematical nomenclature
✘No debuggers

“OOP makes code understandable by
encapsulating moving parts.
FP makes code understandable by
minimizing moving parts.
✘Michael Feathers

You Don’t Need a
Functional Language To
Be Functional

Some [Subjective] Examples
Pure-ish
✘ Haskell
✘ Erlang
✘ Elm
✘ Hope
✘ Joy
✘ Mercury
✘ Scheme
Hybrids
✘ Scala
✘ F#
✘ Kotlin
✘ Swift
✘ ML
✘ LISP
✘ Rust
✘ Groovy
✘ R
✘ Dart
✘ Ruby
Progressively Incorporating
✘ Java 8
✘ C#
✘ Python
✘ C++ 11
...and many more

Popular Languages
Beware Bias Ahead

JVM Languages
Scala
✘ Statically strong typed
✘ FP with OOP good parts
✘ Higher-order functions
✘ Insanely advanced type system
✘ Currying, lazy-evaluation, pattern matching, etc.
✘ Large commercial adoption
Twitter, Spotify, LinkedIn, Apache Spark, Kafka, etc.
✘ Backed by Lightbend + Scala Centre
Clojure
✘ Dynamically typed
✘ First-order functions
✘ S-expressions
✘ LISP-dialect
“Modern LISP that is symbiotic with Java”

.NET Languages
F#
✘ Statically typed
✘ Multi-paradigm: FP, imperative, OOP
✘ .NET Framework
✘ Visual Studio Tooling
✘ Backed by Microsoft

Apple Languages
Swift
✘ Scala...brought to you by Apple
I kid! I kid!
✘ FP alternative to Objective C
✘ Borrowed some constructs from C & Objective C
✘ Optional types
✘ Categories (i.e. type-classes)

Erlang Languages
Erlang
✘ Ideal for distributed systems
✘ Fault-tolerant, real-time
✘ Highly-available systems
✘ BEAM virtual machine
Elixir
✘ Higher abstractions on top of Erlang
Reduces boilerplate
✘ Runs on BEAM
✘ New language but closely related to Erlang

Purist Languages
Haskell
✘ Purely functional
✘ Named after Haskell Curry
✘ Strong type system
✘ Introduced type-classes
✘ Strict immutability
Elm
✘ FP for the web
✘ Graphical layout without destructive updates
✘ Interops with (not compiles to) JavaScript/CSS/HTML

Let’s Talk About Some FP
Concepts

The Suspects
Pure Functions
Expressions
Type Systems
Function Chaining
Map, Filter, Fold
Functors, Monoids, Monads

Side-Effects Are The
Source of Many Woes

f(x) = 3x2-7x+5Given the above
Find f(-4)

f(x) = 3x2-7x+5Given the above
Find f(-4)
81

Function Has Side-Effects If It...
✘Modifies a variable
✘Modifies a data structure in place
e.g. append to linked list
✘Throws an exception
✘Prints to the console
✘Writes to a file
✘Updates a database
✘Draws to the screen

Function Has Side-Effects If It...
✘Modifies a variable
✘Modifies a data structure in place
e.g. append to linked list
✘Throws an exception
✘Prints to the console
✘Writes to a file
✘Updates a database
✘Draws to the screen Have you ever passed a
reference of a list to
something else?

Single Input
Single Output
No side effects
Referentially transparent Func
A B
Function Is Pure If It...

Functional Imperative OOP
Pure functions are
easy to test
Local reasoning
In => Out
VS
Objects are hard to
test
Encapsulated state
Context
Global reasoning

Pure functions are
easy to re-use
Low risk
Little-to-no
dependencies
VS
We are terrible at
making truly reusable
objects
Challenges of tight
coupling
Hard to abstract at
correct level

Pure functions are
easy to parallelize
State in isolation
Just lego pieces
VS
Sharing is cool in
life...not in threads
How many
concurrency patterns
do we need to deal
with shared state?

Pure functions reduce
need for most OOP
design patterns
VS
‘Cause who doesn’t
want to know about
your
MVVMVMVMMVCCC
singleton factory
observer adapter
thingy?

Single Input Single Output
Func
A B

Functions Of This Sort Can Be Things
Func
A B

Compose Them Together
Func
Func

Function Composition Is
The New Old Injection

// Goal: Allow brewing coffee with different techniques and beans
// Types
// Beans => Grind
// Grind => Coffee Compose to get: Beans => Coffee
trait Beans
trait Grind
trait Coffee
case class ColumbianBeans() extends Beans
def brew(grind: Beans => Grind)(brew: Grind => Coffee): Beans => Coffee = {
brew compose grind
}
def burrGrind(beans: Beans): Grind = ???
def blendGrind(beans: Beans): Grind = ???
def pourOver(grind: Grind): Coffee = ???
def drip(grind: Grind): Coffee = ???
def frenchPress(grind: Grind): Coffee = ???
val pourOverWithBurrGrind = brew(burrGrind)(pourOver)
val myFavoriteBeans = ColumbianBeans()
val myFavoriteCoffee = pourOverWithBurrGrind(myFavoriteBeans)
// TIME TO WAKE UP!!!

// Goal: Allow brewing coffee with different techniques and beans
// Types
// Beans => Grind
// Grind => Coffee Compose to get: Beans => Coffee
trait Beans
trait Grind
trait Coffee
case class ColumbianBeans() extends Beans
def brew(grind: Beans => Grind)(brew: Grind => Coffee): Beans => Coffee = {
brew compose grind
}
def burrGrind(beans: Beans): Grind = ???
def blendGrind(beans: Beans): Grind = ???
def pourOver(grind: Grind): Coffee = ???
def drip(grind: Grind): Coffee = ???
def frenchPress(grind: Grind): Coffee = ???
val pourOverWithBurrGrind = brew(burrGrind)(pourOver)
val myFavoriteBeans = ColumbianBeans()
val myFavoriteCoffee = pourOverWithBurrGrind(myFavoriteBeans)
// TIME TO WAKE UP!!!
brew is a higher
order function

// Imagine how many combinations we can use this code
// Imagine how easy testing is
object Person {
def drink(coffee: Coffee): AwakePerson = ???
}
def wakeSomeone(makeIt: () => Coffee): AwakePerson = {
Person.drink(makeIt())
}
Anything that
makes coffee

// Which right triangle that has integers for all sides and all sides equal to
// or smaller than 10 has a perimeter of 24?
def rightTriangle: Seq[Int] =
for {
c <- 1 to 10
b <- 1 to c
a <- 1 to b
if ((Math.pow(a,2) + Math.pow(b,2) == Math.pow(c,2)) && (a + b + c == 24))
} yield (a, b, c)
rightTriangle
Answer: [6, 8, 10]
It’s Not About the How
but the What

f(x) = 3/x
1 => 3/1 => 3.0
2 => 3/2 => 1.5
0 => 3/0 => ???

f(x) = 3/x
1 => 3/1 => 3.0
2 => 3/2 => 1.5
0 => 3/0 => ???
AH,
PICKLES!

f(x) = 3/x
1 => 3/1 => 3.0
2 => 3/2 => 1.5
0 => 3/0 => ???
THROW AN
EXCEPTION?

f(x) = 3/x
Int => Double
0 => 3/0 => ???
THROW AN
EXCEPTION?
THEN THIS
IS A LIE!

f(x) = 3/x
Int => Double
0 => 3/0 => ???
THROW AN
EXCEPTION?
THEN THIS
IS A LIE!
Are You A
Liar?

But Functions Are Types!
Types Don’t Have to Be
Open to All
Circumstances

f(x) = 3/x
NonZeroInt => Double
Just Became Constrained And
Self-Documented

f(x) = 3/x
Zero Not
Allowed BY
NonZeroInt
-1 => 3/-1 => -3
1 => 3/1 => 3
2 => 3/2 => 1.5

Static Types Just Became
Enforced Domain
Documentation

Intro to Functional Programming

We Sometimes Refer to
Our Programs as an
“Algebra”

If It Compiles, It
Probably Works

def foo(): Thing = {
val x = DoAThing()
if (x != null) {
val y = DoAnotherThing(x)
if (y != null) {
val z = DoYetAnotherThing(y)
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}

val x = DoAThing()
if (x != null) {
if (y != null) {
val z = DoYetAnotherThing(y)
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Yeah, I know
this is bad.
But you know
you’ve seen
this before.
Hang with me.

val x = DoAThing()
if (x != null) {
if (y != null) {
val z =
DoYetAnotherThing(y)
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Pyramid
of Doom

val x = DoAThing()
if (x != null) {
if (y != null) {
val z =
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Pyramid
of Doom
The Only
Lines Doing
Work
That’s only
20%!

val x = DoAThing()
if (x != null) {
if (y != null) {
val z =
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Pyramid
of Doom
Look at all
those nulls!
Half this code
is null
checking.
Nulls are a
serious code
smell!

val x = DoAThing()
if (x != null) {
if (y != null) {
val z =
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Pyramid
of Doom
Look at all
those nulls!
Half this code
is null
checking.
Nulls are a
serious code
smell!
Null Pointer
Exceptions
Waiting to
Happen

val x = DoAThing()
if (x != null) {
if (y != null) {
val z =
if (z != null) {
return z
} else {
return null
}
} else {
return null
}
} else {
return null
}
}
Pyramid
of Doom
Throw in async
operations, we can
create the same
pyramid with nested
callbacks.

def foo(): Option[Int] = {
for {
x <- DoAThing()
y <- DoAnotherThing(x)
z <- DoYetAnotherThing(y)
} yield z
}

def foo(): Option[Int] = {
for {
x <- DoAThing()
y <- DoAnotherThing(x)
z <- DoYetAnotherThing(y)
} yield z
}
Every line is
significant

Application Becomes a
Collection of Pure
Functions

Parallelization
Fold All the Pieces!

Monads
The Key to a Lot of Awesome

Monoid
Type A
Identity Function
Binary Combinator

Monad
Type with a Functor +
FlatMap

State
The box is a
“monad”

State
Think of
monad as
collection of
at most one
item

State
You can do collection things to monads
Operation creates new monad of same type but
new state
.map(...)
.flatMap(...)
.fold(...)
.filter(...)
.collect(...)
.head

State
If Monad is “empty”, applied functions are
ignored
.map(...)
.flatMap(...)
.fold(...)
.filter(...)
.collect(...)
.head

def foo(): Option[Int] = Some(100)
val myFoo = foo()
val result =
myFoo
.map(i => i + 100)
.map(i => i.toString)
.map(i => i + " is a bigger number")
.getOrElse("didn't do anything")
// result = "200 is a bigger number"

def foo(): Option[Int] = None
val myFoo = foo()
val result =
myFoo
.map(i => i + 100)
.map(i => i.toString)
.map(i => i + " is a bigger number")
.getOrElse("didn't do anything")
// result = "didn’t do anything"
Executed but
not applied

Monads are so much
more but let’s keep it
simple for now…
...another talk to come

Trends in Functional Programming
Data Processing Streaming Parallelization
Machine Learning
Heavy
Computation Attracting Talent

Natural way to migrate
To Functional
Programming?

thanks!
Any questions?
You can find me at
@ProfParmer

Intro to Functional Programming

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Intro to Functional Programming (20)

Recently uploaded (20)

Intro to Functional Programming

Editor's Notes