1. F#in the
Real World

3. agenda

4. Domain Modelling
Infrastructure
Game Logic
Algorithms
DSLs

5. 1MILLION USERS
ACTIVE
DAILY

6. 250MILLION DAY
PER
REQUEST

7. 2MONTH
TB
P E R
sec
ops
25,000

8. C#

9. why F#?

10. time to market

11. correctness

12. efficient

13. tame complexity

15. Collectables
Wager Size
Special Symbol
Avg Wager Size
Web Server call

16. • Line Win
– X number of matching symbols on adjacent columns
– Positions have to be a ‘line’
– Wild symbols substitute for other symbols
• Scatter Win
– X number of matching symbols anywhere
– Triggers bonus game

17. What symbols should land?
Any special symbol wins?
Did the player win anything?

18. What the player’s new
average wager?

19. Should the player receive
collectables?

20. type Symbol = Standard of string
| Wild

21. type Symbol = Standard of string
| Wild
e.g. Standard “hat”
Standard “shoe”
Standard “bonus”
…

22. type Symbol = Standard of string
| Wild
i.e. Wild

23. type Win = LineWin of int * Symbol * int
| ScatterWin of Symbol * int

24. type Win = LineWin of int * Symbol * int
| ScatterWin of Symbol * int
e.g. LineWin (5, Standard “shoe”, 4)

25. type Win = LineWin of int * Symbol * int
| ScatterWin of Symbol * int
e.g. ScatterWin (Standard “bonus”, 3)

26. type LineNum = int
type Count = int
type Win = LineWin of LineNum * Symbol * Count
| ScatterWin of Symbol * Count

27. closed hierarchy

28. no Nulls

29. “Make illegal states unrepresentable”
- Yaron Minsky

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

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

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

33. type Wager = int64<Pence>
type Multiplier = int
type Payout = Coins of Wager
| MultipliedCoins of Multiplier * Wager
| Multi of Payout list
| BonusGame

34. type Wager = int64<Pence>
type Multiplier = int
type Payout = Coins of Wager
| MultipliedCoins of Multiplier * Wager
| Multi of Payout list
| BonusGame

35. type Wager = int64<Pence>
type Multiplier = int
type Payout = Coins of Wager
| MultipliedCoins of Multiplier * Wager
| Multi of Payout list
| BonusGame

36. type State =
{
AvgWager : Wager
SpecialSymbol : Symbol
Collectables : Map<Collectable, Count>
}

37. immutable by default

39. Recap

40. lightweight syntax
for types &
hierarchies

41. great for domain
modelling

42. make invalid states
unrepresentable

43. better correctness

44. order of magnitude
increase in productivity

47. player states are big

48. Stateless Server DatabaseClient

49. 1:1 read-write ratio

51. ServerClient
Session 1
Session 2

52. ServerClient Database

53. Elastic Load Balancer
S3
Auto scaling Group
Server A Server B
...
EC2
CloudFront
Stateful Server

54. Stateful Server
Game Logic
Stateless Middle-tier
Infrastructure
logging
circuit
breaker
perf
tracking
retry …

55. Stateful Server
Game Logic
Stateless Middle-tier
Infrastructure
logging
circuit
breaker
perf
tracking
retry …

56. Stateful Server
Game Logic
Stateful Middle-tier
Infrastructure
logging
circuit
breaker
perf
tracking
retry …

57. The Actor Model
An actor is the fundamental unit of computation
which embodies the 3 things
• Processing
• Storage
• Communication
that are essential to computation.
-Carl Hewitt*
* http://bit.ly/HoNHbG

58. The Actor Model
• Everything is an actor
• An actor has a mailbox
• When an actor receives a message it can:
– Create new actors
– Send messages to actors
– Designate how to handle the next message

59. Stateful Server
• Gatekeeper
– Manages the local list of active workers
– Spawns new workers
• Worker
– Manages the states for a player
– Optimistic locking
– Persist state after period of inactivity

60. Stateful Server
Game Server
Player A
Player B
S3
Worker C
Worker B
Gatekeeper
RequestHandlers
Asynchronous

61. Stateful Server
Game Server
Worker C
Worker B
Gatekeeper
Worker A
ok
RequestHandlers
Player A
Player B
Asynchronous
S3

62. Stateful Server
Game Server
S3
Worker C
Worker B
Gatekeeper
Worker A
RequestHandlers
Player A
Player B
Asynchronous

63. Stateful Server
Game Server
S3
Worker C
Gatekeeper
Worker A
RequestHandlers
Player A
Player B
Asynchronous

64. Stateful Server
Game Server
Worker C
Worker A
Gatekeeper
error
RequestHandlers
Player A
Player B
S3
Asynchronous

65. type Agent<‘T> = MailboxProcessor<‘T>

66. type Agent<‘T> = MailboxProcessor<‘T>
type Message =
| Get of AsyncReplyChannel<…>
| Put of State * Version * AsyncReplyChannel<…>

67. type Agent<‘T> = MailboxProcessor<‘T>
type Message =
| Get of AsyncReplyChannel<…>
| Put of State * Version * AsyncReplyChannel<…>

68. type Result<‘T> =
| Success of ’T
| Failure of Exception

69. type Result<‘T> =
| Success of ’T
| Failure of Exception
type GetResult = Result<State * Version>
type PutResult = Result<unit>

70. type Agent<‘T> = MailboxProcessor<‘T>
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

71. type Agent<‘T> = MailboxProcessor<‘T>
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

72. type Worker (playerId) =
let agent = Agent<Message>.Start(fun inbox ->
let state = getCurrentState playerId
let rec workingState (state, version) =
async { … }
and closedState () =
async { … }
workingState (state, 1))

73. type Worker (playerId) =
let agent = Agent<Message>.Start(fun inbox ->
let state = getCurrentState playerId
let rec workingState (state, version) =
async { … }
and closedState () =
async { … }
workingState (state, 1))

74. type Worker (playerId) =
let agent = Agent<Message>.Start(fun inbox ->
let state = getCurrentState playerId
let rec workingState (state, version) =
async { … }
and closedState () =
async { … }
workingState (state, 1))

75. type Worker (playerId) =
let agent = Agent<Message>.Start(fun inbox ->
let state = getCurrentState playerId
let rec workingState (state, version) =
async { … }
and closedState () =
async { … }
workingState (state, 1))

76. type Worker (playerId) =
let agent = Agent<Message>.Start(fun inbox ->
let state = getCurrentState playerId
let rec workingState (state, version) =
async { … }
and closedState () =
async { … }
workingState (state, 1))

77. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None ->
do! persist state
return! closedState()
…
}

78. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None ->
do! persist state
return! closedState()
…
}

79. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None ->
do! persist state
return! closedState()
…
}

80. non-blocking I/O

81. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None ->
do! persist state
return! closedState()
…
}

82. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None ->
do! persist state
return! closedState()
…
}

83. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Get(reply)) ->
reply.Reply <| Success(state, version)
return! workingState(state, version)
…
}

84. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Get(reply)) ->
reply.Reply <| Success(state, version)
return! workingState(state, version)
…
}
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

85. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Get(reply)) ->
reply.Reply <| Success(state, version)
return! workingState(state, version)
…
}
type GetResult = Result<State * Version>
type PutResult = Result<unit>

86. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Get(reply)) ->
reply.Reply <| Success(state, version)
return! workingState(state, version)
…
}

87. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(newState, v, reply)) when version = v ->
reply.Reply <| Success()
return! workingState(newState, version+1)
…
}

88. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(newState, v, reply)) when version = v ->
reply.Reply <| Success()
return! workingState(newState, version+1)
…
}
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

89. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(newState, v, reply)) when version = v ->
reply.Reply <| Success()
return! workingState(newState, version+1)
…
}

90. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(newState, v, reply)) when version = v ->
reply.Reply <| Success()
return! workingState(newState, version+1)
…
}

91. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(_, v, reply)) ->
reply.Reply <| Failure(VersionMismatch(version, v))
return! workingState(state, version)
}

92. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
…
| Some(Put(_, v, reply)) ->
reply.Reply <| Failure(VersionMismatch(version, v))
return! workingState(state, version)
} type Result<‘T> =
| Success of ’T
| Failure of Exception

93. let rec workingState (state, version) =
async {
let! msg = inbox.TryReceive(60000)
match msg with
| None -> …
| Some(Get(reply)) -> …
| Some(Put(newState, v, reply)) when version = v -> …
| Some(Put(_, v, reply)) -> …
}

94. and closedState () =
async {
let! msg = inbox.Receive()
match msg with
| Get(reply) ->
reply.Reply <| Failure(WorkerStopped)
return! closedState()
| Put(_, _, reply) ->
reply.Reply <| Failure(WorkerStopped)
return! closedState()
}

95. and closedState () =
async {
let! msg = inbox.Receive()
match msg with
| Get(reply) ->
reply.Reply <| Failure(WorkerStopped)
return! closedState()
| Put(_, _, reply) ->
reply.Reply <| Failure(WorkerStopped)
return! closedState()
}

96. 5x efficient
improvement

97. 60% latency drop

98. no databases

99. 90% cost saving

101. akka.Net
Orleans

104. Caught a Gnome

105. EXP Item Gold
Quest Progress
Caught a Gnome

106. Level Up
Quest Progress
EXP Item Gold
Caught a Gnome
Quest Complete

107. Level Up
Quest Progress
EXP Item Gold
Caught a Gnome
New Quest
Quest Complete

108. Quest Progress
EXP Item Gold
Caught a Gnome
Quest Complete
New Quest
Level Up

109. Quest Progress
New Quest
Achievement
Progress
EXP Item Gold
Quest Complete
Level Up
Caught a Gnome

110. Level Up
Quest Progress
EXP Item Gold
Caught a Gnome
Quest Complete
New Quest
Achievement
Progress
Achievement
Complete

111. Level Up
Quest Progress
EXP Item Gold
Caught a Gnome
Quest Complete
New Quest
Achievement
Progress
Achievement
Complete

112. 100+ actions

114. triggered by different
abstraction layers

115. non-functional
requirements

117. message-broker
pattern

118. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting

119. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
Ignore
Process
Process
Process
Process
Ignore

120. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
EXP
Item
Gold

121. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
EXP
Item
Gold

122. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
EXP
Item
Gold
Process
Ignore
Ignore
Ignore
Process
Ignore

123. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
EXP
Item
Gold
Level Up

124. Caught Gnome Trapping
Queue
Levelling
Quests
Achievements
Analytics
Partner
Reporting
EXP
Item
Gold
Level Up

125. need lots of facts

126. type Fact =
| GotExp of Exp
| GotGold of Gold
| GotItem of Item * Count
| CaughtMonster of Monster * Bait * Location
| LevelUp of OldLevel * NewLevel
…

127. type Reward =
| GotExp of Exp
| GotGold of Gold
| GotItem of Item * Count
type StateChange =
| LevelUp of OldLevel * NewLevel
…

128. type Fact =
| StateChange of StateChange
| Reward of Reward
| Trapping of Trapping
| Fishing of Fishing
…

129. let process fact =
match fact with
| StateChange(stateChange) -> …
| Reward(reward) -> …
| Trapping(trapping) -> …
…

130. C# interop

131. …
var fact = Fact.NewStateChange(
StateChange.NewLevelUp(oldLvl, newLvl));
…

132. type IFact = interface end
type Reward =
| GotExp of Exp
| GotGold of Gold
| GotItem of Item * Count
interface IFact

133. type IFact = interface end
type Reward =
| GotExp of Exp
| GotGold of Gold
| GotItem of Item * Count
interface IFact

134. let process (fact : IFact) =
match fact with
| :? StateChange as stateChange -> …
| :? Reward as reward -> …
| :? Trapping as trapping -> …
…
| _ -> raise <| NotSupportedFact fact

135. let process (fact : IFact) =
match fact with
| :? StateChange as stateChange -> …
| :? Reward as reward -> …
| :? Trapping as trapping -> …
…
| _ -> raise <| NotSupportedFact fact

136. let process (fact : IFact) =
match fact with
| :? StateChange as stateChange -> …
| :? Reward as reward -> …
| :? Trapping as trapping -> …
…
| _ -> raise <| NotSupportedFact fact

137. simple

138. flexible

139. saver

141. location bait
attraction rate
catch rate

142. auto-tuning
trapping stats

143. Monster
strength
speed
intelligence
Trap
strength
speed
technology

144. Monster
strength
speed
intelligence
Trap
strength
speed
technology
Catch Rate %

145. trial-and-error

147. “…if you require constant diligence you’re
setting everyone up for failure and hurt”

149. genetic algorithms

161. F#-powered DSLs.
Awesome!

164. wanna find
correlations?

165. wanna find
correlations?
you can DIY it!
;-)

166. why was
payment service
slow last night?

169. Pain Driven Development

170. Amazon
.CloudWatch
.Selector
github.com/fsprojects/Amazon.CloudWatch.Selector

171. Find metrics whose 5
min average exceeded
1 second during last
12 hours

172. cloudWatch.Select(
unitIs “milliseconds” +
average (>) 1000.0
@ last 12 hours
|> intervalOf 5 minutes)

173. cloudWatch.Select(“
unitIs ‘milliseconds’ and
average > 1000.0
duringLast 12 hours
at intervalOf 5 minutes”)

174. did any cache
nodes’ CPU spike
yesterday?

175. cloudWatch.Select(
namespaceLike “elasticache” +
nameLike “cpu” +
max (>) 80.0
@ last 24 hours
|> intervalOf 15 minutes)

176. cloudWatch.Select(
namespaceLike “elasticache” +
nameLike “cpu” +
max (>) 80.0
@ last 24 hours
|> intervalOf 15 minutes)
regex support

182. Amazing
F#
=

183. usable from anywhere you
can run F# code
e.g. F# REPL, executable, ..
Internal DSL

184. useful for building tools
e.g. CLI, …
External DSL

186. Recap

190. managed
key-value store

191. redundancy
9-9s guarantee

192. great performance

193. name your
throughput

197. select GameTitle, UserId, TopScore
from GameScores
where GameTitle = “Starship X”
and TopScore >= 1000
order desc
limit 3
with (NoConsistentRead, Index(GameTitleIndex, true))

198. DynamoDB.SQL
github.com/fsprojects/DynamoDb.SQL

199. GOAL
Disguise
complexity

200. GOAL
SELECT UserId, TopScore
FROM GameScore
WHERE GameTitle CONTAINS “Zelda”
ORDER DESC
LIMIT 3
WITH (NoConsistentRead)

201. Query
AST
Execution

202. F# & FParsec*
*www.quanttec.com/fparsec
External DSL
via

204. SELECT * FROM GameScore
Abstract Syntax Tree (AST)
FParsec

206. select GameTitle, UserId, TopScore
from GameScores
where GameTitle = “Starship X”
and TopScore >= 1000
order desc
limit 3
with (NoConsistentRead, Index(GameTitleIndex, true))

208. < 50 LOC

209. S3 Provider
github.com/fsprojects/S3Provider
F# type provider for Amazon S3

212. intellisense over S3

213. compile time validation

214. no code generation

215. Domain Modelling
Infrastructure
Game Logic
Algorithms
DSLs

216. why F#?

217. time to market

218. correctness

219. efficient

220. tame complexity

221. also on the Functional Track this year :-)
Today
REPL
Driven Dev
FP Lab Hour
Tomorrow
Parser
Combinators
FP Lab Hour

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