I've just completed reading "Emergent Design: The Evolutionary Nature of Professional Software Development" by Scott L. Bain; I found the author's writing style to be engaging which made for an easy read. However, from my perspective (someone who has been in the trenches of software development for the past 20 years) I found nothing new in this book for the seasoned professional.

If you are just starting out, I would recommend this book; if you call yourself a programmer, I would recommend this book. However, if you are a trained software professional, and already understand that the phrase "software as an engineering discipline" is an oxymoron, then I would recommend you spend your time elsewhere. This book simply puts into written words what we already know -- waterfall development doesn't work for systems where the requirements aren't well understood or are subject to change during the development effort. The author adequately discusses the importance of patterns and their importance to modern software systems, the importance of paying attention to the details not found in the software, and the fact that you need to get over fear of change. In my opinion, the author does not offer any new insights.

Again, if you are just starting out, or have no exposure to object-oriented theory/practice, patterns and iterative-and-incremental development, this book is a good introductory text. If you are looking for advanced knowledge, in my opinion, its not here.

This is a very good book specially for those that are interested in learning about design patterns and applying them in your own codes.

This book rehashes the Gang of Four's design patterns and standard recommendations about XP/test-driven development. There is a lot of filler and nothing new. Read the originals; they're classics.

For a real epiphany about emergent design, I highly recommend Eric Evans' "Domain-Driven Design: Tackling Complexity in the Heart of Software".

I think of this book as answering three questions:
* what do developers need to know to work as professionals?
* how does quality coding and design play into unfolding designs?
* what is the proper way to integrate refactoring, test-driven development and design patterns in the real world?

All too long this industry has allowed individuals to do what they like instead of what their teams and businesses need. Programming is not just about individual people's opinion of approach and quality, but about real issues that have been long identified.

This book weaves the tale of what is known and how to use it in a real environment. I didn't react to this book the way Mr. Vodde did as an advertisement for Net Objectives. I like the anecdotal story telling of how this knowledge is conveyed to realy people in real situations.

Developers often talk about their problems in getting others convinced of better approaches. What better way than to hear how Mr. Bain has done this himself - something good to learn.

While this book is probably thought of as being for agile developers (those who write code in iterations) it'd be highly useful for anyone. Everybody's code needs to morph over time - even if the first release is done in a classic waterfall.

Emergent Design by Scott Bain is a interesting book. The title is very promising, when I first heard about it, I got very excited! Finally a book about how designs emerge, how designs emerge from multiple people and how designs evolve over time compared to specifying. After reading the book, I felt the book was good, but disappointing. It did not cover the topics I would like to have seen.

The general idea of the book is that software should grow better over time instead of decay over time and that the optimal design will emerge. An idea I strongly agree with. The author links this to software development needing to change to become a profession. If SW development is a profession, then people will use proper practices and design will emerge. The practices (in a broad sense) are principles of design, patterns and disciplines. After the first couple of chapters the book was having a good start, though I started wondering if the author didn't bite of more than he could chew. Those are huge topics by themselves!

From chapter 7 to chapter 14 the author just describes good practices. He starts with qualities of code and qualities of designs. He moves to unit-testing, refactoring and then Test-Driven-Development. He ends with the pattern chapter. The last chapter puts all things together in a case study. Scott does a reasonable job in describing all practices. There are a couple of weird things, like the recommendation that every class has exactly one test class. The TDD chapter also seems to have very little TDD in it :)

As a catalog of best practices, this book perhaps does the best of all the current agile related books. Great job by the author.

However, there are some things that personally bothered me. The book seems to be very pattern focused. Scott seems to be of the opinion that patterns is what hold everything together (probably everything in the world). Though, I agree that patterns are an important concept in modern software development, I wouldn't put so much pattern focus in e.g. a chapter on test-driven development. Maybe the title of the book would better be "Scott on SW design and patterns".

That brings me to another issue with the book, the title. Emergent design is an immensely important topic. How does a design start with the first requirement. How does it evolve. How do multiple people work with the design. How can the overall architecture evolve. What about items that evolve difficult, like different programming language usage etc. So much to talk about and the book doesn't do this. It misses a huge opportunity to talk about emergent design & architecture and instead (although important) decides to talk about design principles, patterns and practices. (in that sense, the book is similar to Bob Martin's "Agile Software Development: Principles, Patterns and Practices", which I would recommend over this book).

But again, the content of the book is good and useful and normally I would go for a 4 star rating, but I decided to go for 3 stars. This is because the book IMHO contains things that really turned me off.
One of the examples is the talk about professionalism. Don't get me wrong, I do agree with the author on this subject. The point is, we are not alone. In fact, IEEE has been working on certification for many years. In 1999, Steven McConnell wrote a book called "After the Gold Rush" with the subtitle "Creating a True Profession of Software Engineering". Scott talks about finally making a profession out of SW development, but he seems to have not done any research on this topic and seems to not be involved in other attempts to make it a profession. It would have increased his credibility a lot if he would have said "the earlier attempts are different because ..." or something similar.

Another item that was a huge turn-off was the constant promotion of Net Objectives. The book, at times, almost felt like a commercial. Personally, I didn't need to know about what courses Net Objectives teaches, I want to know about Emergent Design!

Anyhow, all these negative points aside, Emergent Design is a good introduction to modern agile development practices. Especially if you are not yet familiar with topics like Refactoring, TDD and patterns, this book is certainly worth reading. Next to that, Scott's writing style is funny and easy to read. So, if you belong to that group of people, recommended! Otherwise, skip it.