Presentation at GibDev and StartUp Grid event.

1. https://github.com/patricknoir/reactive-platform

2. Patrick Di Loreto
CTO Addison Global (MoPlay)
https://github.com/patricknoir
http://patricknoir.blogspot.com
@patricknoir

6.  This architecture was designed for
system pre smart phone generation
 Need for customer acquisition
=> need for SCALABILITY
 Availability became more important
than Consistency (CAP theorem)

7. Response in a
timely manner
Responsive under
failure scenariosResponsive
under load
Enabler for
responsiveness

8. Monolithic Microservices

9.  Average system utilization across organization is 15% to 20%
 The ideal should be around 80%
20% of IT budgets go to operations
“We have created:
Large
Underutilized
Complex
Environments which are costly to maintain”

10. In => Out
In
Stateful
Out
Database
In => Out
In
Stateless
FaaS
Out

11.  Has a name
 Is a function from In to Out
 Service[-In, +Out](name: String, f: In => Out)

12.  Sometime services have to handle a state, so in order to elaborate a
computation: they need to know the current state and they will also
produce an output state.
type StatefulService[S, Input, Output] = Service[(S, Input), (S, Output)]
class Service[In, Out](name: String, f: In => Out)
type In = (S, Input) type Out = (S, Output)

13. type In = (S, I)
type Out = (S, O)
class Service[In, Out](name: String, f: In => Out)
f: (S, I) => (S, O)
f: I => S => (S, O) // Currying: I => (S => (S, O))
f: I => State[S, O] // S => (S, O) = State[S, O]
class StatefulService[S, I, O](name: String, f: I => State[S, O])

15. Instruction Time
Execute typical instruction 1/1,000,000,000 = 1 nanosec
Fetch from L1 cache memory 0.5 nanosec
Branch misprediction 5 nanosec
Fetch from L2 cache memory 7 nanosec
Mutex lock/unlock 25 nanosec
Fetch from main memory 100 nanosec
Send 2K bytes over 1Gbps network 20,000 nanosec (20µs)
Read 1MB sequentially from memory 250,000 nanosec (250µs)
Fetch from new disk location (seek) 8,000,000 (8ms)
Read 1MB sequentially from disk 20,000,000 nanosec (20ms)
Send packet US to Europe and back 150,000,000 nanosec (150ms)

16. Instruction Time
Execute typical instruction 1 s
Fetch from L1 cache memory 0.5 s
Branch misprediction 5 s
Fetch from L2 cache memory 7 s
Mutex lock/unlock ½ s
Fetch from main memory 1½ min
Send 2K bytes over 1Gbps network 5½ hours
Read 1MB sequentially from memory 3 days
Fetch from new disk location (seek) 13 weeks
Read 1MB sequentially from disk 6½ months
Send packet US to Europe and back 5 years

17. class Service[In, Out](name: String, f: In => Out)
type ReactiveService[I, O] = Service[I, Future[O]]
val f: I => Future[O]
type ReactiveStatefulService[S, I, E] = StatefulService[I, Future[State[S, E]]]
val f: I => Future[State[S, E]]
O = State[S, E]

18. f: (S, Command) => (S, Event)
val f: Command => State[S, Event]
type Cmd[S] = StatefulService[S, Command, Event]
f: (S, Event) => (S, Event)
val f: Event => State[S, Event]
type Evt[S] = StatefulService[S, Event, Event]
f: (S, Request) => (_, Response)
val f: Request => State[S, Response]
type Ask[S] = StatefulService[S, Request, Response]
(Wallet(id=123, balance=5), DepositCmd(walletId=123, amount=10)) => (Wallet(id=123, balance=15), DepositEvt(walletId=123, amount=10))
(Wallet(id=123, balance=15), SettleWinEvt(walletId=123, amount=10)) => (Wallet(id=123, balance=25), WinSettledEvt(walletId=123, amount=1
(Wallet(id=123, balance=15), GetBalanceReq(walletId=123)) => (_, GetBalanceResp(walletId=123, amount=25))

19. val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]]
val modifiers: Set[StatefulService[S, Command, Event]]val modifiers: Set[(S, Command) => (S, Event)]
trait Processor[S] {
type RootAggregate = S
}

20. trait View[S] {
type RootAggregate = S
}
val queries: Set[(S, Request) => Response]val queries: Set[StatefulService[S, Request, Response]]
val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]]

21. Processor Actor
Cmd[Debit(10)]
Evt[Credit(50)]
Evt[Debit(20)]
Evt[Credit(15)]
Evt[Debit(10)]
publish
process
View Actor
request
respond
Client App
notify
Actor
[View1]Actor
[View1]Actor
[View1]
PROCESSORS
(WRITE)
VIEWS
(READ)
(Wallet, Cmd) => (Wallet Evt)
(List[Wallet], Req) => Res
(List[Wallet], Evt) => List[Wallet]

23. Node 1 Node 2 Node 3

24.  Deployment CI/CD
 Monitoring
 Logging
 Tracing
 Security Auth/Autz

25. MessageFabric
APIGateway
Pub
Int
Ext
Computation Farm
RDS KV GRAPH HDFS/S3
Repository
Kubernetes

27. Node
/logs
POD PODPOD
Infra Kubernetes

29. Federated Prometheus

30.  Mobile growth changed customer behavior, new needs:
 SCALABILITY is a must to run your business
 Shift on priorities: AVAILABILITY over CONSISTENCY (CAP)
 Infrastructure complexity and operational costs increase with MicroService
Architecture vs Monolith
 Serverless is the way to go but are not yet good enough to manage State
 https://cloudstate.io/

31.  https://github.com/patricknoir/reactive-platform