I’ve read this book Diseño Ágil con TDD (Spanish) by Carlos Blé from cover to cover, when previously I had only read the theoretical parts (Part I and Chapter 12 in Part II).

It’s worth noting that this is the first TDD book in Spanish (I haven’t found any book in Spanish predating this one - also backed by the author; published in January 2010) and, as such, there are some translations that could be improved. Not that it makes it more difficult to read. Sometimes it’s a good idea to roughly translate concepts into English and then you’ll understand the point.

First part

The first part is very interesting, a theoretical introduction into TDD, ATDD and Agile methodologies. Points to some good books as a reference (e.g., Growing Object Oriented Software, Guided by Tests; Working Effectively with Legacy Code; Refactoring; etc)

He explains the TDD algorithm (chapter 2) and the ATDD one (chapter 3). These two are maybe the two most important ones on the book. Should you read only a part of this book, I’d recommend to read the motivational intro (the fable on the preface) and these two.

He gives excellent pieces of advice who, correctly applied, would set the basis for good software development, such as SOLID, Object Oriented Design (OOD), Inversion of Control (IoC), etc. (See chapter 7, “Diseño orientado a objetos”).

There’s a chapter (number 6) on “Mocks and other test doubles” (translation is mine)

Second part

The second part, as many other books where the source code is printed, was dense for me. Other books, such as GOOS, show differences in content with bold typeface, to ease the reader’s task. In my opinion, it would be useful to color the diffs, show them on the left and right, or even show the raw diff (e.g., +++ ---). I’m envisioning a typing program as LaTeX where you could specify a commit with its parent and a range of lines to output.

The second part is written in C# and python, to show a TDD session with him. Warning: it’s much better in person than reading his book!

The chapter 12 is a set of antipatterns you might find after starting with TDD. Even after you keep practicing TDD for a while, you will not get rid of these smells. Highly recommended.

There’s also an appendix on Continuous Integration, although there are better books for this.

Conclusion

Recommend this book if you are starting with TDD, or you are more advanced but it’s difficult for you to read in English.

Always good as a refresher to read the theoretical part and the antipatterns

PS: This book is free to read, published under a Creative Commons license (don’t know exactly which one)

After reading (in a specific order - below) part of the patterns in Apprenticeship Patterns, I stumbled upon the “Your First Language”

First of all, the illustration with the baby reading a Java book is priceless.

Having said that, I came to the realization that you might not know a paradigm but just an implementation (e.g., you don’t know about Object-Oriented programming but just about Java), in the same fashion as you could not know about LISPs but only about an implementation, such as clojure.

Also, clicks with the idea of “code to interfaces, not implementations”. Does it also click with you?

PS: What a great book this is. I’m reading it as explained here ¹

PPS: you can read it online for free, here

Some weeks ago I listened to some podcasts from BastaYaDePicar (episodes 1 to 8) and now I’m listening more (9 to 10). I really recommend these to you, and I imagine that the newer episodes (also new format) will be interesting too.

They’re in Spanish and narrated by Sebastian Hermida

Following a team member’s recommendation, I recently started a repository to save all my useful snippets.

I’ve decided that the examples should be designed guided by tests or at least to have a working example exercised by tests. Also, that I should not reinvent the wheel and use as many open source libraries as possible, reducing the amount of code I have to write myself.

Ideally, every snippet should be a maven project (where applicable) and be imported as a small library, therefore being able to reuse the functionality incrementally across projects.

For the time being, I’m saving my snippets into a private repository and later I might decide to publish it for common usage.

Manuel Rivero and I did a subset of the bank kata, proposed by Sandro Mancuso.

We’ve used java (mockito, hamcrest, junit), outside-in TDD. The code is spread among several sessions. We have not committed after each step, only at the end of the session.

The source code is on github

You can read Manuel’s take on the kata on his blog

Last year we started the program 12 months, 12 katas (as inspired by this repository). This year we want to propose something different: an asynchronous code jam

New problem: Mini-Power Swapper

This post belongs to a series: code-jam

Each month (or so) we at GMaur will publish a new problem (and announce it on twitter) and post a solution to the last problem.

This month, the Mini-Power Swapper

You can fork the repo, commit there and send a pull request. We’ll review the code (if you want) and merge the solution to a branch in “solutions/”.

Happy katas and happy code jamming!