Archive for Architecting

Visual Architecting

The Visual Architecting Process (VAP) supports the architect in leading architectural decision making and the exploration of options, the iterative resolving of critical uncertainties and challenges, and the evolution of the system.

The process is illustrated here and here, emphasizing the visual support for system conceptualization, design and reflection. We regard process as “scaffolding” (it supports us and enables us to build more complex systems, but the effort and focus is on building the system) and we use just as much as we need to fit the design and organizational challenges of our system/organization and the maturity stage of our system. In other words, it is a “just enough” highly iterative and agile process.

We advocate identifying and prioritizing, exploring and addressing opportunities, uncertainties, challenges and risks with the cheapest medium that will serve those we judge most important to address. If we can learn with an exercise of the imagination, with a sketch or model, with role play, with a (paper) mock-up, with a focused prototype, or a spike, then we do that. We recognize uncertainty, and deliberately seek to discover value and resolve direction.

Visual Architecting supports:
Visual Architecting

  • Creating architectures that are good, right and successful, where good: technically sound; right: meets stakeholders goals and fit context and purpose; and successful: actually delivers strategic outcomes.
  • Translating business strategy into technical strategy and leading the responsive implementation of that strategy
  • Applying guiding principles like: this extraordinary moment principle; the minimalist architecture principle; and the connect the dots principle.
  • Being agile. Creating options. Reflecting. Responding. Factoring and refactoring.
  • A commitment to objectivity.

Given a “just enough” (e.g., willing to work with as sketchy and cheap a decision medium as does the job well enough) and “minimalist” (focusing on decisions necessary to strategic outcomes) orientation: We seek to make the context and rationale for our decisions explicit, to identify the important side-effects and consequences and dependencies of these decisions, as well as alternatives noting why we make the decision we make. We seek to understand and compensate for cognitive biases and other sources of decision error.

Some further discussions of aspects of VAP:


Architecture and the Agile Quest

If you’re interested in Agile and Architecture, here’s an interesting read, including the comments: The Demise of the Gantt Chart in Agile Software Projects, by Tate Stuntz on July 31, 2007. I have to agree with David Christiansen: “I’m not convinced there is such a thing as a methodology or process that can produce good architecture.People create great architecture, just like it is people that create great software systems. But are there things we can do to create better architectures, and better software systems? Of course I believe there are! That’s where process comes in.

In manufacturing we learned that if we inspect quality in at the end, the cost of quality (a term that refers to the cost of poor quality that leaks through the inspection process, as well as the cost of removing found defects) is much, much higher than if we find potential quality problems at the source, to ensure they aren’t inserted. 

Architecture defects, those that have diffuse impact across the system, are so expensive they are hard to recover from when they are only discovered once the architecture is hard-cast in code. Hard-cast, I say, because though we think software is pliable while we are writing code, the volume of it quickly amasses, and with it sunk cost and sunk time. And we don’t, as an industry, understand sunk cost and sunk time terribly well! It is a huge reset to go back and rework the system to accommodate an architectural change of any significance. Because we perceive software as highly mutable, we think we can recover if we scramble, but our accommodations to the code make it ever more immutable as the structure erodes to the point where it is hard and unpredictable to change.

More expensive still, have to be products that are defective in concept, set to miss the market. Getting the product or application concept right–the value propositions that will deliver customer advantage and delight–is not a feel-our-way-as-we-build kind of thing. It is a strategic matter. Or at least, get the strategy wrong, and all the tweaks in the world are going succeed only by amazing luck and sheer heroics.

And yet, it seems to be asking for suspension of disbelief to ask for time on a project where all that is being produced is models, diagrams, stories, even if this work is toward a minimalist set of strategic decisions. Putting features in front of users, why, that is what creating software is all about. That is where we can see progress.

Still, if progress is moving towards a better sense of what our customers value, across use contexts, and all that decision space complexity, then we can make a lot of progress quickly and cheaply with models (and mock-ups and proof-of-concept/prototypes). And by exploring how those features play out over our posited architecture structures, we can refactor early, cheaply, while all we are changing is models and descriptions.

To help people create great architectures, our process needs to:

  • lead us to work in an integrative, collaborative way (without becoming a “committee”)

  • explore and visualize value opportunities and value delivery mechanisms, to establish architecturally significant requirements and architecture strategy

  • learn quickly through iterative cycles.

Yes, this is an agile process, if we make models recognized citizens of the software world, with full rights to authenticity and budget! In all we do, we have to find a good balance. Our models should not be belabored, certainly not early on, by putting in too much detail or trying to make them look pretty too early in a tool where pretty is hard to do once, let alone with changes.

We also need to open up our “agile” concept of customer. I highly recommend  Hidden in Plain Sight. I’ve also written about delight (key to customer advantage) various places in my architects/architecting/architecture journal notes (e.g., Vitruvius and delightcircle of excellence and (skipping the first paragraph) Zappos demonstrates that IT Does Matter).

What we are trying to do is surface and understand value propositions that users and other stakeholders find compelling. And find and improve the structures (architectural components and mechanisms) that will support the system through the sprints leading up to the first release, and beyond.



Agile Architecting

The Agile Manifesto articulates the following core values:

  • Individuals and interactions over processes and tools

  • Working software over comprehensive documentation

  • Customer collaboration over contract negotiation

  • Responding to change over following a plan

In essence, informal, iterative, adaptive processes that rely on the collaboration of empowered individuals are strongly favored over formal, bureacratic process and its accoutrements (plans, contracts, comprehensive documentation).  If we overlay these values with values for enabling dynamic teaming, value delivery and risk management, we have the value-set that underlies the Visual Architecting Process.

Short iterative cycles, early involvement of stakeholders, and visualization, allow for quick learning, early direction setting and iterative direction correction and refinement. But this learning is done with models as long as they are effective, reducing the cost of change as the architectural design is explored, refined and elaborated. Along the way, the architecture is documented, both to aid the architects in thinking through approaches and alternatives, and as a communication tool to get input and feedback from a broad set of stakeholders.

The process promotes early discovery of opportunity to innovate and differentiate, and builds alignment and motivation through a strong, shared vision and high-level system design that identifies system building blocks that, for large systems, become the units of agile development, allowing further innovation and experiment, with generally lower cost of changelowered by isolating the impact of change.

This process then, allows us to integrate the best of agile software practices along with other practices used to get complex products created in reduced timenamely, allowing more people to be effective, productive and creatively engaged in building the system, because they have clear commitments to and from the system via the system design, and, yes, its documentation.

Embrace agile development and refactoring. Just start with models, work with all of the agile philosophies while the team is using models and document with sketches (visual and verbal) of the overall system and the key architectural mechanisms. Some of our lessons are learned the hard way, through discovery that necessitates refactoring at the code level. Others can be discovered by modeling the system and refactoring at the conceptual architectural element (module, component, service) level. Others are more apparent; we have after-all, some experience building software systems!  Yes, the ground is constantly shifting under our feet–the competitive landscape, and the technological landscape, keep changing, sometimes in revolutionary ways. But at the same time, dominant designs emerge that see us through periods of system evolution.

Naturally, I’ve defended (just enough) architecture documentation various places:

This piece is intended to plead the case for documentation within an agile culture

Also related:

On Agile and Documentation

and while I wouldn’t toss the proverbial baby out with the bathwater:

Colm Smyth has a series of posts titled “Debugging Extreme Programming–Agile not Fragile” that is architect-friendly; see, for example, Refactoring, On-site Customer and Metaphor.




Comments (2)