The Thoughtworks Anthology

Thu, Dec 27, 2012 5-minute read

The Thoughtworks Anthology is a collection of essays written by ThoughtWorkers about different aspects of Software Engineering.

The topics span from pure coding to team working, from operations to development methodology. If you work in Information Technology you can easily find (at least some of) these essays very interesting.

Among the others,I particularly liked Martin Fowler (Yes, that Martin Fowler) code kata describing different ways to implement Domain Specific Languages in Ruby. It presents different approaches and, more important, the essay talks about the design decisions and their implications.

If you are reading this blog you probably like programming languages. The book contains a very nice survey on different language features by Rebecca J. Parsons. For each feature she gives a short but complete description and describes what it does imply for a language to have or to miss it.

Talking about the right tool for each job, Neal Ford wrote an essay about polyglot programming. He shows how we can leverage features of different languages in our applications. We simply need a common runtime environment, such as the Java Virtual Machine or the CLR, and use the various languages that compiles to its bytecode.

Jeff Bay’s Object Calisthenics is awesome. I’m not going to tell you more because I’d like to try to follow that rules in a toy project. So expect (sooner or later) a more detailed post about my take on that exercise. Those are the rules:

  • One level of indentation per method.
  • Don’t use the ELSE keyword.
  • Wrap all primitives and Strings in classes.
  • First class collections.
  • One dot per line.
  • Don’t abbreviate.
  • Keep all classes less than 50 lines.
  • No classes with more than two instance variables.
  • No getters or setters.

Are you going to follow them in your next project?

These were the most code intensive essays, and you shouold not be surprised that I liked them the most. However you will find a lot of other essays on different topics:

  • What Is an Iteration Manager Anyway? by Tiffany Lenz. Because you need to organize your work. You can’t code for the sake of coding.
  • Project Vital Signs by Stelios Pantazopoulos. That gives you some useful metrics you can use to monitor the health of your projects.
  • Consumer-Driven Contracts: A Service Evolution Pattern by Ian Robinson. How to evolve services without breaking existing code.
  • Domain Annotations by Erik Doernenburg. Modern programming languages provides you with ways to annotate your code. Use annotations to represent domain concepts and get a better design.
  • Refactoring ANT Build Files by Julian Simpson. Sometimes you consider worth refactoring only the actual code. In reality, everything you produce should be as clean and as well factored as possible.
  • Single-Click Software Release by Dave Farley. Release automation. I don’t think I should add anything. Just do it.
  • Agile vs Waterfall Testing for Enterprise Web Apps by Kristan Vingrys. A comparison on testing as performed in these two opposite approaches.
  • Pragmatic Performance Testing by James Bull. Testing non functional requirements is hard. Let’s make it easier with a pragmatic approach.

The Good Things

The book covers a lot of different topics. It probably attracts you with the essays about the things you like the most and then it will give you the opportunity to think about other aspects of software development.

I started reading the book to learn more about coding and then it made me think about other things. I think that this is one of the most important reason to read the anthology rather than searching the web for essays on a specific topic.

There is a lot of code and it is well balanced with explainations of the design concepts behind it. The code gives you the feeling that you’re reading something ‘real’, while the explainations allows you to get the reasons why it is done that way.

Most of the sections gives you hints about design techniques that you can apply in all your projects, regardless of the technologies used to write the examples.

The book covers both mainstream technologies and ‘the new cool stuffs’. Some sections are about Java and .Net, while in others you’ll learn (a little) about the features of Ruby, Haskell, LISP, Scala, Groovy. You are not going to get all the details, but at least you’ll know what each language is good at and when you should think about using it.

What Should Be Improved

Some of the examples are not future proof as they talk about some specific technology. For instance, the section about ANT files was not too appealing because I am a Maven or sbt user and I rarely have to write ANT tasks. Nonetheless, after I read it, I realized that the principle of trying to have everything as clean as possible is really valuable. Even if I’m not going to write an ANT task I should apply the refactoring techniques described in the essay to something else.

A couple of sections are too enterprise-oriented for my taste. But it may be me. And, as I mentioned before, I had the chance to read something about the enterprise world while usually I don’t search for articles about it. So this is more a drawback with respect to what I like the most rather than with respect to what I find useful and interesting.

If you liked this book you should check the other reviews I wrote. And stay tuned for the review of the Volume 2 of the anthology. I’m reading it and so far I can say that it is at least as good as the first volume.