2. Hi, my name is Yan Cui.

3. Jan 2010
Nov 2015
Apr 2016

4. F#in the
Real World

5. agenda

6. Domain Modelling
Infrastructure
Game Logic
Algorithms
DSLs

7. 1MILLION USERS
ACTIVE
DAILY

8. 250MILLION DAY
PER
REQUEST

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

10. we are polyglot
C#

11. why F#?

12. time to market

13. correctness

14. efficient

15. tame complexity

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

18. • 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

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

20. What the player’s new
average wager?

21. Should the player receive
collectables?

22. type Symbol = Standard of string
| Wild

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

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

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

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

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

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

29. closed hierarchy

30. no Nulls

31. make invalid states
unrepresentable

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

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

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

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

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

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

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

39. immutable by default

41. Recap

42. lightweight syntax
for types &
hierarchies

43. great for domain
modelling

44. make invalid states
unrepresentable

45. better correctness

46. order of magnitude
increase in productivity

49. player states are big

50. Stateless Server DatabaseClient

51. 1:1 read-write ratio

53. ServerClient
Session 1
Session 2

54. ServerClient Database

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

82. non-blocking I/O

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

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

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

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)
…
}
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

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

88. 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)
…
}

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)
…
}
type Message =
| Get of AsyncReplyChannel<GetResult>
| Put of State * Version * AsyncReplyChannel<PutResult>

91. 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)
…
}

92. 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)
…
}

93. 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)
}

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

95. 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)) -> …
}

96. 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()
}

97. 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()
}

98. 5x efficient
improvement

99. 60% latency drop

100. no databases

101. 90% cost saving

102. Recap

103. Agents
• no locks
• async message passing

104. Agents
• no locks
• async message passing
• self-contained
• easy to reason with

105. akka.Net
Orleans

106. Pattern Matching
• clear & concise

107. Async Workflow
• non-blocking I/O
• no callbacks

110. Caught a Gnome

111. EXP Item Gold
Quest Progress
Caught a Gnome

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

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

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

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

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

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

118. 100+ actions

120. triggered by different
abstraction layers

121. non-functional
requirements

123. message-broker
pattern

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

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

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

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

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

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

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

131. need lots of facts

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

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

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

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

136. C# interop

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

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

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

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

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

142. simple

143. flexible

144. saver

146. location bait
attraction rate
catch rate

147. auto-tuning
trapping stats

148. Monster
strength
speed
intelligence
Trap
strength
speed
technology

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

150. trial-and-error

151. “if you require constant
diligence you’re setting
everyone up for failure and hurt”
- Bryan Hunter

152. genetic algorithms

164. F#-powered DSLs.
Awesome!

167. wanna find
correlations?

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

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

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

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

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

173. Did any cache nodes’
CPU spike yesterday?

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

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

179. Amazing
F#
=

181. managed
key-value store

182. redundancy
9-9s guarantee

183. great performance

184. name your
throughput

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

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

188. GOAL
Disguise
complexity

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

190. Query
AST
Execution

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

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

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

197. < 50 LOC

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

201. intellisense over S3

202. compile time validation

203. no code generation

204. Domain Modelling
Infrastructure
Game Logic
Algorithms
DSLs

205. why F#?

206. time to market

207. correctness

208. efficient

209. tame complexity

210. @theburningmonk
theburningmonk.com
github.com/theburningmonk