May 17, 2013 — Posted by Al Shalloway
Continuing with the 100 Things You Must Know to Be Effective In Software Development
Many wonder how a quality architecture can be built in an large organization attempting to achieve Agile methods. While most acknowledge big design up front (BDUF) has certain disadvantages, the design as you go approach that many espouse in the Agile community seems to have its own pitfalls and risks. At Net Objectives we believe that both extremes – too much architecture and no architecture - are fraught with risk and waste and are to be equally avoided. To understand what is needed and how to achieve architecture in the Agile space, one must step back and look at what architecture needs to provide to us.
Architecture, whether Agile or otherwise, needs to provide the following:
- A vision of the context within which we are designing so as to allow different teams to stay aligned while implementing in the best way for their local needs
- Enable extensions to the system, in particular, new concepts, technologies and scaling requirements that are discovered/demanded/required must be able to be implemented with low overhead
- Enable new ways of implementing existing concepts (e.g., new pricing, new countries) with only the cost of the new functionality. That is, there should not be any impact to existing functions.
- Foster testability throughout the system – both at the acceptance level and team functional level. In particular, new requirements should not adversely affect regression testing.
- De-couple systems from the application. As systems evolve, the application should not have to change merely because the system architecture does unless the changing system enables new functionality
- Facilitate reuse of common functions across teams
Doing the above is not necessarily easy, but it is made much more possible with an understanding of:
- how to evolve systems with emergent design
- how to test systems at the behavioral and functional level
- the different perspectives of conceptual Vs specification; creation from using; and system architecture from application architecture
The skill sets associated with the above are:
- Being able to do quickly identify sets of implementations that are conceptually the same and how they relate to each other (this is readily achieved with commonality / variability analysis using the analysis matrix)
- Pattern oriented design
- Test-Driven Development
- Acceptance Test-Driven Development
Agile architectures will then enable us to:
- Inject new concepts with little to no rework
- Add new implementations of existing concepts with only minimally affecting the existing system
- Change the system with little risk of introducing errors and full confidence that if you do you will detect them
We would suggest the needs of Agile and non-Agile architecture are really the same, Agile architecture merely needs to evolve in smaller increments. Architecture shifts from being this static structure that can accommodate everything to one of an architecture that can be easily modified as new information (often in the form of additional requirements) become known.
As you might guess, we have training and coaching on all of the areas mentioned above. We are introducing an online course, instructor facilitated course as well. If you are interested in improving the skill sets of your folks, please send me a note.
Al Shalloway
CEO, Net Objectives
If you liked this blog please tweet about it by clicking the icon below.
