F# in the real world (NDC)

F#in the Real World

agenda

Domain Modelling Infrastructure Game Logic Algorithms DSLs

1MILLION USERS ACTIVE DAILY

250MILLION DAY PER REQUEST

2MONTH TB P E R sec ops 25,000

why F#?

time to market

correctness

efficient

tame complexity

Collectables Wager Size Special Symbol Avg Wager Size Web Server call

• 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

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

What the player’s new average wager?

Should the player receive collectables?

type Symbol = Standard of string | Wild

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

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

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

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

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

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

closed hierarchy

no Nulls

“Make illegal states unrepresentable” - Yaron Minsky

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

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

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

immutable by default

Recap

lightweight syntax for types & hierarchies

great for domain modelling

make invalid states unrepresentable

better correctness

order of magnitude increase in productivity

player states are big

Stateless Server DatabaseClient

1:1 read-write ratio

ServerClient Session 1 Session 2

ServerClient Database

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

non-blocking I/O

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

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

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>

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>

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

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

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>

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

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

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

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

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

5x efficient improvement

60% latency drop

no databases

90% cost saving

akka.Net Orleans

Caught a Gnome

EXP Item Gold Quest Progress Caught a Gnome

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

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

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

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

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

100+ actions

triggered by different abstraction layers

non-functional requirements

message-broker pattern

Caught Gnome Trapping Queue Levelling Quests Achievements Analytics Partner Reporting

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

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

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

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

need lots of facts

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

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

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

C# interop

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

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

simple

flexible

saver

location bait attraction rate catch rate

auto-tuning trapping stats

Monster strength speed intelligence Trap strength speed technology

Monster strength speed intelligence Trap strength speed technology Catch Rate %

trial-and-error

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

genetic algorithms

F#-powered DSLs. Awesome!

wanna ﬁnd correlations?

wanna ﬁnd correlations? you can DIY it! ;-)

why was payment service slow last night?

Pain Driven Development

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

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

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

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

did any cache nodes’ CPU spike yesterday?

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

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

Amazing F# =

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

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

Recap

managed key-value store

redundancy 9-9s guarantee

great performance

name your throughput

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

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

GOAL Disguise complexity

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

Query AST Execution

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

SELECT * FROM GameScore Abstract Syntax Tree (AST) FParsec

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

< 50 LOC

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

intellisense over S3

compile time validation

no code generation

Domain Modelling Infrastructure Game Logic Algorithms DSLs

why F#?

time to market

correctness

efficient

tame complexity

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

@theburningmonk theburningmonk.com github.com/theburningmonk

F# in the real world (NDC)

Yan Cui

F# in the real world (NDC)