This anthology marks the first of multiple anthologies that ThoughtWorks published.

Chapter 2: Last Mile - Roy Singham & Michael Robinson

Precursor for Continuous Delivery. Including non functional requirements at start of development cycle.
Doesn’t really provides ideas into how to avoid getting slow to release after growth. More into saying that just not pating attention will make it worse.

Chapter 3: Ruby DSL - Martin Fowler

Examples of various forms of describing a specific thing. Lacks describing what a DSLs is or exposing trade offs about generalization and specification of the language. Some cool patterns for those that have never written a language.

Chapter 4: Languages - Rebecca Parsons

A brief summary of concepts of programming languages. Tries to keep the concepts around more modern languages to talk to existing business. This ends up creating some awkwardness since most modern languages are a big mess of concepts.
The academic approach to start with "pure" languages and move to the mistures seems better.
Good different between imperative and procedural.

Chapter 5: Polyglot programming - Neal Ford

A praise to the JVM (and CLR... And .Net) to its ability to support multiple languages. The idea that certain languages are better for certain problems. No mention of the cost and difficulties of maintaining such diverse code bases and the concept mixtures (and mistakes) caused by inexperience with pne or another language.

Chapter 6: Calystenics - Jeff Bay

Rules to improve OO code. Very java oriented even if ruby could follow it.
Some of the rules need to improve but still worth the exercise.

Chapter 7: Iteration manager - Tiffany Lentz

Description of an IM's responsibilities. Nice.
Lacks a bit of elaboration into why one would not be able to perform this work along with PM.
Also one worrying part is that 'the IM runs the retrospective'. This concentration of responsibility & power is a bit scary.
Finally, there is no mention about how the IM interacts with the PM and that sounds wrong.

Chapter 8: Radiators - Stelios Pantazopoulos

Very basic radiator examples with few warning on metrica miss use and miss interpretation. To add to it, the examples provided picture a project with serious problems described as "on track". Not very recommended reading. Need to find a better sugestion for the topic. Chapter also lacka a summary

Chapter 9: Service contracts/evolution - Ian Robinson

Basic ideas behind my evolutionary systems talk heavily focused in XML soap interactions. Applicable only in environments where all consumers of the service are "under control". Idea is in general that service contracts should be an aggregation of minimalist consumer contracts.
Json culture seems a lot more into this than xml.

Chapter 10: Domain annotations - Erik Doernenburg

Goal here is to implement certain business logic that may not seem 100% natural in the domain object using annotations. I have mixed feelins on this one. It looks to me like the example is not good enough to capture the real motivation behind it. The way it is presented it just looks like a bad way to separate responsibilities between domain objects and persistance details or other business rules that suld be represented in other objects.

Chapter 11: Ant refactoring - Julian Simpson

Aged a lot. Very specific to ant. Could have abstracted some ideas.
Some refactorings are a bit confusing.

Chapter 12: One click deploys - Dave Farley

Build pipekine description. Addresses the problems and concerns that motivate a build pipeline. Hasnt aged very much. The technical details are easily ignorable and the lesson still applies.
Pretty good piede of advice for those who are yet trying to automate their deployment. If you are already trying then this article offfers little value.

Chapter 13: Testing in agile projects - Kristan Vingrys

Very basic article. Talks essentially about the different types of tests., who is responsible for them and when they are executed. It emphasyses a lot automation but doesn't explain the problems that one may find hile trying to automate all. It also doesn't explain how to transition from one style of testing (waterfall) to another.

Chapter 14: Performance testing - James Bull

Calls out for more dedication regarding performance testing. Explains the ideal scenario where perf testing happens early on a dedicated environment and points how to downgrade the environment for those tests. Obviously biased article that doesn't talk about the costs associated with performance testing against the benefit it brings. Also doesnt address how to detect, after a test failure, where the bottleneck is and lets that to the developers. Doesnt address profiling or granularity of results.

Overall:

The book has somehow aged. Sill has interesting ideas for people who have not been doing agile. Most of the articles are a lot more about what to do and less about how to get there which makes the
whole of it a bit harder.