JDD2015: Functional programing and Event Sourcing - a pair made in heaven - extended, 2 hours long brainwash - Paweł Szulc

Functional Programming
& Event Sourcing
A pair made in heaven
twitter: @rabbitonweb, email: paul.szulc@gmail.com

Functional Programming
& Event Sourcing
A pair made in heaven
twitter: @rabbitonweb, email: paul.szulc@gmail.com2h brainwash

● no assignment statements
● no variables

● no variables
● once given a value, never
change

● no variables
● once given a value, never
change
● no side-effects at all

“The functional programmer
sounds rather like a
mediæval monk,

mediæval monk, denying
himself the pleasures of life

mediæval monk, denying
himself the pleasures of life
in the hope that it will make
him virtuous.”

case class User(id: Long, fn: String, ln: String)

class Cache { def check(id: Long): Option[User] = ??? }

case class UserRepo(cache: Cache) {
def retrieve(id: Long): User = ???
}

}
class UserFinder(cache: Cache, repo: UserRepo) {
}

}
def findUser(id: Long): User = {
}
}

}
val maybeUser: Option[User] = cache.check(id)
}
}

}
if (maybeUser.isDefined) {
maybeUser.get
}
}
}

}
if (maybeUser.isDefined) {
maybeUser.get
} else {
val user: User = repo.retrieve(id)
cache.insert(user.id, user)
}
}
}

input f(input): output output g(input): output

input f(input): output output g(input): output output

h = g o f
input f(input): output output g(input): output output

/**
* This function returns a reversed list
* @param list A list to be reversed
* @return A reversed list
*/
public List<T> reverse(List<t> list) { ??? }

JDD2015: Functional programing and Event Sourcing - a pair made in heaven - extended, 2 hours long brainwash - Paweł Szulc

/**
* @param list A list to be reversed

/**

public List<T> reverse(List<t> list) {
return list.sort();
}

def smdfknmsdfp[A](a: A): A = ???

def smdfknmsdfp[A](a: A): A = a

def smdfknmsdfp(a: Int): Int = ???

def smdfknmsdfp(a: Int): Int = a
= a + 10
= 10

def sum(list: List[Int]): Int =

def sum(list: List[Int]): Int = list match {
case Nil => 0

def sum(list: List[Int]): Int = list match {
case Nil => 0
case num :: tail => num + sum(tail)
}

def reduce[T, K]
(list: List[T]): K =

def reduce[T, K]
(list: List[T]): K = list match {
case Nil => zero

def reduce[T, K]
(zero: K)
case Nil => zero

def reduce[T, K]
(zero: K)
case Nil => zero
case head :: tail => op(head)(reduce(op)(zero)(tail))
}

def reduce[T, K](op: T => K => K)
(zero: K)
case Nil => zero
}

(zero: K)
case Nil => zero
}
def sum: List[Int] => Int =

(zero: K)
case Nil => zero
}
def sum: List[Int] => Int = reduce(plus)(0)

(zero: K)
case Nil => zero
}
def product: List[Int] => Int =

(zero: K)
case Nil => zero
}
def product: List[Int] => Int = reduce(multiply)(1)

(zero: K)
case Nil => zero
}
def anyTrue: List[Boolean] => Boolean =

(zero: K)
case Nil => zero
}
def anyTrue: List[Boolean] => Boolean = reduce(or)(false)

(zero: K)
case Nil => zero
}
def allTrue: List[Boolean] => Boolean =

(zero: K)
case Nil => zero
}
def allTrue: List[Boolean] => Boolean = reduce(and)(true)

(zero: K)
case Nil => zero
}
A :: B :: C :: D :: E :: Nil

(zero: K)
case Nil => zero
}
A :: B :: C :: D :: E :: Nil
A :: B :: C :: D :: E :: Nil

(zero: K)
case Nil => zero
}
A :: B :: C :: D :: E :: Nil
A :: B :: C :: D :: E :: zero

(zero: K)
case Nil => zero
}
A :: B :: C :: D :: E :: Nil
A op B op C op D op E op zero

def <++>[T](a: List[T])(b: List[T]): List[T] =

def <++>[T](a: List[T])(b: List[T]): List[T] =
reduce(::[T])(b)(a)

def lgth[T]: List[T] => Int = reduce(<+>)(0)

def <+>[T](el: T)(len: Int) = 1 + len
def lgth[T]: List[T] => Int = reduce(<+>)(0)

def double(x: Int) = 2 * x
def doubleAll: List[Int] => List[Int] =

reduce(<+>)(List.empty[Int])

def <+>(el: Int)(list: List[Int]) = double(el) :: list
reduce(<+>)(List.empty[Int])

def map[T](f: T => T) = {
reduce(<+>)(List.empty[T])(_)
}

def <+>(el: T)(list: List[T]) = f(el) :: list
}

}
def doubleAll: List[Int] => List[Int] = map(double)

case class TreeOf[T](label: T, subtrees: List[TreeOf[T]])

def redtree[T, K,M]
= tree match {
case TreeOf(label, subtrees) =>
}

def redtree[T, K,M](op1: T => K => M)
= tree match {
op1(label)()
}

def redtree[T, K,M](op1: T => K => M)
= tree match {
op1(label)(_redtree[T, K,M](op1)(op2)(zero)(subtrees))
}

def redtree[T, K,M](op1: T => K => M)(op2: M => K => K)(zero: K)(tree:
TreeOf[T]): M = tree match {
}

def _redtree[T, K, M](op1: T => K => M)(op2: M => K => K)(zero: K)
(subtrees: List[TreeOf[T]]): K =
}

(subtrees: List[TreeOf[T]]): K = subtrees match {
case Nil => zero
}

case Nil => zero
case subtree :: rest =>
}
}

case Nil => zero
redtree(op1)(op2)(zero)(subtree))
}
}

case Nil => zero
redtree(op1)(op2)(zero)(subtree))
(_redtree(op1)(op2)(zero)(rest))
}
}

case Nil => zero
op2(redtree(op1)(op2)(zero)(subtree))
(_redtree(op1)(op2)(zero)(rest))
}
}

def sumtree = redtree(plus)(plus)(0)(_)

def labels[T]: TreeOf[T] => List[T] =
redtree(::[T])(<++>[T])(List.empty[T])

def mapTree[T, K](f: T => K): TreeOf[T] => TreeOf[K] = {
def <+>(label: T)(subtrees: List[TreeOf[K]]) =
TreeOf(f(label), subtrees)
redtree(<+>)(::[TreeOf[K]])(List.empty[TreeOf[K]])
}

“Why Functional Programming Matters”
J. Hughes
http://comjnl.oxfordjournals.org/content/32/2/98.
full.pdf

J. Hughes, Nov. 1988
full.pdf

Soft introduction
J. Hughes, Nov. 1988
full.pdf

“Program Design by Calculation”
J.N. Oliveira
http://www4.di.uminho.pt/~jno/ps/pdbc_part.pdf

J.N. Oliveira, Draft

Patterns in FP World

Patterns in FP World Math Matters

“A lengthy approach to Haskell fundamentals”
http://www.davesquared.net/2012/05/lengthy-
approach-to-haskell.html

https://xkcd.com/1312/

Monads
Asking the right question

“I'm ready to write my first program. How
can I print some stuff to console?”

“What the *** is a monad?”

1. We understand code
2. It is easier to talk about related ideas and
then abstract to something more general

3. Having abstract model created, we tend to
create metaphors

3. Having abstract model created, we tend to
create metaphors
4. Having all above we can formalize

Android, iOS, Windows Phone
Partner Lookup

case class Geek(name: String, partner: Geek = null, workPlace: WorkPlace)

case class WorkPlace(name: String, street: String)

def partnerLookup(geek: Geek): String =

def partnerLookup(geek: Geek): String = geek.partner.workPlace.street

val cheeseCakeFactory = WorkPlace("Cheese Cake Factory", "Cake Street 1")
val university = WorkPlace("University", "Academic St. 10")

var penny = Geek("Penny", workPlace = cheeseCakeFactory)
var leonard = Geek("Leonard", workPlace = university)

penny = penny.copy(partner = leonard)
leonard = leonard.copy(partner = penny)

println(partnerLookup(leonard))
println(partnerLookup(penny))

println(partnerLookup(leonard)) // output: "Cake Street 1"

println(partnerLookup(penny)) // output: "Academic St. 10"

val rajesh = Geek("Rajesh", workPlace = university)

println(partnerLookup(rajesh))

// java.lang.NullPointerException
// at wtf.examples.A1$.partnerLookUp(A1.scala:14)
// at ...

def partnerLookup(geek: Geek): String = {
}

if(geek != null) {
}

if(geek != null) {
if(geek.partner != null) {
}

if(geek != null) {
if(geek.partner.workPlace != null) {
}

if(geek != null) {
if(geek.partner.workPlace.street != null) {
}

if(geek != null) {
return geek.partner.workPlace.street
}
}
}
}
}

if(geek != null) {
return geek.partner.workPlace.street
}
}
}
}
"not found"
}

println(partnerLookup(penny)) // output: "Academic St. 10"
println(partnerLookup(rajesh)) // output: "not found"

sealed trait Maybe[+A]
case class Some[+A](value: A) extends Maybe[A]

case object None extends Maybe[Nothing]

case object None extends Maybe[Nothing]
object Maybe {
def apply[A](value: A) = Some(value)
}

sealed trait Maybe[+A] {
}
object Maybe {
}
case class Some[+A](value: A) extends Maybe[A] {
}
case object None extends Maybe[Nothing] {
}

def andThen[B](f: A => Maybe[B]): Maybe[B]
}
object Maybe {
}
}
}

}
object Maybe {
}
def andThen[B](f: A => Maybe[B]): Maybe[B] = f(value)
}
}

}
object Maybe {
}
}
def andThen[B](f: Nothing => Maybe[B]): Maybe[B] = this
}

case class Geek(name: String, partner: Maybe[Geek] = wtf.monads.None, workPlace: Maybe[WorkPlace])
case class WorkPlace(name: String, street: Maybe[String])

geek.partner

geek.partner.andThen(p => p.workPlace)

geek.partner.andThen(p => p.workPlace).andThen(wp => wp.street)

geek.partner.andThen(p => p.workPlace).andThen(wp => wp.street) match {
case wtf.monads.Some(street) => street
}

case wtf.monads.None => "not found"
}

println(partnerLookup(leonard))

}

def partnerLookup(geek: Geek): Maybe[String] =
}

with a little bit of magic
For-comprehension

}
def partnerLookup(geek: Geek): Maybe[String] = {
}

}
import Magic._
}

geek.partner.andThen(g => g.workPlace).andThen(wp => wp.street) match {
}
import Magic._
for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

}
import Magic._
for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

var leonard = Geek("Leonard", workPlace = university, partner = penny)
partnerLookup(leonard) // Some("Cake Street 1")
// how to print it?

def within[B](f: A => B): Maybe[B]
}
object Maybe {
}
}
}

}
object Maybe {
}
}
}
Reuse existing functionality like println

}
object Maybe {
}
def within[B](f: A => B): Maybe[B] = Maybe(f(value))
}
}

}
object Maybe {
}
def within[B](f: A => B): Maybe[B] = Maybe(f(value))
}
def within[B](f: Nothing => B): Maybe[B] = this
}

partnerLookup(leonard)

partnerLookup(leonard).within(println) // output: "Cake Street 1"

Android, iOS, Windows Phone
Ship Inventory

case class Pirate(name: String, ships: Many[Ship])
case class Ship(name: String, hold: Hold)
case class Hold(barrel: Many[Barrel])
case class Barrel(amount: Int)

val jack = Pirate("Captain Jack Sparrow", Many(blackPearl, whitePearl))

val blackPearl = Ship("Black Pearl", blackHold)
val whitePearl = Ship("White Pearl", whiteHold)

val blackHold = Hold(Empty)
val whiteHold = Hold(Many(Barrel(20), Barrel(10)))
val blackPearl = Ship("Black Pearl", blackHold)
val whitePearl = Ship("White Pearl", whiteHold)

sealed trait Many[+A]
case class Const[+A](head: A, tail: Many[A]) extends Many[A]

case object Empty extends Many[Nothing]

case object Empty extends Many[Nothing]
object Many {
def apply[A](elements: A*): Many[A] = {
if(elements.length == 1) Const(elements(0), Empty)
else Const(elements(0), apply(elements.drop(1) : _*))
}
}

sealed trait Many[+A] {
def andThen[B](f: A => Many[B]): Many[B]
def within[B](f: A => B): Many[B]
}

case class Const[+A](head: A, tail: Many[A]) extends Many[A] {
def andThen[B](f: A => Many[B]): Many[B] = ...
def within[B](f: A => B): Many[B] = ...
}

def andThen[B](f: A => Many[B]): Many[B] = ...
def within[B](f: A => B): Many[B] = Const(f(head), tail.within(f))
}

def andThen[B](f: A => Many[B]): Many[B] =
concat( f(head), tail.andThen(f) )
}

private def concat[A](first: Many[A],
second: Many[A]): Many[A] = { … }
}

private def concat[A](first: Many[A],
second: Many[A]): Many[A] = { … }
}
case object Empty extends Many[Nothing] {
def andThen[B](f: Nothing => Many[B]): Many[B] = this
def within[B](f: Nothing => B): Many[B] = this
}

val blackPearl = Ship("Black Pearl", Hold(Empty))
val whitePearl = Ship("White Pearl",
Hold(Many(Barrel(20), Barrel(10))))

jack.ships.andThen(ship => ship.hold.barrel)
.within(barrel => barrel.amount)

import Magic._
val amounts = for {
ship <- jack.ships
barrel <- ship.hold.barrel
} yield (barrel.amount)

import Magic._
val amounts = for {
ship <- jack.ships
barrel <- ship.hold.barrel
} yield (barrel.amount)
println(amounts) // Const(20,Const(10,Empty))

● We've seen two wrapping classes.

● All have andThen method.

● All have andThen method.
● Each can take a function that can be called
on a value wrapped by the structure (which
can be empty or there can be multiple
instances of it).

Both were examples of a
Monad!

Monad is a container, a box.
A box in which we can store
an object. Wrap it.

an object, a value.
A box that has a common
interface, which allows us to
do one thing: connect
sequence of operations on the
content of the box.

an object, a value.
content of the box.
andThen means "do the next
things".

an object, a value.
content of the box.
andThen means "do the next
things".
But the way it is done depends
on a box.

Monad is an abstract data type.

It has two operators: andThen and unit

object Maybe {
}

bind (>>=) // formal name

bind (>>=) // formal name
flatMap // in Scala

import Magic._
for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

object Magic {
case class RichMaybe[A](m: Maybe[A]) {
def flatMap[B](f: A => Maybe[B]): Maybe[B] = m.andThen(f)
def map[B](f: A => B): Maybe[B] = m.within(f)
}
implicit def enrich[A](m: Maybe[A]) = RichMaybe(m)
}

for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

It has two operators: bind and unit

It has two operators: bind and unit
Those operators must follow certain rules:
1. associativity
2. left identity
3. right identity

1. associativity
2. left identity
3. right identity
unit acts approximately as a
neutral element of bind

1. associativity
2. left identity
3. right identity
unit allows us to put value
into the box without
damaging it

1. associativity
2. left identity
3. right identity
unit(x).flatMap(f) == f(x)
m.flatMap(unit) == m
unit allows us to put value
into the box without
damaging it

1. associativity
2. left identity
3. right identity
“Binding two functions in
succession is the same as
binding one function that can
be determined from them”

1. associativity
2. left identity
3. right identity
m.flatMap{f(_)}.flatMap.{g(_)}
==
m.flatMap{f(_).flatMap.{g(_)}}
“Binding two functions in
succession is the same as
binding one function that can
be determined from them”

class Cache {}

class Cache {}
def check(id: Long)(cache: Cache): (Cache, Option[User]) = ...

class Cache {}
def retrieve(id: Long)(cache: Cache): (Cache, User) = ...

class Cache {}
def findUser(id: Long)(cache: Cache): (Cache, User) = {
}
}

class Cache {}
val (c, mu) = check(id)(cache)
}
}

class Cache {}
mu match {
case Some(u) => (c, u)
}
}
}

class Cache {}
mu match {
case None => retrieve(id)(c)
}
}
}

State[S, A]
S => (S, A)
.run(S)

State[S, A]
S => (S, A)
.map(A => B): State[S, B]

State[S, A]
S => (S, A)
.flatMap(A => State[S, B]): State[S,B]

object State {
def apply[S, A] (f: S => (S,A)): State[S, A] =
}

object State {
new State[S, A] {
def run(s: S) = f(s)
}
}

object State {
new State[S, A] {
}
}
def check(id: String) = State[Cache, Option[User]].apply {
}

object State {
new State[S, A] {
}
}
def check(id: String) = State[Cache, Option[User]].apply {
(c: Cache) => (c, c.get(id))
}

object State {
new State[S, A] {
def run(s: S) = f(s(
}
}
def check(id: String) = State[Cache, Option[User]]{
(c: Cache) => (c, c.get(id))
}

trait State[S, +A] {
def run(initial: S): (S, A)
}

def map[B](f: A => B): State[S, B] =
}
}

State {
}
}
}

State { s0 =>
(_, _ )
}
}
}

State { s0 =>
(_, f(a))
}
}
}

State { s0 =>
val (s, a) = run(s0)
(_, f(a))
}
}
}

State { s0 =>
(s, f(a))
}
}
}

State { s0 =>
(s, f(a))
}
}
def flatMap[B](f: A => State[S,B]): State[S, B] =
}
}

State { s0 =>
(s, f(a))
}
}
f(a)
}
}

State { s0 =>
(s, f(a))
}
}
State { s0 =>
f(a)
}
}
}

State { s0 =>
(s, f(a))
}
}
State { s0 =>
f(a).run(s)
}
}
}

class Cache {}
def check(id: Long)(cache: Cache): (Cache, Option[User]) = ???
def retrieve(id: Long)(cache: Cache): (Cache, User) = ???
mu match {
case None => retrieve(id)(c)
}
}
}

class Cache {}
def check(id: Long): State[Cache, Option[User]] = ???
def retrieve(id: Long): State[Cache, User] = ???
def findUser(id: Long): State[Cache, User] = {
for {
maybeUser <- check(id)
user <- maybeUser match {
case Some(u) => State { c => (c, u)}
case None => retrieve(id)
}
} yield (user)
}

Event Sourcing
driven by business

Bloggers Conf App
● Can create an account

Bloggers Conf App
● List all bloggers already using the app

Bloggers Conf App
● Mark/unmark other blogger as a friend

Bloggers Conf App
● Mark/unmark other blogger as an enemy

Bloggers Conf App
● Mark/unmark other blogger as an enemy
● Deactivate its account

Bloggers Conf App
Bloggers
id first_name last_name active
1 Jan Kowalski T
2 Krystian Nowak T
3 Malgorzata Kucharska T

Bloggers Conf App
Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
3 1

Bloggers Conf App
Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
3 1
Enemies
id enemy_id
3 2

Structure is not that
important

Structure is not that
important
Changes more often than behaviour

Start thinking about facts
occurring

Start thinking about facts
occurring
Derive structure from them

Blogger
Account
Created
(id=3)

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2
Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
Enemies
id enemy_id

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2
Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
3 1
Enemies
id enemy_id

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2
Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
3 1
Enemies
id enemy_id
3 2

Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2
Befriended
Blogger
id=2
Unfriended
Blogger
id=2
Blogger
Account
Created
(id=3)
Befriended
Blogger
id=1
Made
Enemy of
Blogger
id=2

Event Sourcing
The only model that does not lose data

“Enemy of my enemy is
my friend”

Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
Friends
id friend_id
3 1
Enemies
id enemy_id
3 2

Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
4 Tomasz Młynarski T
Friends
id friend_id
3 1
Enemies
id enemy_id
3 2
4 2

Bloggers
1 Jan Kowalski T
2 Krystian Nowak T
4 Tomasz Młynarski T
5 Monika Jagoda T
Friends
id friend_id
3 1
Enemies
id enemy_id
3 2
4 2
2 5

id = 3
id = 2
id = 1
id = 4
id = 5
id = 6

Benefits of Event Sourcing
● Ability to go in time and figure out exactly what have
happened

happened
● Scientific measurements over time, compare time
periods

happened
periods
● Built-in audit log

happened
periods
● Enables temporal querying

happened
periods
● Fits well with machine learning

happened
periods
● Preserves history - question not yet asked

happened
periods
● Writing regression tests is easy

happened
periods
● Writing regression tests is easy
● Polyglot data

Drawbacks of Event Sourcing
● Historical record of your bad decisions

● Handling event duplicates

● Handling event duplicates
● Data eventually consistent

Journal
val id = “”
val firstName: String = “”
val lastName: String = “”
val friends: List[String] =
List()

Journal
val id = “”
val firstName: String = “”
val lastName: String = “”
List()
Initialized(“1”, “Jan”, “Kowalski”

Journal
val id = “1”
val firstName: String =
“Jan”
val lastName: String =
“Kowalski”
List()

Journal
val id = “1”
val firstName: String = “Jan”
“Kowalski”
List()

Journal
val id = “1”
“Kowalski”
List()
Befriended(“10”)

Journal
val id = “1”
“Kowalski”
List(“10”)

Journal
val id = “1”
“Kowalski”
val friends: List[String] = List
(“10”)

Journal
val id = “1”
“Kowalski”
List(“10”, “31”)

Journal
val id = “1”
“Kowalski”
(“10”, “31”)

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“31”)

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“31”)
validation

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“34”)

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“34”)
validation

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“34”)
Befriended(“34”)

Journal
val id = “1”
“Kowalski”
(“10”, “31”)
Befriend(“34”)
ACK

Journal
val id = “1”
“Kowalski”
List(“10”, “31”, “34”)
Befriend(“34”)

Journal
val id = “1”
“Kowalski”
List(“10”, “31”, “34”)

What we are missing?
1. Read-model

What we are missing?
1. Read-model
2. Validation

Paweł Szulc
http://rabbitonweb.com

Paweł Szulc
@rabbitonweb

Paweł Szulc
@rabbitonweb
https://github.com/rabbitonweb/

JDD2015: Functional programing and Event Sourcing - a pair made in heaven - extended, 2 hours long brainwash - Paweł Szulc

Recommended

More Related Content

What's hot (20)

Similar to JDD2015: Functional programing and Event Sourcing - a pair made in heaven - extended, 2 hours long brainwash - Paweł Szulc (20)

Recently uploaded (20)

JDD2015: Functional programing and Event Sourcing - a pair made in heaven - extended, 2 hours long brainwash - Paweł Szulc