BOOK REVIEW: Emergent Design – The Evolutionary Nature of Professional Software Development
|
 by Scott
L. Bain
Scott Bain's recent book Emergent
Design - The Evolutionary Nature of Profaessional Software Development is
a perfect tome for individuals to learn the personal discipline and practices
that underlie the technical practices of Agile development: Refactoring,
Automated-Tests, Design Patterns, Test-Driven Development, Design Principles, and of course Emergent Design. It's all right
there. Throw in a sprinkle of commonality & variability analysis (CVA) ,
pathologies (code/design "smells"), programming-by-intention, along with a dash
of JUnit and Mock Objects, and this author has cooked-up one of the most useful
references to date for how to stir all of these together into a full-bodied
personal and professional discipline.
I've been very satisfied with the books and articles from
the folks over at NetObjectives for
the past several years and Emergent Design
continues that trend. This ~400 page book seems to start off a bit slow at
first. The preface
is an outstanding and concise overview of the material covered in the book, and
succinctly ties together the main concepts discussed: qualities, principles,
practices, disciplines and processes. He clearly conveys his thesis just before
elaborating on those:
 "Software development by its very nature is a
process of evolution. We do not analyze,
design, and build; we create something that works, is of high quality, and is
valuable as it stands, and then we evolve it in stages toward the product that
the world needs."
The first three chapters explore the author's personal
discovery of the nature of software development with some examples using closet
space design, and lunar space missions. We see how he ultimately concluded that
software development is really about evolving systems and how best to evolve
change-tolerant attitudes and designs that make us eager to address the
inevitable changes that happen (rather than dread them). Chapter three
in particular really keeps hammering away at the essence of embracing change
and transforming it from a feared enemy to a strategic ally.
Chapters 4 and 5 get at the essence of patterns and forces
and even discuss the work of Christopher Alexander. Chapter 6 is short and
sweet (3-4 pages) and is actually my favorite, not because of its brevity but
because of its clarity and insight. It is also where the author defines his
terms to explain what he believes emergent design to be:
"Emergent design is the process of evolving systems
in response to changing requirements, better understanding of existing
requirements, and in response to new opportunities that arise from new
technology, better ideas, and a changing world. To create efficiencies and
minimize risk, it depends on the disciplines of test-driven development (TDD) and
pattern-oriented development (POD)"
What's that you say? No mention of refactoring in that
definition? How could it be so? Fear not! Refactoring, as it turns out, is
covered as something that naturally arises out of evolution (change), TDD and
POD. It turns out that Refactoring is the disciplined way of making change. TDD
provides "coverage" for refactoring and patterns are the thing we (usually) end
up refactoring to, while at the same time we discover how to identify and
diagnose pathologies ("smells") with these refactorings. The chapter ends with
a nice pyramid showing the layers of building blocks that make-up the
discipline of emergent design:
Chapter 7 teaches us about the code qualities of
encapsulation, coupling, cohesion, redundancy, readability, testability and
also covers a number of code pathologies (usually forms of undesirable
coupling). Chapter 8 introduces fundamental design principles separation of
concerns, open-closed principle, dependency inversion, and the Gang-of-Four
design principles of: programming to an interface (not an implementation);
prefer composition/delegation over inheritance; and encapsulating "the thing"
that varies.
The remaining chapters cover coding-style, programming-by-intention,
commonality & variability analysis, TDD, refactoring, unit-testing (with
JUnit and mock objects), and patterns. The book winds down with a case study of
emergent design, and then the last 100 pages are appendices, most of which are
an overview of the patterns used in the book.
Numerous design and code examples are used throughout. The
book does not attempt to teach the scores of specific patterns and refactorings
(though it does cover more than a few). As such, the book really should not be
considered an introduction to those patterns nor to refactorings. Rather, the
book is an indispensable guide and primer to those who have learned about patterns,
refactoring and TDD, and wish to understand how to weave them all together into
a personal discipline for professional software development. Along the way it
reveals the fundamental nature of software development through evolutionary
change and relates those to first-principles that should resonate with any
experienced developer. I would highly recommend Evolutionary Design to any budding agile developer.
About the Reviewer
Brad
Appleton is an enterprise SCM/ALM solution architect for a Fortune 100
technology company. Currently he helps projects and teams adopt and apply agile
development & SCM practices. Brad also author's the Agile CM Environments blog, and is
co-author of Software
Configuration Management Patterns: Effective Teamwork, Practical Integration, the
"Agile SCM" column
in CMCrossroads.com's CM
Journal, and is a former section editor for The C++ Report. Since 1987,
Brad has extensive experience using, developing, and supporting SCM
environments for teams of all shapes and sizes. He holds an M.S. in Software
Engineering and a B.S. in Computer Science and Mathematics.
|
