My Stuff

2010 Conferences

OSGi DevCon @ JAX London

February 23 - Keynote titled OSGi in the Enterprise: Agility, Modularity, and Architecture’s Paradox

EclipseCon

March 22 - 25 - Tutorial on Modular Architecture

Über Conf

June 14 - 17 - Sessions titled Turtles and Architecture and Patterns of Modular Architecture

Catalyst

July 26 - 30 - Two sessions on rich mobile applications and one on agile development. Half day tutorial on software process improvement.

Tweets @ Twitter

re: #apple event "We sold more iPads than any PC manufacturer sold of their entire PC line." 2012-09-12

re: #Apple Event ""Our notebooks now rank #1 in the US in Market share in the last three months." 2012-09-12

Right on. I just won a Best Buy drawing worth $1000. Either that or I won a shiny new virus by clicking the link. Hmm...what to do. 2012-08-29

The #osgi alliance response (http://t.co/KrN8XNWg) to the @mreinhold #jigsaw announcement (http://t.co/9YvcDdqC). 2012-08-29

Good Q&A with @mreinhold on project #jigsaw. http://t.co/9YvcDdqC. Modularity will change the way we design and run apps! 2012-08-28

LinkedIn Profile

The opinions expressed on this site are my own, and not necessarily those of my employer.

Agile Architecture

Filed Under Agile, Architecture & Design, Development, OSGi |  

Software architecture is difficult to define. Ask five different developers their definition of software architecture, and you’ll likely get five different answers. Arguably though, we can agree that software architecture represents the significant technical decisions spanning the breadth of the system. For instance, managing the dependencies between modules is a significant aspect of software architecture. Developing application frameworks that promote consistency across use cases is architecturally significant. Identifying application layers and the behavioral granularity of those layers is architecturally significant, as well. As Booch states:

Architecture is design, but not all design is architecture. Rather, architecture focuses upon significant decisions, where significant is measured by the impact of changing that decision. For this reason, architectural decisions tend to concentrate upon identifying and controlling the seams in a system, which are described in terms of interfaces and mechanisms and so typically mark the units of change in the system.

Essentially, we differentiate between architecture and design based on the impact of change. How easy is it to modify system modules if dependencies are not carefully managed? How difficult is it to change the dependency structure? How easy is it to reuse software components or services if the behavioral granularity is incorrect? How easy is it to refactor behavioral granularity? Traditionally, we attempt to make the right architectural decisions early due to the significant anticipated cost affiliated with making incorrect decisions.

This contradicts agile practices which have taught us to avoid up front design and architecture, and instead embrace change throughout the software development lifecycle. So how do agile and architecture come together? Conceptually, the goal of agile architecture is to eliminate the architectural significance of change by crafting software that can easily adapt to change. I provide an example of how to do this by focusing on the joints within a system. In practice, developing agile architecture is much more difficult. There are two simple truths we must be willing to accept.

  • Software architecture is organic. The architectural goals you set to achieve early in the lifecycle differ from those you’ll need to satisfy late in the lifecycle. Agile architecture is not only about what decisions you make, but when you make those decisions.
  • Software architecture is only as good as the source code it’s built upon. Shoddy source yields shoddy architecture. Therefore architecture must emphasize building the highest quality and structurally sound source code possible.

So how do agile practices promote agile architecture? To briefly paint a picture of agile architecture, we’ll explore a development scenario examining system growth and evolution.

Early in the lifecycle, change is rampant as new features are under development. An architectural vision that guides developers should be established that aligns technology adoption and implementation with business objectives. The time required to establish this initial architectural vision should be measured in days, not weeks or months.

Developers should stress closure by bundling code into larger modules, avoiding the unpredictability associated with complex implementation issues such as module granularity and transactionality spanning module boundaries. As the system grows, change and discovery occur less frequently. Modules should be broken apart, emphasizing independent deployment, clear separation of concerns, and even reuse. Smaller, self-contained modules are wired together via interfaces, further decoupling the structural relationships between modules.

Throughout the lifecycle, as business objectives change and new requirements emerge, the architectural vision evolves, yet still serves as the guide to implementation. Agile architecture is manifest as modules with minimal dependencies, concise behaviors, and clear points of extensibility. This drives architecture down to the class and code level, making the quality of your source code, and the coupling and cohesion of your classes, a critical factor in the resiliency of your architecture.

Agile practices play a critical role in agile architecture. Test-driven development lends you the courage to undergo architectural evolution. Continuous integration accommodates architectural shifts by ensuring issues encountered while refactoring are identified and corrected quickly. Supplementing your up-front design approach with an emergent strategy emphasizing spikes or proofs helps verify the architectural vision. Developing a robust infrastructure supporting incremental delivery allows your team to experience and identify architectural deficiencies related to performance, failover, usability, and more. Early and frequent discovery of inadequate architectural decisions provides the team with the time necessary to make architectural adjustments.

Shifts in architecture exists in a world beneath the trendy technologies du jour. It exists in a world separate from your decision on which web framework to use. Or which ORM framework you want to play with. SOA isn’t relied upon as a revolutionary architectural model. With agile architecture, technology becomes less significant because the architecture diminishes the impact of change. Crafting a robust architecture is not easy, but is at least possible if you allow architecture to evolve, and refactor as architecture must shift. Agile practices enable agile architecture.

That’s my definition of agile architecture. What’s yours?

Comments

10 Responses to “Agile Architecture”

  1. Michael L Perry on May 7th, 2009 4:46 am

    I am a Solutions Architect at AmerisourceBergen Specialty Group, serving the pharmacological industry.

    I’ve been engaged in what some might call agile architecture on my current project. I joined the team after the big architectural decisions were made, and we have challenged and changed many of them along the way. But the truth is that if I had been around to make those big decisions up front, I would have gotten them just as wrong.

    Each architectural change is accompanied by a large and painful refactor. XP and the agile methods that have followed are based on the premise that “the cost of change may not rise dramatically over time” (Beck, 23). Maybe we’re doing it wrong, but we haven’t found this to be true.

    So if the big decisions cannot be correctly made up front, and the cost of change does not stay flat, what then is the role of an agile architect?

    An agile architect, as I see it, is the advocate for quality. Whatever needs to be done to preserve and improve the quality of the product, that’s what he must do. Whether it’s taking on that big painful refactor, producing documentation where consistent understanding is lacking, or going toe-to-toe with project managers over the schedule. An agile architect slogs through the battles day after day, makes tough decisions, and owns the consequences.

  2. Rod Claar on May 7th, 2009 3:23 pm

    Nice article.

    Architecture is less about where to put things and more about decoupling and improving cohesion. In other words it is important to create an architecture that supports easy addition to the system when it changes and creates the ability to minimize changes to existing code when requirements change.

  3. Daily del.icio.us for May 2nd through May 7th | Vinny Carpenter's blog on May 8th, 2009 5:00 am

    [...] Agile Architecture : Software & Technology @kirkk.com - Agile practices play a critical role in agile architecture. Test-driven development lends you the courage to undergo architectural evolution. Continuous integration accommodates architectural shifts by ensuring issues encountered while refactoring are identified and corrected quickly. Supplementing your up-front design approach with an emergent strategy emphasizing spikes or proofs helps verify the architectural vision. [...]

  4. Agile Architecture Requires Modularity : Software & Technology @kirkk.com on June 15th, 2009 4:53 pm

    [...] few weeks ago, I presented my view of agile architecture, and followed that up with a post on DZone that presented two aspects of agile architecture. A [...]

  5. Software Architecture Reading « nthread on July 1st, 2009 4:51 am

    [...] thing that got me thinking about this was Agile Architecture, a good blog today about keeping architecture moving along during a project, always a good [...]

  6. Agile Architecture at Upcoming Conferences : Software & Technology @kirkk.com on August 11th, 2009 2:43 pm

    [...] Agile Architecture - My views on agile architecture and the natural architectural shifts that occur throughout the development lifecycle. [...]

  7. Agile Architecture Presentation : Software & Technology @kirkk.com on September 11th, 2009 6:02 pm

    [...] Agile Architecture - My views on agile architecture and the natural architectural shifts that occur throughout the development lifecycle. [...]

  8. The Use/Reuse Paradox : Software & Technology @kirkk.com on October 7th, 2009 5:05 pm

    [...] important because they are consequential to architecture, and resolving the tension is an aspect of architectural agility. It’s virtually impossible to design a reusable software entity until we have a better [...]

  9. Applied Modularity - Part 1 : Software & Technology @kirkk.com on November 16th, 2009 6:05 pm

    [...] abstract essence of what I’m referring to here, you should read some of my prior blog posts (Agile Architecture might be a good place to start). It’s a deep and very interesting topic, and impacts how we [...]

  10. Brad Appleton's ACME Blog: Emergent Design and Evolutionary Architecture - Resources on October 31st, 2011 11:12 am

    [...] Architecture from the Agile JournalLean Software Architecture, from Jim Coplien and Gertrud BjornvigAgile Architecture and Agile Architecture Requires Modularity, by Kirk Knoernschild Product Line Architectures and [...]

Leave a Reply