Architecture vs Design
By Gene Hughson
There was interesting debate on what is an architect, the difference between design and architecture (no one really knows… (Ilan Kirschenbaum, discussing a meeting of the Software Craftsmanship in Israel group)
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. (Grady Booch, as quoted by nearly everyone)
In the inaugural post of Form Follows Function, I noted the definition of architecture that I felt best applied across the realms of Application, Solution, and Enterprise Architecture. While researching the post "What's driving your architecture?", I found considerable discussion of the difference between architecture and design (in the sense of design decisions that are architecturally significant versus those that are not). Although the distinction might seem to be academic at first glance, it cuts to the heart of questions around the value of architecture and architects, particularly under Agile processes. This makes the confusion alluded to above by Ilan Kirschenbaum doubly worrisome.
Simon Brown, building on Booch's comment above, provides important insights on the concept of design in "Disambiguating architecture". Design "...exists to resolve a force on the system", where force represents "...cost, scope, resources, timescales, requirements - anything you wish to take into consideration as part of your design selection". He also notes that "...a design is one of a number of possible choices for resolving a particular force on the system". Thus design, architectural or not, can be defined as making the optimal choice to satisfy the various forces impacting the matter at hand.
Rick Kazmon and Amnon Eden, writing for the Carnegie Mellon Software Engineering Institute, identified locality as the defining characteristic of architectural design in their article "Defining the Terms Architecture, Design, and Implementation". Non-local specifications, applying to the system as a whole, constitute architecture in their opinion. According to Kazmon and Eden, "More generally, for each specification we should be able to determine whether it is a design statement, describing a purely local phenomenon (and hence of secondary interest in architectural documentation, discussion, or analysis), or whether it is an instance of an underlying, more general rule".
Eden and Kazman, joined by Yoram Hirshfeld, further expanded on this definition in "Abstraction Classes In Software Design", published in IEE Software Vol. 153, No. 4 (Aug. 2006). The authors identify global design decisions as strategic and local design decisions as tactical:
Strategic design statements
 articulate design decisions that determine the primary behavioural and structural properties of a program (software system). Strategic decisions address global, system-wide concerns and carry the most consequential implications. Strategic decisions include the choice of programming paradigm  (‘object-oriented programming’), architectural style  (‘pipes and filters’), application framework  (‘Microsoft Foundation Classes’), component-based software engineering standards  (‘Enterprise JavaBeans’), and design principles (‘universal base class’), as well as assumptions that may lead to architectural mismatch  (‘The Softbench Broadcast Message Server expected all of the components to have a graphical user interface’) and law governed regularities  (‘every class in the system inherits from class C’). Because of the consequences they carry, Strategic decisions must be made early in the software development process and should be established explicitly before any detailed design is carried out.
In contrast, Tactical design  statements articulate design decisions that are concerned with a specific module. Tactical decisions often describe a pattern of correlations between one collection of modules (objects, procedures, classes etc.) and another. Intuitively speaking, Tactical statements are ‘local’ in the sense that their scope is limited to some part of the program and not outside it. Tactical decisions include the choice of design patterns  (‘Factory Method’), refactorings  (‘Replace Conditional With Polymorphism’), and programming idioms  (‘counted pointer’), and usually are taken much later than strategic design decisions in the software development process.
Although I broadly agree with the general rule of global = strategic and local = tactical, it should not be considered an absolute. It is possible for one segment of a system to have aspects that strongly influence the overall architecture (justifying Booch's criteria for significance). This is the reason that I do not hold the opinion that functional requirements are design and non-functional are architecture.
Arnon Rotem-Gal-Oz, architecture manager at Nice Systems, identifies several aspects of architecture in his presentation "Software Architecture". Architecture comprises the major components of a system; their relationships and interactions. Data and behavior of these major components is only relevant to architecture from the point of view of the interactions between these components. Like Booch, Rotem-Gal-Oz characterizes the architecture as being the most difficult parts of the system to change. Like Eden, Kazman, and Hirshfeld, he defines architecture as the design decisions that must be made earliest in the process.
The value of strategic, foundational design decisions should be obvious. Since these aspects of the system are both difficult and costly to change, there should be considerable incentive to make optimal choices. As noted by Kevlin Henney in "What is Software Architecture?" on developerFusion:
The issue is not whether or not a system has architecture, but whether its architecture is good or not. All systems have architecture, whether intentional or accidental, explicit or implicit, good or bad – even “no architecture” systems have architecture! Having related architecture to cost of change, we have a simple way of evaluating architectural quality. It is not that a good architecture makes a system cheap to create; it is that it is also cheap to evolve. In other words, a good architecture is one in which the significance of design decisions is minimised. You are free to change many aspects of a system without the fear that such changes are challenging, costly or create a cascade of bugs. A good architecture is therefore a sustainable one.
Given the criticality of these design decisions, it makes little sense to leave them to chance. Sustainable, flexible architecture is unlikely to emerge organically. Sufficient planning and coordination will be needed from someone in the architect role (regardless of whether the role is full or part-time). Localized design decisions can then be made within that framework in a decentralized manner.
Occasionally I hear people still raising the agile mantra against Big Design/Requirements Up Front. The thing is that Agile Manifesto never said to intentionally bury your head in the sand with regards to the purpose of the system. It was a push-back against spending months in analysis without anything but documents coming out, but the goal was to reach a middle ground. Nobody ever said “no design up-front” or “no requirements up front”. (Udi Dahan from "A CQRS Journey – with and without Microsoft")Reposted from Form Follows Function