What are the ingredients of robust, elegant, flexible, and maintainable software architecture? Over the past couple of years, my colleague Georgios Gousios and I worked on answering this question through a collection of intriguing essays from more than a dozen of today's leading software designers and architects.
The result is the book
Beautiful Architecture: Leading Thinkers Reveal the Hidden Beauty in Software Design,
which was published by O'Reilly a few days ago, and
is now available from amazon.com through
In each essay, contributors present a notable software architecture,
and analyze what makes it innovative and ideal for its purpose.
Some of the engineers in this book reveal how they developed a specific
project, including decisions they faced and tradeoffs they made. Others
take a step back to investigate how certain architectural aspects have
influenced computing as a whole.
In this book you'll discover:
The book begins with a preface Stephen J. Mellor presenting his view of the universal principles of an architecture that can be called beautiful. We organized the contents of the book around five thematic areas: overviews, enterprise applications, systems, end-user applications, and programming languages. There is an obvious, but not deliberate, lack of chapters on desktop software architectures. Having approached more than 50 software architects, this result was another surprise for us. Are there really no shining examples of beautiful desktop software architectures? Or are talented architects shying away from an area often driven by a quest to continuously pile ever more features on an application? It would be interesting to see comments on these issues.
The book's first part examines the breadth and scope of software architecture and its implications on software development and evolution.
Chapter 2 A Tale of Two Systems, by Pete Goodliffe, provides an allegory on how software architectures can affect system evolution and developer engagement to a project.
Enterprise systems, the IT backbone of many organizations, are large, often tailor-made, conglomerates of software usually built from diverse components. They serve large, transactional workloads and must scale along with the enterprise they support, readily adapting to changing business realities. Scalability, correctness, stability, and extensibility are the most important concerns when architecting such systems. This part of the book includes some exemplar cases of enterprise software architectures.
Chapter 3 Architecting for Scale, by Jim Waldo, demonstrates the architectural prowess required to build servers for massive multiplayer online games.
Chapter 4 Making Memories, by Michael Nygard, goes through the architecture of a multi-stage, multi-site data processing system and presents the compromises that must be made to make it work.
Chapter 5 Resource-Oriented Architectures: Being "In the Web", by Brian Sletten, discusses the power of resource mapping when constructing data-driven applications and provides an elegant example of a purely resource-oriented architecture.
Chapter 6 Data Grows Up: The Architecture of the Facebook Platform, by David Fetterman, advocates data-centric systems, explaining how a good architecture can create and support an application ecosystem.
Systems software is arguably the most demanding type of software to design, partly because efficient use of hardware is a black art mastered by a selected few, and partly because many consider systems software as infrastructure that is "simply there". Seldom are great systems architectures designed on a blank sheet; most systems that we use today are based on ideas first conceived in the sixties. The four following chapters walk you through some innovative systems software architectures discussing the complexities behind the architectural decisions that made them beautiful.
Chapter 7 Xen and the Beauty of Virtualization, by Keir Fraser and Derek Murray, gives an example of how a well-thought of architecture can change the way operating systems evolve.
Chapter 8 Guardian: A Fault-Tolerant Operating System Environment, by Greg Lehey, presents a retrospective on the architectural choices and building blocks (both software and hardware) that made Tandem the platform of choice in high-availability environments for nearly two decades.
Chapter 9 JPC: An x86 PC Emulator in Pure Java, by Rhys Newman and Christopher Dennis, describes how carefully designed software and a good understanding of domain requirements can overcome the perceived deficiencies of a programming system.
Chapter 10 The Strength of Metacircular Virtual Machines: Jikes RVM, by Ian Rogers and David Grove, walks us through the architectural choices required for creating a self-optimizable, self-hosting runtime for a high level language.
End-user applications are those we interact with in our everyday computing lives, and the software that our CPUs burn the most cycles to execute. This kind of software normally does not need to carefully manage resources or to serve large transaction volumes. It does need however to be usable, secure, customizable, and extensible. These properties can lead to popularity and widespread use and, in the case of free and open source software, to an army of volunteers willing to improve it. In this part, the authors dissect the architectures and the community processes required to evolve two very popular desktop software packages.
Chapter 11 GNU Emacs: Creeping Featurism Is a Strength, by
explains how a
set of very simple components and an extension language
can turn the humble text editor into
an operating system
the Swiss army knife of a programmer's toolchest.
Chapter 12 When the Bazaar Sets Out to Build Cathedrals, by Till Adam and Mirko Boehm, demonstrates how community processes such as sprints and peer-reviews can help software architectures evolve from rough sketches to beautiful systems.
As many people have pointed out in their works, the programming language we use affects the way we solve a problem. But can a programming language also affect a system's architecture and, if yes, how? In the architecture of buildings, new materials and the adoption of CAD systems allowed the expression of more sophisticated and sometimes strikingly beautiful designs; does the same also apply to computer programs? The last two chapters investigate the relationship between the tools we use and the designs we produce.
Chapter 13 Software Architecture: Object-Oriented Versus Functional, by Bertrand Meyer, compares the affordances of object-oriented and functional architectural styles.
Chapter 14 Rereading the Classics, by Panagiotis Louridas, surveys the architectural choices behind the building blocks of modern and classical object oriented software languages.
Finally, in a thought-provoking Afterword, William J. Mitchell, an MIT Professor of Architecture and Media Arts and Sciences, ties the concept of beauty between the building architectures we encounter in the real world and the software architectures residing on silicon.Read and post comments, or share through
Last modified: Wednesday, February 4, 2009 12:48 am
Unless otherwise expressly stated, all original material on this page created by Diomidis Spinellis is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.