Tour of language landscape (code.talks)

tour guide : Yan Cui @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

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

“One of the most disastrous
thing we can learn is the ﬁrst
programming language, even
if it's a good programming
language.”
- Alan Kay

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

“We cannot solve our
problems with the same
thinking we used when
we created them.”
- Albert Einstein

your
app
CSVCSVCSV
CSVCSVXML
some
service

your
app
CSVCSVCSV
CSVCSVXML
some
service
DB

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

compiler
provideexternal
data source typed info

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

“…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)

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

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

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

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

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

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

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

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

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

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

you’re never too smart
to make mistakes

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

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

Duck Typing
If it looks like a duck
and quacks like a
duck, it's a duck

def say_quack(duck):
duck.quack()

class Duck:
def quack(self):
print("quack quack!”)

class Duck:
def quack(self):
print("quack quack!”)
duck = Duck()
say_quack(duck)
> quack quack!

class Bird:
def quack(self):
print(“tweet tweet!”)

class Bird:
def quack(self):
print(“tweet tweet!”)
bird = Bird()
say_quack(bird)
> tweet tweet!

Convenience Safety
see also http://bit.ly/1H2fN9i

implicit
interface
implementation

type Duck interface
{
Quack()
}
see also http://bit.ly/1ER5zVs

func sayQuack(duck Duck) {
duck.Quack()
}

type Donald struct { }
func (d Donald) Quack()
{
fmt.Println(“quack quack!”)
}

type Bird struct { }
func (b Bird) Quack()
{
fmt.Println(“tweet tweet!”)
}

func main() {
donald := Donald{}
sayQuack(donald)
bird := Bird{}
sayQuack(bird)
}

quack quack!
func main() {
donald := Donald{}
sayQuack(donald)
bird := Bird{}
sayQuack(bird)
}

tweet tweet!
func main() {
donald := Donald{}
sayQuack(donald)
bird := Bird{}
sayQuack(bird)
}

type Dog struct { }
func (d Dog) Bark()
{
fmt.Println(“woof woof!”)
}

func main() {
dog := Dog{}
sayQuack(dog)
}
main.go:40: cannot use dog (type Dog) as type
Duck in argument to sayQuack:
Dog does not implement Duck (missing
Quack method)

patterns are observed
after the fact

system building is also
a process of learning
and discovery

implementation
package
interface package

encourages precise
interface deﬁnitions

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…

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

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

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

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

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

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

form :
code as data structure

code data
quote
eval

quote
(+ 1 2)
=> 3

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

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

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

(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#))))))

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

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

(throw
(AssertionError.

(throw
(AssertionError.
‘(

expanded at
compile time

(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__)))))

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

memory safety
without GC

ZERO
runtime cost

safety + speed

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

immutable by default

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

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

// 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]);
// ^

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

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

// 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]);
// ^

let me buy
your book

sure thing!

thanks

BURN!!!
>:D

but I
still need it..
:’(

borrowing

// 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
}

// 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

let me
borrow your
book

I’m done,
here you go

immutable by default

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

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

borrowing
rules

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

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

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.

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

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

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

seen generics?
aka parametric polymorphism

List<T>
List<int> List<Cat>
List<string>

types that depend on
arbitrary values?

Vect n a
vector of n elements of type a

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

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

making invalid state
UNREPRESENTABLE

see also https://vimeo.com/123606435

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

Functional Reactive
Programming

private var arrowKeyUp:Bool;
private var arrowKeyDown:Bool;
private var platform1:Platform;
private var platform2:Platform;
private var ball:Ball;

function keyUp(event:KeyboardEvent):Void {
if (event.keyCode == 38) {
arrowKeyUp = false;
} else if (event.keyCode == 40) {
arrowKeyDown = false;
}
}

mental model
input state new state behaviour
{ x; y } { x; y-speed }
{ x; y } { x; y+speed }
timer { x; y } { x; y } draw platform
… … … …

transformation
let y = f(x)
Imperative Functional
x.f()
mutation

transformations
simplify problem
decomposition

type alias Platform = {x:Int, y:Int}
defaultPlatform = {x=5, y=0}
delta = Time.fps 20
input = Signal.sampleOn delta Keyboard.arrows
cap x = max 5 <| min x 395
p1 : Signal Platform
p1 = foldp ({x, y} s -> {s | y <- cap <| s.y + 5*y})
defaultPlatform
input

Keyboard.arrows
UP { x=0, y=1 }
DOWN { x=0, y=-1 }
LEFT { x=-1, y=0 }
RIGHT { x=1, y=0 }

“I thought of objects being like
biological cells and/or
individual computers on a
network, only able to
communicate with messages.”
- Alan Kay

“OOP to me means only
messaging, local retention and
protection and hiding of state-
process, and extreme late-
binding of all things.”
- Alan Kay

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

processing
storage
communication

loop (Map) ->
receive
{get, Key, Pid} ->
Pid ! maps:get(Key, Map, not_found),
loop(Map);
{set, Key, Value} ->
loop(maps:put(Key, Value, Map))
end.

client (N, Pid) ->
Pid ! {set, N, N},
Pid ! {get, N, self()},
receive
not_found -> io:format(“~p :-(~n”, [N]);
N -> io:format(“~p :-)~n”, [N]);
_ -> io:format(“~p …~n”, [N])
end.

start(N) ->
Kvs = spawn(mod, loop, [#{}]),
[spawn(mod, client, [X, Kvs])
|| X <- lists:seq(1,N)].

need state?
talk to the actor!

makes you
THINK
about
distributed systems

messaging promotes
failure thinking

Network is reliable
Latency is zero
Bandwidth is infinite
Network is secure
Topology doesn't change
There is one administrator
Transport cost is zero
The network is homogeneous
8 fallacies of distributed computing

Type Provider Pipes
Implicit Interface
Implementation
Borrowed Pointers Dependent Types
Uniqueness TypesOTP
Bit Syntax
Signals
Macros
Unit-of-Measure

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

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

the first 20 hours -
how to learn anything

Practice Time
Howgoodyouare

1.Deconstruct the skill

2.Learn enough to self-correct

3.Remove practice barriers

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

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

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

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

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

@theburningmonk
theburningmonk.com
github.com/theburningmonk

Tour of language landscape (code.talks)

More Related Content

Similar to Tour of language landscape (code.talks) (20)

More from Yan Cui (20)

Recently uploaded (20)

Tour of language landscape (code.talks)