Functional Programming Essentials

Functional Programming

Essentials

Engineering Team Lead

@kelleyrobinson

Kelley Robinson


Essentials

“Standardized” Ladder of Functional Programming

really

FUNCTIONAL PROGRAMMING ESSENTIALS @KELLEYROBINSON


Essentials


@kelleyrobinson

Kelley Robinson


@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+1scala> { 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


Essentials

Why this matters

FP In Scala

Origins

Recursive Programming TechniquesW.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

http://jmct.cc/intro/index.html


ExpressionsExpressions

ExpressionsExpressions

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

operandsfor x = 2, y = 1

Essentials


+ (12, 1)

operators

operandsfor x = 2, y = 1

Essentials


13

for x = 2, y = 1

Essentials

Side Effects Changes outside of function scope

Modifies 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 benefits

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


Essentials

Why this matters

FP In Scala

Origins

“Standardized” Ladder of Functional Programming

really


“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-specific ideas.)”

- Bonnie Eisenman

FUNCTIONAL PROGRAMMING ESSENTIALS @KELLEYROBINSON@KELLEYROBINSON

Why this matters

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

Vocabulary and context are necessary

for understanding

http://bit.ly/2oiaoUc

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

http://bit.ly/2oUI3om

http://bit.ly/2oUI3om

Please.

Stop.

Saying

This.

Please.


Why this matters


Essentials

Why this matters

FP In Scala

Origins


🙅FP In Scala


Storing data val var

Iterating map for loop

pattern matching

procedural statementsDeconstructing 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

[email protected]

mailto:[email protected]

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 • Effects of long-term vocabulary instruction on reading comprehension

@KELLEYROBINSON

http://blog.bonnieeisenman.com/blog/scala-jargon/

http://jmct.cc/intro/index.html

https://cse.sc.edu/~mgv/csce330f15/haskell/p359-hudak.pdf

https://pbs.twimg.com/media/CydL5EYUsAAI-61.jpg:large

http://lambdaconf.us/downloads/documents/lambdaconf_slfp.pdf

https://books.google.com/books?id=XUMvpxmTdQYC&pg=PA468&lpg=PA468&dq=%E2%80%9CIt+is+also+a+striking+demonstration+of+the+fact+that+even+definitions+of+very+high+quality+are+often+inadequate+as+sources+of+information+on+usage.%E2%80%9D&source=bl&ots=SLiuY7TW8f&sig=KIHBEHcGYLrzuh5QkDV1wNowhB0&hl=en&sa=X&ved=0ahUKEwiQtMngua7TAhWrsFQKHQSVAjcQ6AEIJzAB#v=onepage&q=%E2%80%9CIt%20is%20also%20a%20striking%20demonstration%20of%20the%20fact%20that%20even%20definitions%20of%20very%20high%20quality%20are%20often%20inadequate%20as%20sources%20of%20information%20on%20usage.%E2%80%9D&f=false

https://en.wikipedia.org/wiki/Functional_programming

https://en.wikipedia.org/wiki/Lambda_calculus

http://www-formal.stanford.edu/jmc/history/lisp/lisp.html

https://www.youtube.com/watch?v=eis11j_iGMs

https://www.youtube.com/watch?v=AZZThgj4Jw4

https://www.youtube.com/watch?v=1qBHf8DrWR8

https://www.hindawi.com/journals/edri/2015/209154/

http://files.eric.ed.gov/fulltext/EJ1095578.pdf

http://fisherpub.sjfc.edu/cgi/viewcontent.cgi?article=1248&context=education_ETD_masters

http://ngl.cengage.com/assets/downloads/edge_pro0000000030/am_moore_why_vocab_instr_mtrs.pdf

http://bit.ly/2nPYikB

@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 effects • Escher print • Legos • Jargon • Child reading • University • The thinker • Jargon is alienating • Cat typing

@KELLEYROBINSON

http://www.apple.com

https://twitter.com/thepracticaldev/status/800752571497545729

http://inlpcenter.org/5-undeniable-signs-that-your-personal-paradigm-is-holding-you-back/

http://www.summitrecords.com/artist/london-symphony-orchestra-3/

https://www.princeton.edu/pr/pwb/03/0505/7a.shtml

https://www.flickr.com/photos/drjason/280369547

https://s-media-cache-ak0.pinimg.com/originals/06/f4/a6/06f4a635df1fa7973279e0acc9f9d6f9.jpg

https://en.wikipedia.org/wiki/Fortran

http://www.businessinsider.com/win-a-game-of-chess-in-two-moves-2016-4

https://en.wikipedia.org/wiki/Lisp_(programming_language)#/media/File:LISP_machine.jpg

https://www.reddit.com/r/OldSchoolCool/comments/2afl2d/snl_original_1975_cast/

https://www.fdli.org/2017/05/rems-key-issues-best-practices/

http://britton.disted.camosun.bc.ca/escher/day_and_night.jpg

https://blog.johnrchildress.com/2015/01/06/understanding-corporate-culture-jigsaw-puzzle-or-legos/

http://www.onhold.on.ca/jargon-words-remix-re-read/

http://www.greenatom.earth/news/in-the-brain-one-area-sees-familiar-words-as-pictures-another-sounds-out-words/

http://www.1zoom.net/Cities/wallpaper/300561/z1545.1/

http://www.ktrnews.com/the-thinker/

https://www.theregister.co.uk/2014/06/06/thanks_for_nothing_openssl_cries_stonewalled_de_raadt/

https://media.giphy.com/media/JIX9t2j0ZTN9S/giphy.gif

Functional Programming Essentials

Engineering

Transcript of Functional Programming Essentials