tour of language landscape (katsconf)

tour guide : Yan Cui @theburningmonk

Hi, my name is Yan Cui.

1MILLION USERS

ACTIVEDAILY

250MILLION DAY

PERREQUEST

agenda

Type Provider Pipes

Statically Resolved TP Implicit Interface Implementation

Borrowed Pointers Dependent Types

Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

F#ClojureErlang

Go

RustElm Idris

disclaimers

“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 first 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

F#ClojureErlang

Go

RustElm Idris

your app

your app

CSVCSVCSV

CSVCSVXML

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

compilerprovideexternal

data source typed info

type providers

intellisense!tooltips!

…

compile time validation

no code generation

R

FunScript AzureAmazon S3

CSVSQLiteSQL Server

WSDL

WorldBank

RegexODATA IKVM

FacebookApiary

XAMLFreebaseHadoop

Oracle

Minesweeper

Don SymePowershell

JSON

Fizzbuzz

Mixin

RSS

MatlabDates

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)

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

http://bit.ly/1KN8cd0


2. top-to-bottom1.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


2. bottom-to-top

1.right-to-left




2. top-to-bottom

1.left-to-right

how we read ENGLISH


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 |> filled (rgb 150 170 150) |> alpha 0.5 |> move (x, y)



how we read CODE

let drawCircle x y radius = radius |> circle |> filled (rgb 150 170 150) |> alpha 0.5 |> move (x, y)

2. top-to-bottom1.left-to-right



let drawCircle x y radius = circle radius |> filled (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

unit-of-measure

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

F#ClojureErlang

Go

RustElm Idris

!?

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!

ConvenienceSafety

what if…

Convenience Safety

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

http://bit.ly/1H2fN9i

implicit interface!

implementation

type Duck interface { Quack() }

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

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!


tweet tweet!


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 packagesee also http://bit.ly/1ER5zVs


encourages precise interface definitions



F#ClojureErlang

Go

RustElm Idris

!?

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…

code is data data is code

(let [x 1] (inc x))

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

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



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

list



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)see also http://bit.ly/1PpIrjS


eval

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



macros

(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 (assert-equals (inc 1) (+ 0 1)) ; => AssertionError FAIL in (inc 1) ; expected: (+ 0 1) ; actual: 2


huh?? where? what? how?



(assert-equals (inc 1) (+ 0 1))





‘(


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


F#ClojureErlang

Go

RustElm Idris

GC is great

runtime cost

ownership

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

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



sure thing!



thanks



I’m done, here you go



thanks



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


F#ClojureErlang

Go

RustElm Idris

!!!

seen generics?aka parametric polymorphism

List<T>

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

List<string>

what if…

types that depend on arbitrary values?

Vect n avector 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

Type Driven Development

making invalid state UNREPRESENTABLE

see also https://vimeo.com/123606435

https://vimeo.com/123606435

F#ClojureErlang

Go

RustElm Idris

Functional Reactive Programming

Value over Time

Time

Value

Signals

Move Up

Move Down

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;! } }

source files

state changes

source files execution

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

Move Up

Move Down

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

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.arrowsUP { x=0, y=1 } DOWN { x=0, y=-1 } LEFT { x=-1, y=0 } RIGHT { x=1, y=0 }

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

see also http://oreil.ly/1i5CyhO

http://oreil.ly/1i5CyhO

“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

F#ClojureErlang

Go

RustElm Idris

!?

actor model

actor

state mailbox

actors share nothing

actor

state mailboxactor

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)].

actors are cheap

no locks!

need state?!talk to the actor!

location transparency

makes you !THINK !

about !distributed systems

messaging promotes failure thinking

Distributed

Computing

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

supervise & restart

F#ClojureErlang

Go

RustElm Idris

10,000 hours to be good at something

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

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

How

goo

d yo

u ar

e



1.Deconstruct the skill



1.Deconstruct the skill!2.Learn enough to self-correct



1.Deconstruct the skill!2.Learn enough to self-correct!3.Remove practice barriers



1.Deconstruct the skill!2.Learn enough to self-correct!3.Remove practice barriers!4.Practice at least 20 hrs



learn a new paradigm!not a new syntax

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

http://bit.ly/1IzXVSo

logic programming

stack-oriented programming

array programming

“A language that doesn't affect the way you think

about programming, is not worth knowing.”

- Alan Perlis

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

http://bit.ly/1IzXVSo

“Learning is an act of creation itself, because something happens in you that wasn't

there before.”

- Alan Kay

@theburningmonktheburningmonk.comgithub.com/theburningmonk

tour of language landscape (katsconf)

Software