Book Review of “The ThoughtWorks Anthology: Essays on Software Technology and Innovation”

My very short review of The ThoughtWorks Anthology. The ThoughtWorks Anthology contains 13 essays on software development from different people. The quality of the essays varies widely but in the end: Recommended.

Solving the Business "Last Mile"
Excellent. Worth the book alone. This essay will lead the community to accept that there is a growing last mile problem for companies between the end of development and the going live.
One Lair and Twenty Ruby DSLs
Nothing really new, but an extensive overview over several DSL techniques in Ruby.
The Lush Landscape of Languages
Sub-par. Only interesting if you know nothing about the differences in programming languages. Filler stuff.
Polyglot Programming
Awful. For an explanation see below.
Object Calisthenics
Interesting and thought provoking. Could make you a better developer.
What is an Iteration Manager Anyway?
Good new insights about the general role of Scrum Masters and other Iteration Managers in agile projects.
Project Vital Signs
The team mood chart is genius.
Consumer Driven Contracts: A Service Evolution Pattern
Do your SOA from the consumer side not the provider side, excellent idea.
Domain Annotations
Very good! If your into Domain Driven Design, a must read.
Refactoring Ant Build files
I've been developing Ant build files since the beginning of Ant, but still got some insights.
Single-Click Software Release
Some good points for the deployment process, worth reading.
Agile vs. Waterfall Testing for Enterprise Web Apps
Overview of testing methods and how the fit for agile, solid but could have more punch.
Pragmatic Performance Testing
Sorry to the author, I didn't read this one 🙂

Let me illustrate how bad some parts of the book are. One essay with a clear bias against Java wants to establish how awful Java is and how wonderful other JVM languages like Groovy and JRuby are. After a distorted line number example there is an even more distorted isBlank example. For Java the author presents an implementation from Jakarta Commons, a heap of notoriously bad code.

public static boolean isBlank(String str) {
 int strLen;
 if (str == null || (strLen = str.length()) == 0) {
  return true;
 }
 for (int i = 0; i < strLen; i++) {
  if ((Character.isWhitespace(str.charAt(i)) == false)) {
   return false;
  }
 }
 return true;
}

For comparison the JRuby example (which has other performance and memory characteristics) is short

class String
  def blank?
      empty? || strip.empty?
  end
end

One who is moderatly fluent in Java would write the following code though:

  public static boolean isBlank(String string) {
    return isEmpty(string) || (isEmpty(string.trim()));
  }

  public static boolean isEmpty(String string) {
   return null == string || string.length() == 0;
  }

Not as nice and short as the JRuby example, but much better than the ugly Commons example. And with static imports the methods aren't that ugly to use than before in Java. A isBlank("Hello") works.

But beside some bad essays the book is worth it's money (Well it is cheap).

Thanks for listening.

Update: Lowell: "If you are using Java 6, there is a new method: String.isEmpty(). You could use that in your Java example and then you wouldn't need to write your own." Thanks.