Nuno

© Equal Experts UK Ltd 2015 ‹#›
Why should I bother with functional
programming?
▪ Nuno Marques
▪ nmarques@equalexperts.com
▪ @nfma

gone insane
back to sanity
conclusion
q&a
summary

complexity
side-effects
state
composition
expression problem
compilation
apis
tools
concurrency
distributed systems
gone insane

http://emergentuniverse.wikia.com/wiki/Rube_Goldberg_Machine
complexity

http://www.chinadaily.com.cn/opinion/2013-08/12/
side-effects

http://s2.quickmeme.com/img/
state

composition

http://pictures.jokofy.com/cutest-mechanic/
expression problem

https://pbs.twimg.com/media/B25NsvQCMAA1Ihd.jpg
compilation

http://www.johnlund.com/page/1486/drooping-limp-hammer-bad-tools.asp
tools

http://idm-thoughtplace.blogspot.se/
concurrency

http://www.azquotes.com/author/28839-Leslie_Lamport
distributed systems

▪composition
▪immutability
▪identity and state
▪referential transparency
▪parametricity
▪type classes
▪taming side-effects
▪concurrency
▪parallelism
back to sanity

https://jordankasper.com/js-testing/#/
composition

scala> val double: Int => Int = 2 * _
scala> val inc: Int => Int = _ + 1
scala> val incAndDouble = double compose inc
scala> incAndDouble(5)
res0: Int = 12
function composition example

http://memegenerator.net/instance/55120894
immutability

▪https://en.wikipedia.org/wiki/Persistent_data_structure
persistent data-structure

http://www.railslove.com/stories/my-way-into-clojure-building-a-card-game-with-om-part-1
identity and state

▪ http://www.javiersaldana.com/tech/2014/10/15/mental-models-for-concurrency.html
epochal time model

http://teachers.henrico.k12.va.us/math/Newsletter/May14Newsletter.html
referential transparency

scala> val double: Int => Int = 2 * _
scala> val inc: Int => Int = num => {
/* fire the missiles */
println("missiles fired”)
num + 1
}
scala> inc(5)
missiles fired
referencial transparency example

parametricity

val unknown: Int => Int = ???
parametricity example

val unknown: Boolean => Boolean = ???

scala> val returnArgument = (a: Boolean) => a
scala> val returnFalse = (_: Boolean) => false
scala> val returnTrue = (_: Boolean) => true
scala> val returnOppositeOfArgument = (a: Boolean) => !a

val unknown: A => A = ???

val identity: (a: A) => a

null
exceptions
Type-casing (isInstanceOf)
Type-casting (asInstanceOf)
Side-effects
equals/toString/hashCode
notify/wait
classOf/.getClass
General recursion
parametricity assumptions

http://cdn.meme.am/instances/400x/49222894.jpg
type classes

Prelude> :t (==)
(==) :: Eq a => a -> a -> Bool
Prelude> :t (*)
(*) :: Num a => a -> a -> a

type classes example

class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
x == y = not (x /= y)
x /= y = not (x == y)
data TrafficLight = Red | Yellow | Green

class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
x == y = not (x /= y)
x /= y = not (x == y)
data TrafficLight = Red | Yellow | Green
instance Eq TrafficLight where
    Red == Red = True
    Green == Green = True
    Yellow == Yellow = True
    _ == _ = False

taming side-effects

(defn transfer[amount from to]
“atomically transfer amount between two accounts form and
to”
(dosync
(alter from - amount)
(alter to + amount)))
taming side-effects

(defn memoize [f]
(let [mem (atom {})]
(fn [& args]
(if-let [e (find @mem args)]
(val e)
(let [ret (apply f args)]
(swap! mem assoc args ret)
ret)))))
(defn fib [n]
(if (<= n 1)
n
(+ (fib (dec n)) (fib (- n 2)))))
(memoize fib)
taming side-effects

http://cdn5.raywenderlich.com/wp-content/uploads/2014/01/Thread_All_The_Code_Meme.jpg
concurrency and parallelism

no-no: MS-DOS / single core
yes-no: Windows 95/98 / single core
no-yes: pinned cores to processes
yes-yes: today’s applications / multicore
concurrency and parallelism differences

http://talks.joneisen.me/presentation-javascript-concurrency-patterns/img/meme-concurrency.jpg
concurrency

import
scala.concurrent.ExecutionContext.implicits.global
val f = for {
a <- Future(10 / 2)
b <- Future(a + 1)
c <- Future(a - 1)
if c > 3
} yield b * c
concurrency example

class HelloActor extends Actor {
  def receive = {
    case "hello" => println("hello back at you")
    case _       => println("huh?")
  }
}

object Main extends App {
  val system = ActorSystem("HelloSystem")
  // default Actor constructor
  val helloActor = system.actorOf(Props[HelloActor], name =
"helloactor")
  helloActor ! "hello"
  helloActor ! "buenos dias"
}
concurrency example

(let [c1 (chan)
c2 (chan)]
(go (while true
(let [[v ch] (alts! [c1 c2])]
(println "Read" v "from" ch))))
(go (>! c1 "hi"))
(go (>! c2 "there")))
concurrency example

me
conclusion

http://www.troll.me/images/first-world-problems/done-with-my-presentation-now-i-have-to-answer-questions.jpg
q&a

Nuno

Recommended

Recommended

More Related Content

Similar to Nuno

Similar to Nuno (20)

Recently uploaded

Recently uploaded (20)

Nuno