Functional Programming Essentials

Functional
Programming
Essentials
Engineering Team Lead

@kelleyrobinson
Kelley Robinson

Functional
Programming
Essentials

“Standardized” Ladder of
Functional Programming
really
FUNCTIONAL PROGRAMMING ESSENTIALS @KELLEYROBINSON

Engineering Team Lead

@kelleyrobinson
Kelley Robinson

Essentials
Why this matters
FP In Scala
Origins

Origins
Paradigms

How did we get here?
Origins

“..in the same way that
music is not a set of
instruments, functional
programming is not a
set of abstractions that
we need to learn and
memorize.”
- José Calderón
Origins

The Lambda Calculus
Alonzo Church (1930s)
@KELLEYROBINSONFUNCTIONAL PROGRAMMING ESSENTIALS
Origins

λx.x+1
variable
function application
expression
Origins

λx.x+1
scala> { x: Int => x + 1 }
res1: Int => Int = <function1>
Origins

The Lambda Calculus
Alonzo Church (1930s)
Theoretical foundation
Pure functions - no state
Not a programming language
Origins

“Modern functional
languages can be thought
of as (nontrivial)
embellishments of the
lambda calculus”
- Paul Hudak (1989)

Fortran
John Backus (1954)
Origins

Logic Theory Machine
Newell and Simon (1956)
Origins

Logic Theory Machine
Newell and Simon (1956)
IPL (Information Processing
Language)
List processing
Recursion
Origins

Lisp
John McCarthy (1958)
Origins

Functional
abstraction
Evolution of Functional Programming
An Early History
Higher level
languages
List processing &
recursion
Lisp popularizes
paradigm
1930s 1950s
Origins

Paradigms
Revisited
Origins

Recursive
Programming
Techniques
W.H. Burge (1975)
Essentials

This was before…
Polymorphic Type Inference
Algebraic Data types
Lazy languages
Category-theoretic terminology
Introduction: Burge School of Functional Programming
W.H. Burge (1975)
Essentials

Expressions
Expressions
Expressions
Expressions
Expressions
Essentials

3x2 + y3x2 + y
Essentials

+ (* (3, square(x)), y)
3x2 + y
operators
operands
Essentials

+ (* (3, square(2)), 1)
for x = 2, y = 1
operators
operands
Essentials

+ (* (3, 4), 1)
operators
operands
for x = 2, y = 1
Essentials

+ (12, 1)
operators
operands
for x = 2, y = 1
Essentials

13
for x = 2, y = 1
Essentials

Side Eﬀects
Changes outside of function scope
Modiﬁes state
Not predictable
Essentials

Expressions
Instead of statements
Related:
Pure functions
Immutable data
Essentials

Referential
transparency
An expression can be replaced by
its value without changing the
program behavior
Essentials

Immutable data
Avoid modifying state
Essentials

Expressions
The programmer beneﬁts
Understanding
Predictability
Unit testing
Essentials

Data Structures
Constructing and Deconstructing
Essentials

Data Structures
Constructing and Deconstructing
1. How do you make the data?
2. How do you take it apart?
Essentials

sealed abstract class List[+A] 
case class Cons[A](head: A, tail: List[A]) extends List[A] 
case object Null extends List[Nothing]

def listFunction(list: List[Int]) = 
list match { 
case Cons(x, xs) =>
// ... something that uses x and xs... 
case Null =>
// ... something that can’t use x and xs...  
}

def length(l: List[Int]): Int = 
l match { 
case Cons(x, xs) => 1 + length(xs) 
case Null => 0 
}

def sum(l: List[Int]): Int = 
l match { 
case Cons(x, xs) => x + sum(xs) 
case Null => 0 
}

def product(l: List[Int]): Int = 
l match { 
case Cons(x, xs) => x * product(xs) 
case Null => 1 
}

def list[A, B](f: (A,B) => B,
d: B,
xs: List[A]): B = 
xs match { 
case Cons(y, ys) => f(y, list(f,d,ys)) 
case Null => d 
}

def list[A, B](f: (A,B) => B, d: B, xs: List[A]): B
def length ... = list((_, b) => 1 + b, 0, xs)
 
def sum ... = list((a, b) => a + b, 0, xs)
def product ... = list((a, b) => a * b, 1, xs)

Recursive
Programming
Techniques
W.H. Burge (1975)
Expressions
Data structures
Essentials

“Modern” Functional
Programming is
cluttered with jargon
Why this matters

“Jargon comes with an
inherent cost. It needs
to earn its place. (And it
often does: jargon is
necessary to discuss
complex and domain-
speciﬁc ideas.)”
- Bonnie Eisenman
FUNCTIONAL PROGRAMMING ESSENTIALS @KELLEYROBINSON@KELLEYROBINSON
Why this matters

“It is also a striking demonstration
of the fact that even deﬁnitions of
very high quality are often
inadequate as sources of
information on usage.”

Vocabulary and
context are necessary
for understanding

Ladder of
Functional Programming
really
“Standardized”**Updated!🙄**

Profunctor what?
Why this matters

“It may be fun to brag
about knowing how to
use "embedded DSL
with combinators,"
but is that really the
best thing to help your
startup succeed?”
- Hacker News
Why this matters

Jargon is
alienating
Why this matters

Please.
Stop.
Saying
This.
Please.
Why this matters

🙅
FP In Scala

Storing data val var
Iterating map for loop
pattern
matching
procedural
statements
Deconstructing data
preferred possible
FP In Scala

What about…?
Cats…Scalaz…FREE MONADS!?
Basics are built into Scala
(think `map`, `fold`)
Libraries have other syntactic
sugar
FP In Scala

• Have fun
• Promote understanding
• Be kind

Thank You!
@kelleyrobinson
hello@krobinson.me

FUNCTIONAL PROGRAMMING ESSENTIALS
Special thanks to
• Sharethrough
• José Calderón
• Heather Miller
• Bonnie Eisenman
Resources
• Mentioned in this talk:
• Bonnie Eisenman on Scala Jargon
• José Calderón's Burge School of Functional Programming
• Conception, Evolution, and Application of Functional Programming Languages
• Original LambdaConf ladder and Updated LambdaConf ladder
• Vocabulary Processes
• Further Reading & Watching:
• Functional programming
• Lambda calculus
• John McCarthy - History of Lisp
• Lambda Calculus - Computerphile
• Mark Priestley - New Problems, New Paradigms
• John Hughes, Mary Sheeran - Keynote: Why Functional Programming Matters
• Vocabulary and Comprehension Research:
• The Relationship between Reading Comprehension and Vocabulary Knowledge
• The Relationship between Vocabulary Size and Reading Comprehension
• Vocabulary and Word Study to Increase Comprehension in Content Areas
• Why Vocabulary Instruction Matters
• Eﬀects of long-term vocabulary instruction on reading comprehension
@KELLEYROBINSON

@KELLEYROBINSONFUNCTIONAL PROGRAMMING ESSENTIALSFUNCTIONAL PROGRAMMING ESSENTIALS
Photography credits
• Opening image
• Solving imaginary scaling issues
• Paradigms
• Orchestra
• Alonzo Church
• Philip Wadler
• Glitter
• Fortran
• Chess
• A Lisp machine in the MIT Museum
• 1975 SNL cast
• Side eﬀects
• Escher print
• Legos
• Jargon
• Child reading
• University
• The thinker
• Jargon is alienating
• Cat typing
@KELLEYROBINSON

Functional Programming Essentials

Recommended

Recommended

More Related Content

What's hot

What's hot (7)

Similar to Functional Programming Essentials

Similar to Functional Programming Essentials (20)

More from Kelley Robinson

More from Kelley Robinson (20)

Recently uploaded

Recently uploaded (20)

Functional Programming Essentials