traceinthesand.com Blog » Architecture

The Art of Change: Fractal and Emergent

Ruth — Sun, 28 Nov 2010 16:48:44 +0000

Our “The Art of Change: Fractal and Emergent” Executive Report covers

a model of change, showing how the vectors of change are different at different points in the lifecycle, so that agility means different things, depending on where in the lifecycle the product-market is
a discussion of how the meaning of business and the meaning of design are shifting
Jeff Bezos notion of fractal strategy, leveraging it to illustrate how fractal strategy enables intrinsic agility
positioning IT as a leading player on a strategic stage where relationships and business intelligence are key drivers of innovation and agility
the tandem role of strategy and architecture in an agile business and the implications for architects
a fractal notion of leadership, in a business that relies on fractal strategy and tandem architecture to combine intentional goal-seeking with emergent responsiveness

Business strategy and its tandem architecture creates coherence of purpose and concert among the many socio-technical systems, the many smaller pools of action and influence, within an organization, so that bigger, more ambitious, impactful things get done. While embracing emergence or extemporaneous dynamic responsiveness, we also note that strategic differentiation takes intentional focus to align inspired, creative, inventive thought and action so that many contributions of mind, will and hands build the systems that create and sustain competitive distinction in the market.

We borrowed Jeff Bezos’ image of strategy happening fractally at Amazon, and put words to what is done, varyingly, in organizations. The important thing about creating this image of fractal strategy and tandem architecture though, is that it gives us a way to have the conversation about the relationship between strategy and architecture. Why? Because there is inconsistent understanding of the role of strategy, let alone architecture!

In some organizations, strategy is ignored or derided — they claim there is “no strategy,” and that is treated as a point of cultural pride. A point of cultural pride. Hmm, that sounds like identity, which is a key part of strategy. So strategy in the organization is fractal, with an independent “cowboy” (shoot first and aim after) culture set as the unifier at the corporate level, and other elements of strategy pushed out to the business elements. But as soon as that company wants to achieve something more coherent across its businesses, it finds itself needing to work strategically and architecturally to create a shared intent and the relationship platform for enabling that coherence. So, whether “dynamic, organic, fractal strategy” enters their parlance, allowing them to explicitly talk about intentional and emergent strategy or not, they have to get more intentional if they want to do those bigger things that require concert to make them more the way they would like them to be (Herbert Simon’s wonderful way of defining and motivating design).

The impetus for writing this report, was an increasing rumbling around the future of IT and EA. Well, of course we know IT and EA has a healthy prognosis. Still, many choose to see IT as a cost-center — one that encumbers with a mish-mash of entangled, brittle systems, and expensive tastes in technology frills that can’t be afforded in lean times, at that. So it is worth articulating the counter-position, don’t you think? Anyway, that’s a key message — articulating the role of IT and architects (product, system and enterprise) in sensing, catalyzing and responding to change. So the report makes points like:

“Many of the business capabilities that IT supports and enables have to do with building and maintaining relationships and their information spaces to run the business and create strategic advantage. …

Relationships, both formal (with codified transactions) and informal (with dynamic, even ad hoc, interactions), are enabled through high connectivity. In Connections, James Burke, commenting on the Gutenberg printing press, observed “the easier it is to communicate, the faster change happens.” Alternately put, new ideas come about through conversations, and conversations through relationships, and increasingly these are digitally enabled and/or enhanced.” …

“When we recognize that this is a world where organizations increasingly compete on and for relationships, perception, and fidelity, and on information leverage, the strategic role of IT jumps into sharp relief. Place this in a context of change, and IT finds itself with a leading role on the strategic stage. Whether it is playing the role of the proverbial bad guy responsible for runaway costs and change encumbrance or a partner in a landscape-defining dance of change depends very much on how well IT is integrated into strategic decision making — at various levels in a fractal approach to strategy setting.”

and

“Complexity is a key driver of architecture. That is to say, as complexity increases, so does the need for architecture. It is not that we want complexity to go away, for value comes hand in hand with complexity. Instead, we want to harness complexity and, as it were, to tame it so that it serves rather than obfuscates and subverts the value we are creating.”

and

“The role of architects in an agile enterprise, therefore, includes taming the transmogrifying mess created by responsiveness, dynamic learning, and accommodation, even while leading with intentionality to innovatively envisage, build, evolve, and sustain systems and their explicit, enabling and constraining architecture decision sets.”

– Ruth Malan and Dana Bredemeyer, The Art of Change: Fractal and Emergent, Cutter Consortium Enterprise Architecture Executive Report, Vol. 13, No. 5, 2010.

We hope that the Report persuades managers and architects that there is an important relationship between architecture and strategy, and that relationship doesn’t have its foundation entirely in the business side, nor entirely in the technical side — but rather in a partnership where strategy and architecture work together collaboratively. That is, they inform and are informed by each other, enhance and are enhanced by, lead and are led by each other. And I hope that the paper unfolds the salient topics in an accessible manner — accessible across the languages of business and technology — to motivate and enable that dynamic tandem relationship.

The Art of Change: Fractal and Emergent is the first in a two-part series, and focuses on the what and the why. Part Two, The Art of Change: To Lead is To See, To Frame, To Draw focuses on the how. We hope that you find the Fractal and Emergent paper, with its focus on agility through fractal strategy and tandem architecture, inspiring and useful. If so, you can play a role in Part Two, helping us improve it by becoming a reviewer or simply by providing encouragement.

You can download a complimentary copy of The Art of Change: Fractal and Emergent at http://www.cutter.com/offers/artofchange.html.

Why Getting Past “But…” is Important

Ruth — Wed, 14 Jan 2009 15:34:30 +0000

You’ve probably read Getting to Yes and heard of Getting Past No, so why Getting Past “But”? Well, because “but…” is insidious, making it harder to get past than an outright “no.” The person who says “yes, but…” is ostensibly aligning with you. Ostensibly agreeing but for this teensy caveat—this objection that is a showstopper! It can be resistance in a subtle guise, seeming passive yet inherently active—the kind of action that is actively rationalized non-action. Or it can be genuine goodwill—indicating a real desire to orient with you, and active intellectual, creative engagement. The trouble, though, is that “but” can become a barrier. We need the attitude that looks beyond “but.” If we look only to “but,” only to the objections, the reasons why not, we stop there. We need to look to what we want to accomplish, then figure out how to get there from here. We need to look beyond “but” to get past “but.” Yes, this is the stuff of “kindling the collective mind,” engaging others in seeing how we would like things to be, then engaging their creativity in resolving how to get there.

I’m told “I agree with you, architects should play an active role in requirements, but reality in my organization is that the structure and process doesn’t allow that.” Yes, that reality is hard to change. And it will not, so long as the one person who could begin to make the change, the person who sees that the change is needed, doesn’t start to lead the change! First, to see the need, then to help others see a better future, then to enroll them in creating that better future.

This by way of an architect’s signature on an email I received this evening:

“Reasonable people adapt themselves to the world. Unreasonable people attempt to adapt the world to themselves. All progress, therefore, depends on unreasonable people.”

George Bernard Shaw

Yes, change can be hard, and it can take a long time to even get to the point where people recognize the need for change. It took Madison five years to get the parties to the table to create change. Hopefully it can take us less time to restructure the status quo in software development. Our Getting Past “But” paper is one resource you have to help shift perception and expectation. The Agile Movement also helps underscore the importance of multi-disciplinary teams. If your organization’s approach to scale and complexity is to do just enough requirements and design upfront (for example, to spin off concurrent teams with enough context), you can still leverage the learning that the Agile Movement has embraced—multi-functional teams, iteration and stakeholder participation allow more concurrency to happen earlier, with better outcomes.

Scaling Agile with VAP: Getting Past “But…”

Ruth — Wed, 17 Dec 2008 17:55:39 +0000

Our Getting Past “But…” executive report covers two essential areas:

innovation, the circles of innovation model, the innovation process, and what all this means for architects.
scaling agile development projects with VAP (emphasizing just enough design upfront or JEDUF).

These map roughly to the first and second halves of the report, though we encourage those interested primarily in the material in the second half to also read the first half. What follows is a brief outline of the contribution of these two parts of the Getting Past “But…” paper.

Innovation and Architects

Innovation is rampant, and clearly companies big and small are innovating apace. At the same time, many companies are disappointed with the return on their innovation investments. Industry incumbents are adapted to the status quo and defend their inertial tendencies with “but..”: but we aren’t chartered to do that, but that’s too risky, but our customers aren’t asking for that, but that would cannibalize our market. Focusing on immediate releases and incremental improvements, thwarts competitive landscape reshaping innovation which then tends to come from outside, often from start-ups.

Getting past “but…” takes a shift in attitude. It is true that this shift is fostered by empowerment, with an innovation culture established by top management. Google is the prototypical example there. It is also true that the shift can start with the individual. The creation of masking tape (the 3M story starts around minute 21 of Scott Berkun’s presentation) is just one example where the inventor used his own initiative and limited budget to fly a skunkwords project under the radar. We need to recognize that generally there isn’t a shortage of ideas. And, in aggregate, there isn’t a shortage of willingness to take risks—witness the number of failures, including startups. What we need are more effective ways to get good ideas on the table, sift for those that make good business sense because they create high customer value that can be used to build differentiated identity and strategic advantage in the industry, put them through early, quick and cheap failure/improvement cycles, and get more and more talented peoples’ heads in the game to build the system.

Our Getting Past “But”: Finding Opportunity and Making IT Happen report speaks to role and process changes that empower design teams to create a new competitive basis through differentiating innovations. You can download a complimentary copy from Cutter Consortium at http://www.cutter.com/offers/findopportunity.html.

In this paper, we take the position that architects need to be part of, if not lead, the innovation team. The architect’s role is to help the business identify opportunities to create value through capabilities that technology brings to the table. This leverages the unique perspective of the architect into technology and the organization’s technical capabilities, but it also leverages the architect’s unique skills in system thinking and modeling.

VAP and Scaling Agile

VAP (the Visual Architecting Process) is all about being agile even when the complexity of the system, and the organizational unit(s) building it, demands just enough upfront design—for example, to launch concurrent agile teams. What VAP emphasizes and enables is parallelizing the requirements and architecture iterations, with intensive stakeholder involvement as pertinent to the quick cycles. VAP can be applied during coding cycles, but for complex systems, early VAP cycles use the cheapest possible artifacts (e.g., models and prototypes) for learning quickly about stakeholder value and architectural challenge. This concurrency, together with the principle of stakeholder involvement (including but not limited to end users), is a major value and contribution of VAP.

We write about JEDUF and agile architecture in the Getting past But paper. The content of the report is so important to the conversations we’re having, to the challenges of organization after organization as the hype around agile pushes larger and larger projects to experiment with agile development. As we do so, we need to leverage all the lessons of our histories creating complex systems, as well as the lessons and values of agile development, to adapt a process that works for concurrent development of complex systems.

References

This synopsis derives from writing in Ruth Malan’s (almost daily) architecture journal.

Ruth Malan and Dana Bredemeyer, “Getting Past “But”: Finding Opportunity and Making It Happen.” Enterprise Architecture Executive Report, Cutter Consortium, August 2008 You can download a complimentary copy from http://www.cutter.com/offers/findopportunity.html.

Conway’s Law

Ruth — Wed, 13 Feb 2008 01:42:32 +0000

The Wikipedia community describes Conway’s Law like this; I paraphrase it like this: if the architecture of the system and the architecture of the organization are at odds, the architecture of the organization wins. The organizational divides are going to drive the true seams in the system.

The architecture of the system gets cemented in the forms of the teams that develop it. The system decomposition is what typically drives work allocations. Then the organizational lines of communication become reflected in the interfaces, with cleaner, better preserved interfaces along the lines where organizational dissonance increases. In small, co-located teams, short-cuts can be taken to optimize within the team. But each short-cut that introduces a dependency is like rebar in concrete–structurally efficient, but rigid. If the environment changes, demanding new lines to be drawn, the cost becomes clear. The architecture is hard to adapt.

One could say this is part of the innovator’s dilemma. Sustaining innovations, that is, incremental improvements within the cast of the architecture, are what the organization is adapted to be good at. But when a breakthrough innovation demands a new architecture, a new organization (unencumbered by power trees that grew up around the old architecture) tends to be more fleet in bringing the innovation to market.

Another implication of Conway’s Law is that if we have managers deciding on teams (what they’ll do, who will be on them, and how they will relate), and deciding which services will be built, by which teams, we implicitly have managers deciding on the system architecture. They determine system chunks (services or components) and capabilities by deciding who will build what.

Conway’s Law also kicks in if we take an initial guess at the system decomposition (a first-cut conceptual architecture), allocate subsystems to teams, and sally forth–the team boundaries will tend to become the boundaries within the system. Anything else will be a feat of architectural heroics; hard to accomplish, when architectural heroics have to compete with schedule heroics driven by the steady beat of integration clocks. Yet, architecture is where we address cross-cutting concerns, or at least those that needs-must be addressed with a system perspective so that when it comes time to compose the system it will have the properties stakeholders care about, rather than emergent properties that may or may not suffice.

Roles are defined by their responsibilities and associated decisions. Architect is a role. Any person may play one or more roles. That is, the architect role may be shared among a group of people (as in many agile project teams), or one person may hold more than one role (as in many small teams, especially in startups). This may be overt and declared. And it may be the result of decisions that are actually effected. If management decisions determine the architecture of the system, they are in effect its architects. If developers determine the architectural decisions, they are in effect its architects.

“Duh!” you might well be saying. Yes, a lot of what is absolutely common sense when it is put plainly, is so obtuse in the face of perplexifying reality. Simply witness all the heated arguments and misunderstandings you get around the topic of the role of the architect.

But what does it mean? Architecture needs to happen across the interfaces, and this also means across the system/organization interfaces. It means that system architects (who we call architects) and business/organization architects (who we call managers) should not work as if one has no impact on the other.

Other references:

Why do we need software architecture (how architecture serves organizational and technical purposes)

Who needs carrots anyway? (about the iron triangle and the interface between management and architects)

Architecture Documentation: Courage to Fly in the Face of Convention

Ruth — Fri, 25 Aug 2006 20:48:51 +0000

I have learned what I know about good architecture from working with good architects, many of whom have set the bar for excellence in architecture documentation. That said, I am too often caused to lament that the only thing harder than getting engineers to read the architecture documentation is getting architects to write it!. So why bother? Who cares? It is only going to get out-of-date. It takes work, and isn’t that time better spent coming up with better solutions to the challenges we face? Or better still, writing code, which is the ultimate in system documentation–right???

An architectural decision that isn’t written down has a lifespan of, let’s see, what is the memory span of a goldfish? Actually, it turns out that a goldfish memory span is not just a few seconds as previously thought. And we’re even smarter than goldfish. Can’t we just rely on our individual and group memory? Well, we have all been in the situation where a decision we thought we made yesterday, is still under debate today, and we have to persuade and coax, inform and influence, brow-beat and defend all over again.

Writing the decision down doesn’t get us entirely away from this perpetual churn, but it does help. We get sign-off on the decision. Once that is achieved, we can demand that only counter-arguments that have a strong link to architectural requirements can be brought up in contention with the decision.

Still, the half-life of an architectural decision depends very much on the authority vested in the architects, and how this authority is formally and informally reinforced in the organization. And it depends on what the architects do to communicate the decision, and what support and follow-through they apply.

So, if we cowtail to the push-back against architecture documentation from extreme agilists, and our own disinclination to write down architecture decisions and thinking that went into them, then we are sending the message that the “architecture” is not a set of decisions but just a fluid initial starting point that we expect everyone to remold and reshape actively and without constraint–or restraint.

In some situations this may be just fine. If we are working on a novel system, without precedent in our experience and in the collective experience of our industry (so we can’t hire in the experience we need), then it would be foolhardy to create an architecture specification early on and expect to live by it through the life of the system.

Architecture is intended to constrain–and enable, but the price is that we must constrain; that’s what decisions do. Once made, they have eliminated some alternatives we might otherwise have picked. Yes, like stop lights, they enable and constrain. So, is it reasonable to constrain (and enable) ourselves early on in the project? While we are always pushing boundaries beyond what we already know, we are generally also working with a good deal of experience to leverage. To the extent that we can create an architecture that we can validate and build confidence that it will serve us through the first release, and prepare us well for subsequent releases, we should do due diligence when it comes to documenting our architecture.

But what is architecture documentation? In good part, the architecture documentation consists of the very models we use to think through and make the architecture decisions. In short, much of the work is already done, assuming that we use models to visualize and evaluate architectural approaches. The diligence part has to do with:

making sure we write down the thinking behind the models
keeping the models (and supporting explanations) up-to-date

Architecture documentation explains and justifies the decisions that embody the architecture. So we need to articulate the reasoning, tracing the decisions back to the requirements that drove them, keeping track of alternatives we weighed but ruled out and why (so we don’t have to make the same arguments again and again), and writing down assumptions we made (so if these assumptions are invalidated, we know we have to revisit the decision).

When we do this, we also help educate the engineering community, sharing the experiences that shaped our decisions. By documenting our reasoning like this, we make our knowledge explicit and shareable. Further, it makes us more careful, because we leave a record that can be assessed and debated.

One of the things we have to do as architects is figure out where to push back against the status quo, to lead out of the rut we are in to a better way of doing things; a better way that enhances our community’s quality of life. And we have to figure out which battles just aren’t worth it, because it takes energy and passion to lead these changes, and some changes are more important than others.

For the things that we see rising above this cut-line, we need to do what it takes to be effective. We must not allow ourselves to be lulled by the cries of “it’s all going to change anyway” to escape the effort it takes to write good documentation for architecturally-significant decisions. If we want these decisions to impact the behavior of people implementing them, we need to do our part in communicating them.

The architecture decisions must be recorded, so we have a ready reference that doesn’t depend on us being always in the room, ready to explain and defend each decision. The decisions must be communicated and understood. It is worth it, if the architecture decisions are worth it. So the decisions must be strategic and minimalist, and relevant. As soon as they are not, we must be on hand to adapt the architecture decision set.

Once written down, to be sure not everyone who should read the various architecture documents, will read them. But those that do will have a much better understanding of the architecture, and the rationale for the decisions it encompasses. Good models and well-written explanations get right into the head of the reader in a personal and effective way. The reader can engage, backtrack, hold an internal dialog with the material until it is well understood, or at least clear where the questions are. Each reader will be better positioned to explain to their peers and reports what the architecture means, in the narrow direct sense and in the broader sense of its intent. This very effectively expands your capacity to champion and explain architecture decisions and catch misunderstandings and misapplication of the architecture.

All this presumes that you and your team can come up with an architecture. It does not presume that you make every architectural decision in advance of all coding. Not at all! But when you have a complex organizational setting (large number of developers, distributed teams, etc.), then you need to do more of the architecture work upfront, and document AS YOU GO, not afterwards! There never is an “afterwards” and even if there was, you’ll have forgotten much of the rationale, if not many of the important decisions. Besides, though we need architecture documentation to help us with system evolution, we need architecture to create a system that addresses our architecturally significant requirements in the first place.

Early on, figure out what the architecturally significant uncertainties and risks are, and figure out what you must do to resolve these risks. Leaving them until “you must deal with them” is risky business. Then work quickly, with a focus on architectural priorities, to get a minimalist set of architecture decisions explored, validated (through models, reviews and assessments, simulations, mock-ups, and early, focused development of critical pieces of the code) and documented!

The bottom line: No architecture documentation –> no architecture; no architecture and we rely on organic people-intensive communication processes that, on average, don’t scale too well. No architecture + big project –> project wipe-out.

Other Perspectives on Architecture Documentation

For Architecture Documentation:

Documenting your Software Architecture, by Jim Alateras on March 15, 2006
Why Documentation Matters, by Frank Kelly, posted on June 15, 2006

On-the-fence about Architecture Documentation:

Agile Architecture Modeling, by Scott Ambler, last updated on April 29, 2006

Creating Architecture Documentation:

Software Architecture Documentation, by Ruth Malan and Dana Bredemeyer, March 2003
Software Architecture Action Guide Book (draft), by Ruth Malan, and Dana Bredemeyer, 2006
Less is More with Minimalist Architecture, by Ruth Malan and Dana Bredemeyer, published in IEEE’s IT Professional, September/October 2002.
A Template for Documenting Software Architectures, by Mike Ogush, Derek Coleman, and Dorothea Beringer, March 2000
Architectural Blueprints – The 4+1 View Model of Software Architecture, by Philippe Kruchten
IEEE Std 1471-2000 IEEE Recommended Practice for Architectural Description of Software-Intensive Systems
Software Architecture Documentation in Practice: Documenting Architectural Layers, by Felix Bachmann, Len Bass, J. Carriere, P. Clements, D. Garlan, J. Ivers, R. Nord, and R. Little, 2000
Architecture Documentation — Choosing the Views, by Paul Clements, Jan 31, 2003.

See also Software Architecture Books and Architecture Documentation (links) in my Trace in the Sand Architecture Journal

[8/25/06: Had to republish this post so the sidebars would show up.]

[9/16/06: Arnon Rotem-Gal-Oz is blogging on the Software Architecture Document -- on 9/12/06. See also Deliverables sections of our Software Architecture Action Guide book chapters on Meta, Conceptual and (soon) Logical Architecture.]

Modularity and what we can learn from Trek

Ruth — Tue, 20 Jun 2006 00:39:04 +0000

I love my Trek bicycle, but with Shimano gears and brakes, and Bontrager frame, wheels, tires, and pedals, the ineffable Trek quality cannot be pinned down to any Trek-branded component. The success factor here: modularity with clear interfaces, and clear design requirements pushed down to the modules so that excellence at the level of the overall system is achieved through the composition of excellent pieces.

Bicycles have been around a long time, and there is a dominant design. That allows innovation to be focused on the components and subsystems, with less frequent revolution in the overall decomposition. Together these 3rd party pieces fitting into a standard decomposition nonetheless yield a system that is unique and differentiated. Modular components driven to excellence in of themselves, plus a clear sense of the differentiating system qualities, yields a distinctive product. Flawless. So well-designed I can say wthout reservation, I love this product.

It is the architect’s responsibility to create the architecture (with collaborative input from component designers): to make decisions about the system identity and integrity, and decisions about components and their scope and responsibilities, and address cross-cutting concerns and system properties. The architecture provides the context to push excellence, innovation and quality to the level of the components.

In the software world, in the pressure of the moment we allow ourselves to accommodate the architecture. Every compromise to the modularity of the system increases the future cost of change. But we live in the present. We have to get out of this singular mindset, and part of the way out is to have an architect with the clear and well-known charter to preserve the structure of the system—to defend modularity and ensure that the modular pieces do indeed work together to deliver the functions and properties required.

Feature set teams or storyline teams (or whatever else you call them in your group) tend to work across the layers in a system. This work partitioning helps drive out features that users can respond to and give feedback on, so they can be improved. Great! But it also makes it important to empower an architect to defend and preserve the architecture, and yes, evolve the architecture when, on balance, that is the best route.

Objects, then components, now services, are all hyped because they promise to address the build-from-parts need in our software world, at ever greater levels of granularity. But solving our problem isn’t simply a matter of picking a programming paradigm that supports (larger-grained) parts. We have to become good at designing parts—parts that really fit our system; really fit our need.

I acknowledge that I am fundamentally, completely, biased here, but I can see no other course than through getting better at architecture, and better at protecting and preserving our architecture, and better at investing in evolving and regenerating our architecture. And better at investing in what it takes to completely revolutionize our architecture, even though that means we have to do so with a whole new set of people, which is counter-intuitive (see Rechtin’s book Why Eagles Can’t Swim, 2000).

What is Software Architecture?

Ruth — Sun, 07 May 2006 22:25:57 +0000

To set the context for subsequent posts, I thought we’d start with the topic of “what is software architecture?” Bass, Clements and Kazman’s definition of software architecture (in essence, the high level structure of the system, described in terms of components and their externally visible properties and the relationships among them) has been very influential. While this definition has resonated with many people, the continuing discussion indicates some remaining uneasiness with definitions proposed so far. We prefer to use the Bass et. al. definition and focus on the central concerns that software architecture addresses. (You might also like to take a look at Chapter 1: Software Architecture: central concerns and key decisions.)

Complexity and Cost of Change

We need architecture to manage complexity and cost of change. Grady Booch puts it like this: “all architecture is design, but not all design is architecture. Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change.” Cost of change goes up as scope of impact increases, so this definition covers decisions relating to system decomposition as well as those addressing cross-cutting concerns. Cost of change is also high if a significant chunk of the system has to be revised or rewritten, so this speaks to challenging pieces of the system.

Big Rocks First

We use the “big rocks” metaphor (see slide 6 and 7): If we start with the big rocks, then add the pebbles, and last the sand, we fit them all into our jar. And yes, we could even add water. The point is not that we can always ask developers to do more! The point is that if we start with the sand, add the pebbles, and then try to add the big rocks, we cannot fit them all in the jar. To fit them all in, we must start with the big rocks. Architecture is about getting the big rocks in place first.

But what are the “big rocks”? The architectural elements—the components and their relationships, yes. And architectural mechanisms addressing cross-cutting concerns or systemic properties, yes. Big rocks bear a high cost of change, yes. Is there more?

Architecture Implements Strategy

The architect of early generations of HP OpenView said “Architecture is the translation of business strategy into technical strategy.” This definition focuses on the strategic nature of architecture. What is significant, in this view, is driven by what is strategic, and what is strategic determines how we will compete. How we will differentiate dictates the big things we must get right, what hard problems we will tackle, where we will innovate, and where we must be ahead of competition. And it allows us to accept good-enough along those dimensions where we are not trying to create competitive advantage. Of course, even “good enough” may be challenging, especially when taken in conjunction with where we aim to differentiate.

The business or product strategy needs to establish what differentiating value we will deliver to our customers, our shareholders, our partners in the value network and our people. The architect needs to assess what capabilities will deliver this value. Architecture is about designing system capabilities that deliver the value propositions and reinforce the identity of the system (application, product, product-line, etc.) in alignment with the business strategy.

Architecturally significant decisions are those that must be made by the person or team who has influence and perspective across the system in order to deliver on the strategic objectives of the system.

Architecture Balances Differentiation, Complexity and Cost

The architect needs to balance the need to differentiate, with the lifecycle cost of the features and quality attributes we pursue. What we need to do, just to be in the game, constrains what we can accomplish in order to distinguish our products or services and business. For example, in many systems some level of security, scalability, and disaster recovery are threshold attributes not our avenues for differentiation. So we must develop mechanisms (authentication, encryption and firewalls; load balancing; failover, etc.) to address these challenges. Just delivering the base level of features and qualities is challenging, given the threshold set by intense competition in most markets.

Others will have a say in what our opportunities are to differentiate (e.g., marketing). And others will have a say in identifying the challenges we face to build and field systems in our domain (e.g., development). The architect needs to play a role in balancing what we would like to do, with what we are able to do given our resources and capabilities.

Architecture Expands Our Capability

Moreover, the architecture needs to play a role in increasing what we are able to do, and increasing the value of what we attempt to do, by allowing focus. Focusing attention, enabling specialization and separation, understanding where outsourcing or licensing can be leveraged, reducing complexity and scope where it is not essential to our value proposition. Knowing what to focus on and knowing what we can ignore—both are key to success.

Architecturally Significant Decisions

So architecture helps us manage complexity and cost of change, and deliver differentiating value in alignment with our business and product strategy. Architecturally significant decisions are those that the architect (or architecture team) needs to make in order to address these concerns (strategy, complexity, and cost of change). They generally include the high-level decomposition of the system and address cross-cutting concerns. What we do is driven by our business strategy, how we do it is driven by cost of change.

Furthering the State of our Understanding

Whatever else you might add, I hope that in the commentary on this post, you will share as concretely as you are comfortable with given the public forum (and your level of identity disclosure),

what are the major concerns you address through architecture, and
what kinds of decisions are architecturally significant for your system?

To set context for your observations, it would be very helpful if you would provide some background, such as

what kind of system you are working on (embedded system, e-commerce system, whatever),
some indication of complexity (like size of the development team), and
what your role is.