1. tour guide : Yan Cui @theburningmonk

2. Hi, my name is Yan Cui.

4. agenda

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

6. disclaimers

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

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

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

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

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

13. your
app

14. your
app
CSVCSVCSV
CSVCSVXML

15. your
app
CSVCSVCSV
CSVCSVXML
some
service

16. your
app
CSVCSVCSV
CSVCSVXML
some
service
DB

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

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

19. compiler
provideexternal
data source typed info

20. type providers

21. intellisense
tooltips
…

24. compile time validation

25. no code generation

26. 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

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

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

29. 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

30. 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…
2.top-to-bottom
1.left-to-right
how we read ENGLISH
see also http://bit.ly/1KN8cd0

31. how we read CODE
public void DoSomething(int x, int y)
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}
see also http://bit.ly/1KN8cd0

32. how we read CODE
public void DoSomething(int x, int y)
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}
2.bottom-to-top
1.right-to-left
see also http://bit.ly/1KN8cd0

33. 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…
2.top-to-bottom
1.left-to-right
how we read ENGLISH
public void DoSomething(int x, int y)
{
Foo(y,
Bar(x,
Zoo(Monkey())));
}
2.top-to-bottom
1.right-to-left
how we read CODE
see also http://bit.ly/1KN8cd0

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

35. |>

36. how we read CODE
let drawCircle x y radius =
radius |> circle
|> filled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)
see also http://bit.ly/1KN8cd0

37. 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-bottom
1.left-to-right
see also http://bit.ly/1KN8cd0

38. let drawCircle x y radius =
circle radius
|> filled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)
see also http://bit.ly/1KN8cd0

39. let drawCircle x y radius =
circle radius
|> filled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)
see also http://bit.ly/1KN8cd0

40. let drawCircle x y radius =
circle radius
|> filled (rgb 150 170 150)
|> alpha 0.5
|> move (x, y)
see also http://bit.ly/1KN8cd0

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

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

43. you’re never too smart
to make mistakes

44. unit-of-measure

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

46. 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

47. 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

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

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

51. def say_quack(duck):
duck.quack()

52. def say_quack(duck):
duck.quack()

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

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

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

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

57. Convenience
Safety

58. what if…

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

60. implicit
interface
implementation

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

62. func sayQuack(duck Duck) {
duck.Quack()
}
see also http://bit.ly/1ER5zVs

63. type Donald struct { }
func (d Donald) Quack()
{
fmt.Println(“quack quack!”)
}
see also http://bit.ly/1ER5zVs

64. type Bird struct { }
func (b Bird) Quack()
{
fmt.Println(“tweet tweet!”)
}
see also http://bit.ly/1ER5zVs

65. func main() {
donald := Donald{}
sayQuack(donald)
bird := Bird{}
sayQuack(bird)
}
see also http://bit.ly/1ER5zVs

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

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

68. type Dog struct { }
func (d Dog) Bark()
{
fmt.Println(“woof woof!”)
}
see also http://bit.ly/1ER5zVs

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

70. patterns are observed
after the fact
see also http://bit.ly/1ER5zVs

71. system building is also
a process of learning
and discovery
see also http://bit.ly/1ER5zVs

72. implementation
package
interface package
see also http://bit.ly/1ER5zVs

73. encourages precise
interface definitions
see also http://bit.ly/1ER5zVs

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

76. 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…

77. code is data
data is code

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

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

80. list (1 2 3)
vector [1 2 3]
see also http://bit.ly/1PpIrjS

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

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

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

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

85. form :
code as data structure
see also http://bit.ly/1PpIrjS

86. code data
quote
eval
see also http://bit.ly/1PpIrjS

87. quote
(+ 1 2)
=> 3
see also http://bit.ly/1PpIrjS

88. quote
(+ 1 2)
=> 3
(quote (+ 1 2))
=> (+ 1 2)
see also http://bit.ly/1PpIrjS

89. quote
(+ 1 2)
=> 3
(quote (+ 1 2))
=> (+ 1 2)
‘(+ 1 2)
=> (+ 1 2)
see also http://bit.ly/1PpIrjS

90. eval
‘(+ 1 2)
=> (+ 1 2)
(eval ‘(+ 1 2))
=> 3
see also http://bit.ly/1PpIrjS

91. macros

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

93. (assert-equals (inc 1) 2) ; => nil
(assert-equals (inc 1) (+ 0 1))
; => AssertionError FAIL in (inc 1)
; expected: (+ 0 1)
; actual: 2
see also http://bit.ly/1PpIrjS

94. (assert-equals (inc 1) 2) ; => nil
(assert-equals (inc 1) (+ 0 1))
; => AssertionError FAIL in (inc 1)
; expected: (+ 0 1)
; actual: 2
see also http://bit.ly/1PpIrjS

95. (assert-equals (inc 1) 2) ; => nil
(assert-equals (inc 1) (+ 0 1))
; => AssertionError FAIL in (inc 1)
; expected: (+ 0 1)
; actual: 2
see also http://bit.ly/1PpIrjS
huh?? where? what? how?

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

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

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

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

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

101. expanded at
compile time
see also http://bit.ly/1PpIrjS

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

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

105. GC is great

106. runtime cost

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

108. memory safety
without GC
see also http://bit.ly/1F6WBVD

109. ZERO
runtime cost
see also http://bit.ly/1F6WBVD

110. safety + speed
see also http://bit.ly/1F6WBVD

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

112. immutable by default
see also http://bit.ly/1F6WBVD

113. // take ownership
let v = vec![1, 2, 3];
see also http://bit.ly/1F6WBVD

114. // take ownership
let v = vec![1, 2, 3];
// moved ownership to v2
let v2 = v;
see also http://bit.ly/1F6WBVD

115. // 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]);
// ^
see also http://bit.ly/1F6WBVD

116. fn take(v : Vec<i32>) {
// ownership of vector transferred
// to v in this scope
}
see also http://bit.ly/1F6WBVD

117. // take ownership
let v = vec![1, 2, 3];
// moved ownership
take(v);
see also http://bit.ly/1F6WBVD

118. // 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]);
// ^
see also http://bit.ly/1F6WBVD

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

120. see also http://bit.ly/1F6WBVD
let me buy
your book

121. see also http://bit.ly/1F6WBVD
sure thing!

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

123. see also http://bit.ly/1F6WBVD
BURN!!!
>:D

124. see also http://bit.ly/1F6WBVD
but I
still need it..
:’(

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

126. // 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
}
see also http://bit.ly/1F6WBVD

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

128. see also http://bit.ly/1F6WBVD
let me
borrow your
book

129. see also http://bit.ly/1F6WBVD
sure thing!

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

131. see also http://bit.ly/1F6WBVD
I’m done,
here you go

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

133. see also http://bit.ly/1F6WBVD
immutable by default

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

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

136. borrowing
rules
see also http://bit.ly/1F6WBVD

137. see also http://bit.ly/1F6WBVD
Rule 1.
the borrower’s scope must not
outlast the owner

138. see also http://bit.ly/1F6WBVD
Rule 2.
one of the following, but not both:
2.1 0 or more refs to a resource
2.2 exactly 1 mutable ref

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

140. see also http://bit.ly/1F6WBVD
data race
a. two or more pointers to the same resource
b. at least one is writing
c. operations are not synchronised

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

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

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

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

146. seen generics?
aka parametric polymorphism

147. List<T>

148. List<T>
List<int> List<Cat>
List<string>

149. what if…

150. types that depend on
arbitrary values?

151. Vect n a
vector of n elements of type a

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

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

154. Type Driven Development

155. making invalid state
UNREPRESENTABLE

156. see also https://vimeo.com/123606435

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

159. Functional Reactive
Programming

160. Value over Time

161. Time
Value

162. Signals

163. Move Up
Move Down

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

165. function keyDown(event:KeyboardEvent):Void
{
if (currentGameState == Paused &&
event.keyCode == 32) {
setGameState(Playing);
} else if (event.keyCode == 38) {
arrowKeyUp = true;
}else if (event.keyCode == 40) {
arrowKeyDown = true;
}
}

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

167. function everyFrame(event:Event):Void {
if(currentGameState == Playing){
if (arrowKeyUp) {
platform1.y -= platformSpeed;
}
if (arrowKeyDown) {
platform1.y += platformSpeed;
}
if (platform1.y < 5)
platform1.y = 5;
if (platform1.y > 395)
platform1.y = 395;
}
}

168. function everyFrame(event:Event):Void {
if(currentGameState == Playing){
if (arrowKeyUp) {
platform1.y -= platformSpeed;
}
if (arrowKeyDown) {
platform1.y += platformSpeed;
}
if (platform1.y < 5)
platform1.y = 5;
if (platform1.y > 395)
platform1.y = 395;
}
}

169. source files
state changes

170. source files execution

171. source files execution

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

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

174. transformations
simplify problem
decomposition

175. Move Up
Move Down

176. 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

177. 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

178. 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

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

180. 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

181. 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

182. 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

183. 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

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

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

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

188. actor model

189. actor
state
mailbox

190. actors share nothing

191. actor
state
mailbox
actor

192. actor
state
mailbox
actor

193. processing
storage
communication

194. 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.

195. 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.

196. 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.

197. 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.

198. 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.

199. 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.

200. 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.

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

203. actors are cheap

204. no locks!

205. need state?
talk to the actor!

206. location
transparency

207. pre-emptive
scheduling

208. makes you
THINK
about
distributed systems

209. messaging promotes
failure thinking

210. Distributed
Computing

211. 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

212. supervise & restart

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

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

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

216. 10,000 hours to reach
top of an ultra-
competitive field
see also http://bit.ly/1KN7SLq

218. the first 20 hours -
how to learn anything
see also http://bit.ly/1KN7SLq

219. Practice Time
Howgoodyouare
see also http://bit.ly/1KN7SLq

220. 1.Deconstruct the skill
see also http://bit.ly/1KN7SLq

221. 1.Deconstruct the skill
2.Learn enough to self-correct
see also http://bit.ly/1KN7SLq

222. 1.Deconstruct the skill
2.Learn enough to self-correct
3.Remove practice barriers
see also http://bit.ly/1KN7SLq

223. 1.Deconstruct the skill
2.Learn enough to self-correct
3.Remove practice barriers
4.Practice at least 20 hrs
see also http://bit.ly/1KN7SLq

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

226. logic programming

227. stack-oriented
programming

228. array programming

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

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

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

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

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