The document discusses several high performance architectural patterns: - Event sourcing, which models data as a sequence of immutable events and allows reconstructing past states; - CQRS, which separates read and write operations into different models for improved performance; - LMAX Disruptor, a high performance inter-thread messaging library that enables lock-free, wait-free, bounded queues for passing data between threads. When combined, these patterns enable building highly scalable and available systems by allowing separate scaling of read and write workloads, easy evolution of data models, and maximizing throughput with disruption-free concurrency.

1. ● Event Sourcing
● CQRS
● LMAX Disruptor
High Performance Bulletproof Architecture

2. Event Sourcing

3. Event Sourcing (Pros)
● ONLY model that never loses data
o You never know how you'd use your data tomorrow
o You can add/remove features like there were out there all
this time
o Perfect for Big Data
● Events (facts) are never ever removed or updated
o Easily proves your audit log is correct
o Protects from superuser attack
● Business asks for it!

4. Cart
Items
Shipping
Information
Traditional Data Structure (DTO or a STATE!)

5. Cart
Created
Event Stream
2 Items
Added
1 Item
Removed
Shipping
Information
Added
● Events are FACTS! They are never deleted from the system
● Events are what creates the current state
● Depending on your business requirement you might have different
view of the same event stream (different states)
● Any possible data can be projected from event stream

6. Event Sourcing (Pros) II
● Best traceability and debuggability (time machine)
● Move to the past and get the state as it was
● Easily evolve domain
● No more mapping objects to tables
● Smoke testing
● Super easy to test
● Scale Easily
● High Availability
● Cost!

7. Current State - Aggregates (Domain Model)

8. Typical test (any behaviour can be tested like this!)

9. Event Sourcing (Cons)
● Weird at first
● Event / Command confusion
● Side effects on event reply
● You either do it all
or not doing at all

10. Java 8 Stream (uppercase sort and print)

11. Java 8 Stream (count all strings starting with “b”)

12. Streams in Reactive Programming
In Rx every data source is a Stream!

13. Streams in Reactive Programming

14. Streams in Reactive Programming

15. CQRS

16. Tipical architecture
UI
BUSINESS
LOGIC Storage
Write
Read

17. Tipical architecture

18. CQRS (Pros)
● PERFORMANCE!!!
o Command side is optimized for writes
 keep the current state in memory
 you only really need ACTUAL CONSISTENCY in write side
o Query side is optimized for reads
 Takes advantage of EVENTUAL CONSISTENCY
● Naturally easy to scale linearly
o Scale only what you need
● Polyglot persistence
o Forget SQL queries, forget joins, forget mapping objects to tables
● Efficiency
o Simple commodity hardware might take a huge load

19. CQRS (Cons)
● Makes you choose between command or query
o You either write or read (but you can workaround it)

20. Questions?

21. Disruptor by LMAX

22. Why Concurrency is HARD?

23. CPU structure

24. False sharing (hidden contention)

25. Java Concurrency
● Locks
● Queues
● Synchronization
● Contention
and other scary things

26. Disruptor Concurrency
● Non
● BLOCKING
● Contention Free
● CONCURRENCY !!!

27. Disruptor Structure

28. LMAX Architecture

29. Disruptor (Pros)
● Performance of course
● Holly BATCHING!!!
● Mechanical Sympathy
● Optionally GC Free
● Prevents False Sharing
● Easy to compose dependant consumers (concurrency)
● Synchronization free code in consumers
● Data Structure (not a frickin framework!!!)
● Fits werry well with CQRS and ES

30. Disruptor (Pros)
● Thread affinity (for more performance/throughput)
● Different strategies for Consumers (busy spin, sleep)
● Single/Multiple producer strategy

31. Disruptor (Cons)
● Weird at first (again)
● Different approach to concurrency
● Hard to understand how the performance is achieved

32. Avoid useless processing (disrupter can batch)

33. Disruptor Implementation (simplified)

34. Why power of 2?

35. lets look at some assembly code

36. Assembly of publish(..) the memory barrier

37. No locks at all ( Atomic.lazySet )

38. Ring Buffer customizations
● Producer strategies
○ Single producer
○ Multiple producer
● Wait Strategies
○ Sleeping Wait
○ Yielding Wait
○ Busy Spin

39. ES + CQRS + DISRUPTOR + EVENTSTORE
The (almost) perfect architecture

40. Command
Bus
Command side
commands *
(1) Replication
(2) Journalling
(3) Unmarshalling
Command Business
Logic [1,2,3]
COMMAND DOMAIN MODEL
events *
Command Store

41. Event
Bus
Query side
events * (1)
(2) Journalling
(3) Unmarshalling
Query Business Logic
[1,2]
QUERY DOMAIN MODEL
(1) Replication
Denormalized Data
Storage
queries * (n)
*
Event Store

42. With pleasure develop colleagues!!!
The END!

43. Links for Event Sourcing and CQRS
● First video you need to watch about ES and CQRS
https://www.youtube.com/watch?v=JHGkaShoyNs
● a good webinar about microservice architecture and CQRS
http://plainoldobjects.com/presentations/building-and-deploying-microservices-with-event-sourcing-
cqrs-and-docker/
● eventstore is a database designed by Greg himself (the guy in first video), he also puts a lot of
information about ES and CQRS in docs http://docs.geteventstore.com/introduction/event-
sourcing-basics/
● practical video showcase (8 hours but worth it) http://www.viddler.com/v/dc528842

44. Links for LMAX Disruptor
● https://www.youtube.com/watch?v=DCdGlxBbKU4
● https://www.youtube.com/watch?v=KrWxle6U10M
● https://www.youtube.com/watch?v=IsGBA9KEtTM
● http://martinfowler.com/articles/lmax.html
● https://www.youtube.com/watch?v=eTeWxZvlCZ8

45. And some stuff about high performance Java code
● https://www.youtube.com/watch?v=NEG8tMn36VQ
● https://www.youtube.com/watch?v=t49bfPLp0B0
● http://www.slideshare.net/PeterLawrey/writing-and-testing-high-frequency-trading-engines-in-java
● https://www.youtube.com/watch?v=ih-IZHpxFkY