This document provides an overview of common software complexity issues and techniques that may help address them. It discusses issues like platform coupling and model ambiguity. It then describes 9 levels of techniques to decouple systems in an iterative way, including using event-driven architectures with de-normalized models, event stores, projections, APIs, and task-based UIs. It emphasizes the importance of continuous improvement, separating concerns, and adapting approaches based on business needs rather than technical preferences.

2. ABOUT ME
Developer @Adform – www.adform.com
https://lt.linkedin.com/in/raimondastijunaitis

3. WHAT THIS TALK IS NOT ABOUT
„Best Practices“
Deep dive into DDD, CQRS, Event Sourcing
Refactoring

4. WHAT IT IS ABOUT
Common (for some of us) software complexity
issues
Techniques that might help and were tried in
production
Continuous/Iterative decoupling

5. THE DUNGEON

6. ISSUES
Platform coupling
Model ambiguity
Growing learning curve

7. SCREW MUSHROOMS, GIVE ME GUNS

8. LEVEL 1 – DE-NORMALIZED MODELS
Specifically designed for quering
Built asynchronously
Messages dispatched from legacy code

9. SALVATION WITH EVENTS
Send Message

10. DE-NORMALIZED MODEL
Project
Ad
Deactivated
Ad
Updated
Ad
Created

11. OTHER POSSIBLE WAYS
SQL Server replications
Depends on consumer count and your system load
Replicates the same relational structure
SQL Server Message Broker
Queue based message publishing
Custom data messages
Re-use write-model + caching
Be careful with excessive indexing – this might harm your
writes
Cache rebuild and invalidation issues

12. READ MODELS
NEW WEAPON UNLOCKED

13. MEET NEW ENEMIES (FRIENDS?)
Eventual consistency
Consistency is a myth
Talk with your business people
Tradeoffs
Idempotency and ordering
Event versions
Read-model versions
What about 1 thread?
Desynchronization
Create sync tools

14. LEVEL 2 – SYNERGY BETWEEN SYSTEMS
Avoid adding new features into monolith
Avoid big-bang reworks
Use strategic design to handle complexity

15. REWORK != REFACTORING
Two systems side-by-
side works together
Iterative functionality
migration
In-syncOld
System
New
System
Sync

16. TIP: Sometimes it is
better to start over
TIP: Having backup
strategy keeps your
blood pressure low
TIP: Go live ASAP

17. SEPARATE INFRASTRUCTURE FROM
BUSINESS LOGIC

18. TIP: Identify
infrastructure code
and separate it
TIP: Use different
models for different
tasks

19. STRATEGIC DESIGN
NEW WEAPON UNLOCKED

20. LEVEL 3: WRITE MODEL DESIGN
Accepts commands
only
Does not provide
reading operations
Commands results into
sequence of events
Events are immutable
and persisted into
EventStore
Commands RabbitMQ
Banner
Management
Service
Event Store
Events

21. OR ANY OTHER ORM FRAMEWORK
Aggregates emit events
Aggregates are de-hydrated by replaying historical
events
No setters/getters
Respect encapsulation
NO HIBERNATE

22. TIP: Events and
commands can be very
natural constructs
TIP: Excluding query
operations can
simplify code a lot

23. COMMANDS AND EVENTS
NEW WEAPON UNLOCKED

24. LEVEL 4: EVENT STORE
Stores series of immutable events
There is no delete
Acts as “Event Log”
Has built in projection engine
Is not designed for querying
BannerCreated BannerClickUrlsAdded BannerRenamed BannerRenamed

25. EVENT SOURCING
NEW WEAPON UNLOCKED

26. Performs left-folding of
historical events
Produces
projections/views into
streams
Event selection
LEVEL 5: PROJECTIONS
Banner Projection
Click Urls
changed
Image
Renamed
Image
Created
Publishing UI Tags

27. PROJECTIONS
NEW WEAPON UNLOCKED

28. Two way synchronization
Anti-corruption layer patters
LEVEL 6: STAYING IN SYNC

29. SYNC: NEW TO OLD
Banner
Event
Event Store
Dispatcher
ACL Service
RabbitMQ
AdministrationDB
Reacts to domain
events
Makes changes into
AdsministrationDB
within small
transactions
Uses Dapper to
simplify persistence

30. SYNC: OLD TO NEW
Legacy event
ACL Service
RabbitMQ
Reacts to legacy
events
(AdCreated/AdUpd
ated)
ACL transforms
events into
commands
Aggregates are
updated
Banner
Management
Service
Commands From old
system
Events

31. TIP: Make legacy
integration
interactions explicit

32. ANTI-CORRUPTION LAYERS
NEW WEAPON UNLOCKED

33. LEVEL 7: API
This is the only way to interact with your system
Build UI on top of the API
Versioning is difficult – think if you really need it

34. EXPOSE COMMANDS AS RESOURCES
PUT: http://.../ImageBaner/{uuid}/Name
Command: RenameBanner
PUT: http://.../ImageBaner/{uuid}/File
Command: ReuploadFile

35. HYPERMEDIA – HELP YOUR CLIENT
GET: http://.../ImageBanner/{uuid}

36. HTTP API
NEW WEAPON UNLOCKED

37. LEVEL 8: UI & UX
Excel is already invented, it’s pretty damn good
UI must be built on top of your API
Guide user through business process

38. BEFORE

39. AFTER

40. TIP: Build UI to solve
business cases but
not to edit data
TIP: Exposing tasks
can reduce overhead
for users and for
developers
TIP: Build UI on top
of the API

41. TASK BASED UI
NEW WEAPON UNLOCKED

42. LEVEL 9: TROUBLESHOOTING AND
DEBUGGING
There is no F5 in distributed systems
Correlate all your requests and messages
Use centralized logging services

43. INSIDE THE RABBIT HOLE
REST
API
Domain
Service
ACL
Service
ES
Dispatcher
Service
Creative
Upload
API
Creative
Upload
Service
Ad
Analyzer
Service
File
Checker
Service
File
Generation
Service
Publishing
Service
Preview
Service

44. TRACK OPERATIONS

45. TIP: Track every
operation performance –
this helps to identify
bottlenecks
TIP: Automate load tests
and run them often.

46. CORRELATION IDS
NEW ITEM UNLOCKED: NIGHT VISION

47. YOU DON’T NEED THEM ALL - CHOOSE WISELY
De-normalized read models
Strategic design
CQRS
Event sourcing
Projections
ACLs
REST API
Task based UI
Centralized logs
LOTS OF GUNS

48. BUT WHAT IF…
No guns for
You!!!

49. ADAPT TO BUSINESS THINKING
Avoid – technical arguments
Code quality is poor
We need to refactor
Technology is old
Everyone is using Angular
now…
Missing “best practices”
We want to try NoSQL…
Prefer – economical arguments
Releases every day
Faster feature development
New products
Involve more developers
MS licenses are expensive…

50. DON’T GET LOST IN A DUNGEON
Have a VISION
COMMIT
Define Your STRATEGY
Create TACTICS
FIGHT
ADOPT new tactics
Fight HARDER
WIN