Tour of language landscape (code.talks)

tour guide : Yan Cui @theburningmonk

Hi, my name is Yan Cui.

agenda

Type Provider Pipes

Statically Resolved TP Implicit Interface Implementation

Borrowed Pointers Dependent Types

Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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

Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

your app

your app

CSVCSVCSV

CSVCSVXML

your app

CSVCSVCSV

CSVCSVXML

some service

your app

CSVCSVCSV

CSVCSVXML

some service

DB

1. define DTO types2. I/O3. marshal data into DTO4. do useful work

compilerprovideexternal

data source typed info

type providers

intellisensetooltips

…

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

Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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



Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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> // error10<Meter> + 2 // error

Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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



Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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


Type Provider Pipes



Uniqueness Types

Bit SyntaxSignals

Macros

Unit-of-Measure

Actor Model

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];




// moved ownership to v2 let v2 = v;




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




// moved ownership take(v);




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




// 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 resourceb. at least one is writingc. operations are not synchronised



Data Race Conditionsa. two or more pointers to the same resourceb. at least one is writingc. operations are not synchronised

Borrowing Rulesone 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


Signals

Macros

Unit-of-Measure

Actor Model

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

Signals

Dependent Types

Uniqueness Types

Bit Syntax

Borrowed Pointers

Type Provider Pipes


Macros

Unit-of-Measure

Actor Model

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}




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




p1 : Signal Platformp1 = foldp (\{x, y} s -> {s | y <- cap <| s.y + 5*y}) defaultPlatform input

“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


Dependent Types

Uniqueness Types

Signals

Macros

Unit-of-Measure

actor model

actor

state mailbox

actors share nothing

actor

state mailboxactor

processingstorage

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

pre-emptive scheduling

makes you THINK

about distributed systems

messaging promotes failure thinking

Distributed

Computing

Network is reliableLatency is zero

Bandwidth is infiniteNetwork is secure

Topology doesn't changeThere is one administrator

Transport cost is zeroThe network is homogeneous

8 fallacies of distributed computing

supervise & restart

Type Provider Pipes



Uniqueness TypesOTP

Bit SyntaxSignals

Macros

Unit-of-Measure

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 skill2.Learn enough to self-correct



1.Deconstruct the skill2.Learn enough to self-correct3.Remove practice barriers



1.Deconstruct the skill2.Learn enough to self-correct3.Remove practice barriers4.Practice at least 20 hrs



learn a new paradigmnot 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 (code.talks)

Technology

Transcript of Tour of language landscape (code.talks)