Implementing the Stable Marriage Problem in Erlang Using Message Passing

@theburningmonkYan Cui @theburningmonk

@theburningmonk
Hi, my name is Yan Cui.

ZOOZU
VAPA
BOROU
DUMBU
dark shades of blue, red, green & purple
white & some shades of yellow
some shades of green & blue
other shades of green, red & brown

@theburningmonk
“The limits of my
language means the
limits of my world.”
- Ludwig Wittgenstein

@theburningmonk
Type Provider Pipes
Statically Resolved TP
Implicit Interface
Implementation
Borrowed Pointers Dependent Types
Uniqueness Types
Bit Syntax
Signals
Macros
Unit-of-Measure
Actor Model

@theburningmonk
your
app
CSVCSVCSV
CSVCSVXML

@theburningmonk
your
app
CSVCSVCSV
CSVCSVXML
some
service

@theburningmonk
your
app
CSVCSVCSV
CSVCSVXML
some
service
DB

@theburningmonk
1. define DTO types
2. I/O
3. marshal data into DTO
4. do useful work

@theburningmonk
compiler
provideexternal
data source typed info

@theburningmonk
type providers

@theburningmonk
intellisense
tooltips
…

@theburningmonk
intellisense over S3
buckets & objects!

@theburningmonk
compile time validation

@theburningmonk
no code generation

@theburningmonk
R
FunScript
Azure
Amazon S3
CSVSQLite
SQL Server
WSDL
WorldBank
Regex
ODATA IKVM
Facebook
Apiary
XAMLFreebase
Hadoop
Oracle
Minesweeper
Don Syme
Powershell
JSON
Fizzbuzz
Mixin
RSS
Matlab
Dates
NorthPole
XML
Python

@theburningmonk
Don Syme can taste lies.

@theburningmonk
“…a clean design is one that
supports visual thinking so
people can meet their
informational needs with a
minimum of conscious effort.”
- Daniel Higginbotham
(www.visualmess.com)

@theburningmonk
Whilst talking with an ex-colleague, a question came up on how to implement the Stable Marriage
problem using a message passing approach. Naturally, I wanted to answer that question with Erlang!
Let’s first dissect the problem and decide what processes we need and how they need to interact with
one another.
The stable marriage problem is commonly stated as:
Given n men and n women, where each person has ranked all members of the opposite sex with a
unique number between 1 and n in order of preference, marry the men and women together such that
there are no two people of opposite sex who would both rather have each other than their current
partners. If there are no such people, all the marriages are “stable”. (It is assumed that the participants
are binary gendered and that marriages are not same-sex).
From the problem description, we can see that we need:
* a module for man
* a module for woman
* a module for orchestrating the experiment
In terms of interaction between the different modules, I imagined something along the lines of…
how we read ENGLISH
see also http://bit.ly/1KN8cd0

@theburningmonk
Whilst talking with an ex-colleague, a question came up on how to implement the Stable Marriage
problem using a message passing approach. Naturally, I wanted to answer that question with Erlang!
Let’s first dissect the problem and decide what processes we need and how they need to interact with
one another.
Given n men and n women, where each person has ranked all members of the opposite sex with a
unique number between 1 and n in order of preference, marry the men and women together such that
there are no two people of opposite sex who would both rather have each other than their current
partners. If there are no such people, all the marriages are “stable”. (It is assumed that the participants
* a module for man
In terms of interaction between the different modules, I imagined something along the lines of…
2.top-to-bottom
1.left-to-right
how we read ENGLISH

@theburningmonk
how we read CODE
public void DoSomething(int x, int y)
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}

@theburningmonk
how we read CODE
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}
2.bottom-to-top
1.right-to-left

@theburningmonk
Whilst talking with an ex-colleague, a question came up on
how to implement the Stable Marriage problem using a
message passing approach. Naturally, I wanted to answer
that question with Erlang!
Let’s first dissect the problem and decide what processes we
need and how they need to interact with one another.
Given n men and n women, where each person has ranked
all members of the opposite sex with a unique number
between 1 and n in order of preference, marry the men and
women together such that there are no two people of
opposite sex who would both rather have each other than
their current partners. If there are no such people, all the
marriages are “stable”. (It is assumed that the participants
* a module for man
In terms of interaction between the different modules, I
imagined something along the lines of…
2.top-to-bottom
1.left-to-right
how we read ENGLISH
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}
2.top-to-bottom
1.right-to-left
how we read CODE

@theburningmonk
“…a clean design is one that
supports visual thinking so
people can meet their
informational needs with a
minimum of conscious effort.”

@theburningmonk
how we read CODE
let drawCircle x y radius =
radius |> circle
|> ﬁlled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)

@theburningmonk
how we read CODE
radius |> circle
|> ﬁlled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)
2.top-to-bottom
1.left-to-right

@theburningmonk
circle radius
|> ﬁlled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)

@theburningmonk
NASA orbiter crashed
because one engineer
accidentally used miles
instead of kilometres

@theburningmonk
you’re never too smart
to make mistakes

@theburningmonk
unit-of-measure

@theburningmonk
[<Measure>]
type Pence
e.g. 42<Pence>
153<Pence>
…

@theburningmonk
10<Meter> / 2<Second> = 5<Meter/Second>
10<Meter> * 2<Second> = 20<Meter Second>
10<Meter> + 10<Meter> = 20<Meter>
10<Meter> * 10 = 100<Meter>
10<Meter> * 10<Meter> = 100<Meter2>
10<Meter> + 2<Second> // error
10<Meter> + 2 // error

@theburningmonk
Homoiconicity
…homoiconicity is a property of some
programming languages in which the program
structure is similar to its syntax, and therefore
the program’s internal representation can be
inferred by reading the text’s layout…

@theburningmonk
code is data
data is code

@theburningmonk
(let [x 1]
(inc x))
see also http://bit.ly/1PpIrjS

@theburningmonk
(let [x 1]
(inc x))
=> 2

@theburningmonk
list (1 2 3)
vector [1 2 3]

@theburningmonk
(let [x 1]
(inc x))
list

@theburningmonk
(let [x 1]
(inc x))
symbol

@theburningmonk
(let [x 1]
(inc x))
vector

@theburningmonk
form :
code as data structure

@theburningmonk
code data
quote
eval

@theburningmonk
quote
(+ 1 2)
=> 3

@theburningmonk
quote
(+ 1 2)
=> 3
(quote (+ 1 2))
=> (+ 1 2)

@theburningmonk
quote
(+ 1 2)
=> 3
(quote (+ 1 2))
=> (+ 1 2)
‘(+ 1 2)
=> (+ 1 2)

@theburningmonk
eval
‘(+ 1 2)
=> (+ 1 2)
(eval ‘(+ 1 2))
=> 3

@theburningmonk
(defmacro assert-equals [actual expected]
‘(let [actual-val# ~actual]
(when-not (= actual-val# ~expected)
(throw
(AssertionError.
(str “FAIL in “ ‘~actual
“n expected: “ ‘~expected
“n actual: “ actual-val#))))))

@theburningmonk
(assert-equals (inc 1) 2) ; => nil
(assert-equals (inc 1) (+ 0 1))
; => AssertionError FAIL in (inc 1)
; expected: (+ 0 1)
; actual: 2

@theburningmonk
(assert-equals (inc 1) 2) ; => nil
; => AssertionError FAIL in (inc 1)
; expected: (+ 0 1)
; actual: 2
huh?? where? what? how?

@theburningmonk
(throw
(AssertionError.

@theburningmonk
(throw
(AssertionError.
‘(

@theburningmonk
expanded at
compile time

@theburningmonk
(macroexpand '(assert-equals (inc 1) (+ 0 1)))
; =>
; (let* [actual-value__16087__auto__ (inc 1)]
; (clojure.core/when-not
; (clojure.core/= actual-value__16087__auto__ (+ 0 1))
; (throw (java.lang.AssertionError.
; (clojure.core/str
; "FAIL in " (quote (inc 1))
; "nexpected: " (quote (+ 0 1))
; "n actual: " actual-value__16087__auto__)))))

@theburningmonk
ownership
see also http://bit.ly/1F6WBVD

@theburningmonk
memory safety
without GC

@theburningmonk
ZERO
runtime cost

@theburningmonk
safety + speed

@theburningmonk
fn foo() {
// v has ownership of the vector
let v = vec![1, 2, 3];
// mutable binding
let mut v2 = vec![];
}
// vector is deallocated at the
// end of scope,
// this happens deterministically

@theburningmonk
immutable by default

@theburningmonk
// take ownership
let v = vec![1, 2, 3];

@theburningmonk
// take ownership
let v = vec![1, 2, 3];
// moved ownership to v2
let v2 = v;

@theburningmonk
// take ownership
let v = vec![1, 2, 3];
// moved ownership to v2
let v2 = v;
println!("v[0] is {}", v[0]);
// error: use of moved value: `v`
// println!("v[0] is {}", v[0]);
// ^

@theburningmonk
fn take(v : Vec<i32>) {
// ownership of vector transferred
// to v in this scope
}

@theburningmonk
// take ownership
let v = vec![1, 2, 3];
// moved ownership
take(v);

@theburningmonk
// take ownership
let v = vec![1, 2, 3];
// moved ownership
take(v);
println!("v[0] is {}", v[0]);
// error: use of moved value: `v`
// println!("v[0] is {}", v[0]);
// ^

@theburningmonk

@theburningmonk
let me buy
your book

@theburningmonk
sure thing!

@theburningmonk
thanks

@theburningmonk
BURN!!!
>:D

@theburningmonk
but I
still need it..
:’(

@theburningmonk
borrowing

@theburningmonk
// note we're taking a reference,
// &Vec<i32>, instead of Vec<i32>
fn take(v : &Vec<i32>) {
// no need to deallocate the vector
// after we go out of scope here
}

@theburningmonk
// take ownership
let v = vec![1, 2, 3];
// notice we're passing a reference,
// &v, instead of v
take(&v); // borrow ownership
println!("v[0] is {}", v[0]);
// v[0] is 1

@theburningmonk
let me
borrow your
book

@theburningmonk
I’m done,
here you go

@theburningmonk
fn take(v : &Vec<i32>) {
v.push(5);
}
let v = vec![];
take(&v);
// cannot borrow immutable borrowed
// content `*v` as mutable
// v.push(5);
// ^

@theburningmonk
fn take(v : &mut Vec<i32>) {
v.push(5);
}
let mut v = vec![];
take(&mut v);
println!("v[0] is {}", v[0]);
// v[0] is 5

there are 2 rules to BORROWING

@theburningmonk
Rule 1.
the borrower’s scope must not
outlast the owner

@theburningmonk
Rule 2.
one of the following, but not both:
2.1 0 or more refs to a resource
2.2 exactly 1 mutable ref

@theburningmonk
data race
There is a ‘data race’ when two or more pointers
access the same memory location at the same
time, where at least one of them is writing, and
the operations are not synchronised.

@theburningmonk
data race
a. two or more pointers to the same resource
b. at least one is writing
c. operations are not synchronised

@theburningmonk
Data Race Conditions
a. two or more pointers to the same resource
b. at least one is writing
c. operations are not synchronised
Borrowing Rules
one of the following, but not both:
2.1 0 or more refs to a resource
2.2 exactly 1 mutable ref

@theburningmonk
Dependent Types
Uniqueness Types
Bit Syntax
Borrowed Pointers
Type Provider Pipes
Statically Resolved TP
Implicit Interface
Implementation
Signals
Macros
Unit-of-Measure
Actor Model

@theburningmonk
seen generics?
aka parametric polymorphism

@theburningmonk
List<T>
List<int> List<Cat>
List<string>

@theburningmonk
types that depend on
arbitrary values?

@theburningmonk
Vect n a
vector of n elements of type a

@theburningmonk
zipWith :
(a -> b -> c)
-> Vect n a
-> Vect n b
-> Vect n c

@theburningmonk
zipWith f [] [] = []
zipWith f (x :: xs) (y :: ys) =
f x y :: zipWith f xs ys

@theburningmonk
Type Driven Development

“Make illegal states unrepresentable”
- Yaron Minsky

@theburningmonk
10,000 hours to be
good at something
see also http://bit.ly/1KN7SLq

@theburningmonk
10,000 hours to reach
top of an ultra-
competitive field

@theburningmonk
the first 20 hours -
how to learn anything

@theburningmonk
Practice Time
Howgoodyouare

@theburningmonk
1.Deconstruct the skill

@theburningmonk
2.Learn enough to self-correct

@theburningmonk
3.Remove practice barriers

@theburningmonk
3.Remove practice barriers
4.Practice at least 20 hrs

@theburningmonk
learn a new paradigm
not a new syntax
see also http://bit.ly/1IzXVSo

“Programming languages
have a devious influence:
they shape our thinking
habits.”
- Edsger W. Dijkstra

@theburningmonk
logic programming

@theburningmonk
stack-oriented
programming

@theburningmonk
array programming

@theburningmonk
“A language that doesn't
affect the way you think
about programming, is not
worth knowing.”
- Alan Perlis

@theburningmonk
see also http://bit.ly/1IzXVSo

@theburningmonk
“Learning is an act of creation
itself, because something
happens in you that wasn't
there before.”
- Alan Kay

@theburningmonk
@theburningmonk
theburningmonk.com
github.com/theburningmonk

Implementing the Stable Marriage Problem in Erlang Using Message Passing

Recommended

Recommended

More Related Content

Similar to Implementing the Stable Marriage Problem in Erlang Using Message Passing

Similar to Implementing the Stable Marriage Problem in Erlang Using Message Passing (20)

More from Yan Cui

More from Yan Cui (20)

Recently uploaded

Recently uploaded (20)

Implementing the Stable Marriage Problem in Erlang Using Message Passing