Traditional approaches to software architecture are broken, and Agile methods offer little guidance. The result is brittle systems that cannot evolve. To fix this, technical professionals must build upon the fundamental goal of Agile — rapid feedback so that development teams can respond to change.

1. From Fragile to Agile Software
Architecture
Presented by Ahmed Khairat

2. Agenda
Change will never be as slow again as it is today
Agile & Architecture Opposites Attract!
The Three Pillars of Architecture
Practices Increasing Architectural Agility
Tips & Recommendations

4. Organizations need to become more adaptive!
Change will never be as slow again as it is today

5. Agenda
Change will never be as slow again as it is today
Agile & Architecture Opposites Attract!
The Three Pillars of Architecture
Practices Increasing Architectural Agility
Tips & Recommendations

6. Agile Values

7. What is Architecture?

8. The Goal of Architecture Is Cost-Effective Evolution
“The architecture of a system is the naming of the most significant design decisions that shape a
system, where we measure significant by cost of change.”
"Handbook of Software Architecture," Grady Booch

9. Traditional Approaches to Architecture Practice Are
Flawed BAUF (Big Architecture Up Front) Cannot Work

10. The Ivory Tower Is Real

11. The Lifeblood of Agile Is Frequent and Accurate
Feedback Double-Loop Learning
• Key success factor for agile processes is reflecting
on your way of working
• The Retrospective meeting is meant for that
• The development process itself should also be
flexible and adaptive
• This also applies to architecture!

12. Agenda
Change will never be as slow again as it is today
Agile & Architecture Opposites Attract!
The Three Pillars of Architecture
Practices Increasing Architectural Agility
Tips & Recommendations

13. The Three Pillars of Architecture

14. The Social Pillar: Collaboration is Key
Waterfall (BAUF) Agile

15. The Process Pillar: Continuous Architecture Across the
Life Cycle

16. The Structural Pillar: Modularity is key
Modular Monolith Using Componentized
Architecture
Microservice Architecture
Structural Architectural Agility

17. Agenda
Change will never be as slow again as it is today
Agile & Architecture Opposites Attract!
The Three Pillars of Architecture
Practices Increasing Architectural Agility
Tips & Recommendations

18. Prove It With Code

19. Architect All the Way Down

20. Architect All the Way Down
Views of a System — Class, Package and Module

21. Architecture All the Way Down Helps Bring
Down the Ivory Tower

22. Generate Documentation
• Generating documentation is a critical form of feedback
• Automate the creation of documentation
• Static code analysers
• Automated test scripts
• Visualizations are a valuable artifact
• Structure101
• JarAnalyzer
• SonarQube
• Code map
• Layer Dependency Validation

23. Generate Documentation
Generated Architectural Diagrams

24. Validate and Enforce the Architecture
• Proving your initial architectural vision with code and ensuring that the vision survives change are
separate issues.
• validate performance.
• validate portability.
• validate transactional correctness.
• validate layering.
• Architectural tests will help validate that the implementation is working and aligned with the
architectural vision, and the team can automate these tests as part of their continuous integration
strategy

25. Refactor Mercilessly
• Refactoring is the process of improving your existing code without changing its behavior
• Refactoring improves the nonfunctional attributes of your codebase
• Refactoring helps you manage the technical debt that increases maintenance cost and hinders your
ability to understand the software system
• Architectural refactoring emphasizes continuous improvement of the architecture as the system needs
to

26. Practices Increasing Architectural Agility:
Keep It as Simple as Possible
"Making something easy to change makes the overall system a little more complex, and making
everything easy to change makes the entire system very complex. Complexity is what makes
software hard to change.“
"Who Needs an Architect?" Ralph Johnson

27. Complexity: Enemy of System Agility
▪Complexity: many relations between the elements of a system, ‘everything’ is related to ‘everything’
▪Complex systems are not agile, because:
▪ you need to understand the complexity before making a change
▪ changes themselves are a lot of work
▪ local changes may have many unforeseen side-effects, sometimes in unexpected places
▪ lots of testing is needed
▪25% more functionality doubles the complexity of a system
(analysis by Cynthia Rettig, MIT Sloan Management Review)
▪ Developers spend 50% of their time simply understanding the software system
▪ 90% of software cost is maintenance and evolution
▪ Software doubles in size approximately every seven years
("Software Maintenance Costs," University of Eastern Finland)

28. Growth of Software Over Time

29. Agenda
Change will never be as slow again as it is today
Agile & Architecture Opposites Attract!
The Three Pillars of Architecture
Practices Increasing Architectural Agility
Tips & Recommendations

30. Tips: Use Smart Business Infrastructure
▪Stuff that hardly changes can be fixed and serve as infrastructure for the changing stuff
▪ Probably you don’t need to have very flexible electric wiring in your house
▪ But you want to be able to plug in all kinds of devices
▪Examples:
▪ Business process management and workflow management systems
▪ Business rule engines
▪ API Management
▪ Event-Driven Messaging infrastructure
▪ Code Templates, Reusable Components

31. Recommendations
• Improve All Three Pillars Simultaneously
• Establish Your Architectural Vision, Avoid BAUF and Adapt Architecture
• If Building a Monolith, Use a Componentized Architecture
• Find Ways to Garner Accurate Feedback on Architecture
• ‘Architecture Owner’ role in agile teams
▪ Convey the architecture vision to the rest of the team
▪ Give guidance on solution architecture
▪ Provide ‘architecture stories’ (enablers) next to user stories
• Refactor the Moment Architectural Deficiencies Are Discovered

32. Conclusion
The environment changes ever faster; not adapting is not an option, agility is key
Agility is not just about software development processes, but an enterprise-wide issue
Architecture is indispensable for sustained agility
Implementing new methods is itself an agile learning process
Key responsibility of architects: collaboration & coherence, between people and
between systems