Meera has posted 70 posts at DZone. You can read more from them at their website. View Full User Profile

Book Review: The ThoughtWorks Anthology

06.11.2008
| 9226 views |
  • submit to reddit
Published by: Pragmatic Bookshelf
ISBN: 193435614X

Reviewer Ratings

Relevance:
4

Readability:
5

Overall:
4

Buy it now

One Minute Bottom Line

This book well justifies its addition to the prestigious ranks of Pragmatic Bookshelf. It is well taken and timely, some of the material covered is just great. This is the real book you need if you are using TDD or planning to, an absolute must-read on the subject.

Review

Solving the Business "Last Mile". This essay is written by Roy Singham, and Michael Robinson. As many of us have seen in the software industry, there are many challenges which remain during the "last mile" of software development. To quote from their essay "This "last mile" is the part of the process that happens after the software satisfies the functional requirements but before the software goes into production and starts to deliver value to the business". They help us understand exactly what this "Last Mile" problem is, how to solve this problem by reexamining the role of people and automation." An excellent essay which I think every stake holder in software development has to read.

One Lair and Twenty Ruby DSLs. This essay by Martin Fowler is all about Ruby and many more DSL techniques. I should be honest here and say I know Groovy, but have not tried Ruby yet. Since I don’t have any expertise in this subject, I am just going to skip this essay.

The Lush Landscape of Languages essay is written by Rebecca J. Parsons. If you want to know the differences in programming languages you should read this essay. Rebecca, examines some specimens and in the process starts to develop a tree like structure for languages. She than looks at old and new languages, showing us what are some major things for which these particular languages are known.

Polyglot Programming by Neal Ford, Meme Wrangler. Authors in this essay start off by explaining what polygot programming is by saying "The word polyglot means speaking many languages. Polyglot programming leverages the separation of language and platform in Java (and in C# as well), allowing developers to use specialized languages to solve specific problems. We now have hundreds of languages that run on the Java virtual machine and the .NET managed runtime. Yet, as developers, we don’t leverage this capability enough.". In the next few sections, they show us some examples of applying polygot programming
1. Reading Files the Groovy Way

Here is a sample of applying ploygot programming:

package com.nealford.polyglot.linenumbers;

import java.io.*;
import static java.lang.System.*;

public class LineNumbers {
public LineNumbers(String path) {
File file = new File(path);
LineNumberReader reader = null;
try {
reader = new LineNumberReader(new FileReader(file));
while (reader.ready()) {
out.println(reader.getLineNumber() + ":"
+ reader.readLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
reader.close();
} catch (IOException ignored) {
}
}
}

public static void main(String[] args) {
new LineNumbers(args[0]);
}
}

The solution the author shows doing the Groovy way:

def number=0 
new File (args[0]).eachLine { line ->
number++
println "$number: $line"
}

2. JRuby and isBlank
3. Jaskell and Functional Programming
4. Testing Java
And they finally finish off this essay by a section on polygot programming the future.

Object Calisthenics essay written by Jeff Bay, is just awesome and helps every developer to write better code by following nine steps. He starts this essay by saying "We've all seen poorly written code that's hard to understand, test, and maintain." I doubt anyone would disagree with the above quote. He than explains in detail the nine rules we can follow to develop better software. Here are the nine rules that Jeff explains in detail:

I am sure in most projects we hear teams saying that the best practices or good practices whatever you call can't be implemented on real working systems. I would say to each one of them, read this essay and the final note which Jeff concludes "On a final note, some might see these rules as overkill or impossible to apply in a real working system. They would be incorrect—I'm finalizing a system as this book goes to press that has more than 100,000 lines written in this style. The programmers working on this system routinely follow these rules and are each overjoyed to see how much less tiresome development can be when embracing deep simplicity."

What is an Iteration Manager Anyway? by Tiffany Lentz. In this essay Lentz highlights the function and value of having an iteration manager as a member of a software team. The author looks at the limits of an iteration manager's responsibilities and discusses how iteration managers play a major role in maintaining a healthy environment amidst organizational and cultural challenges.

Project Vital Signs by Stelios Pantazopoulos. This essay proposes simple, practical, simple approaches for capturing a near real-time summary of a project's vital signs and to effectively communicate those vital signs to the project team members and stakeholders. The author starts off by explaining the project vital sign, and compares it with project health and also information radiator. Next, he explains the major elements of project vital signs such as :

  1. Scope Burn-Up
  2. Deliver Quality
  3. Budget Burn-Down
  4. Current State of Implementation
  5. Team Perceptions

Consumer Driven Contracts: A Service Evolution Pattern by Ian Robinson. This essay was excellent for me because it corrected years of doing SOA the wrong way. Before, I did SOA from the provider side and now thanks to Ian Robinson I have learnt to do it the right way.

In this essay, Ian Robinson discusses how service contracts are often implemented and consumed which in turn lead to overly coupled services. To fix this issue he suggests orienting service provision around consumer contracts.Next he shows how adding schema extension points and performing just enough validation of received messages are two well-understood strategies for mitigating the coupling issues. And in the last few sections he explains in detail about the consumer-driven contract pattern which is targeted primarily at service communities in which consumers can be identified and influenced.

Domain Annotations by Erik Doernenburg. For those of you who are into domain driven design, this is a must read chapter. It discusses in great length how annotations in Java and attributes in C# have added a construct to these programming languages that enables developers to express metadata in a clear and extensible way.

Refactoring Ant Build files by Julian Simpson. Simpson starts off this chapter by giving us a brief introduction about what refactoring is and what Ant is, followed by when you should refactor and when you should runaway. Yes, I have thought of running away quite a few times after seeing the build files at a few places. No kidding here.
The author in the next section called "Ant Refactoring Catalog" explains with a brief description, and an example of refactoring in action. To name a few:

A sample of how the author tells us to extract a traget:

Before Refactoring:

<target name="test" >
<javac srcdir="${test.src}" destdir="${test.classes}" >
<classpath refid="test.classpath" />
</javac>
<junit failureproperty="test.failure" >
<batchtest todir="${test.results}" >
<fileset dir="${test.results}"
includes="**/*Test.class" />
</batchtest>
</junit>
</target>

After Refactoring:

<target name="compile_tests" depends="compile_code" >
<javac srcdir="${test.src}" destdir="${test.classes}" >
<classpath refid="test.classpath" />
</javac>
</target>
<target name="unit_tests" depends="compile_tests" >
<junit failureproperty="test.failure" >
<batchtest todir="${test.results}" >
<fileset dir="${test.results}"
includes="**/*Test.class" />
</batchtest>
</junit>
</target>

Single-Click Software Release by Dave Farley. If you are planning on building an end-to-end continuous integration release systems that will deploy large, complex applications to whichever environment we choose at the click of a button, than this is the chapter you need to read. Dave Farley, shows us the process which is based on the idea of a release candidate progressing through a series of gates. The author explains in this essay the sequence of gates as shown below in one of the example process steps.


Agile vs. Waterfall Testing for Enterprise Web Apps by Kristan Vingrys. If you have never worked on an agile project, or have just started an agile project and need some guidance, this essay is for you. The essay gives a good overview of the testing life cycle, the different types of testing, and testing environments in the first few sections. Then the author covers topics such as issue management, the tools you need to use for testing purposes, reports and metrics. The essay is concluded with discussing the testing roles for different members.

Pragmatic Performance Testing by James Bull. Yet another brilliant essay written by James Bull. This essay gives us an insight about what performance testing is, and gives detailed explanation about the four key elements: requirements, product performance data, communication, and process. The author concludes this essay by explaining how to link all these together, how not to drop behind, and finally once an issue has been identified that something gets done about it.

Published at DZone with permission of its author, Meera Subbarao.

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)