Kata: Happy Numbers in Clojure

I've just dome the Happy Numbers kata in Clojure.

It's a simple kata that can be a lot of fun.

I used a mix of TDD and REPL-driven development to code it.

These are the resulting tests in Midje:

and this is the code:

To document the process I commited the code after every passing test and every refactoring. I also commited the REPL history.

You can find the commits step by step here and the code in this repository in GitHub.

I used memoize to avoid repeated computations.

In the next days I will try other suggested optimizations based on the properties of happy numbers.

Interesting Talk: "Concurrency"

I've just watched this two lectures about concurrency from the CS 61A course from Berkeley University:

• Concurrency I
• Concurrency II

Interesting Talk: "The Building Blocks of Modularity"

I've just watched this rgeat talk by Jim Weirich:

• The Building Blocks of Modularity

Refactoring Conway's Game of Life in Java

I've recently revisited the Java version of Conway's Game of Life that I did nearly a year ago, to refactor it using some of the ideas I used in my more recent Clojure version.

This is the UML for the refactored design:

I eliminated the LivingCells class that appeared in the previous design.

I pushed a lot of code from the GameOfLife class into Generation to eliminate a bit of feature envy. This is GameOfLife's code now:

and this is Generation's one:

I also refactored the tests eliminating all the checks based on strings and using constructors with variadic parameters.

Following the idea in the Clojure version I managed to simplify the Rules interface a lot:

Most of the other changes are just renaming of methods, variables and parameters.

This new code keeps the functionality and characteristics of the previous version but it's much simpler.

Kata: Bank Account in Java

Álvaro and I have been pairing lately to do a subset of the Bank Account kata that Sandro Mancuso proposed as an exercise in his Crafting Code course.

We had to write and make the following acceptance test pass using Outside-In TDD:

Given a client makes a deposit of 1000.00 on 01/04/2014
And a withdrawal of 100.00 on 02/04/2014
And a deposit of 500.00 on 10/04/2014
When she prints her bank statement
Then she would see

DATE | AMOUNT | BALANCE
10/04/2014 | 500.00 | 1400.00
02/04/2014 | -100.00 | 900.00
01/04/2014 | 1000.00 | 1000.00

The goal of the exercise was to understand the outside-in or London-school TDD style.

After the course Álvaro and I continued working on the exercise.

We had many difficulties to get used to this style for several sessions because we weren't used to test behavior instead of state. We struggled a lot because we were working outside of our comfort zone. In one of the sessions, we rushed too much trying to move forward and make the acceptance test pass, which resulted in allocating some of the responsibilities very badly.

In the end, we managed to get out of the mess we got in by slowly refactoring it to a better design.

All in all, it's been a great experience and we've learned a lot pushing our limits a bit further.

Unfortunately, we didn't commit the code after each tiny step this time, only at the end of each pairing session.
You can find the resulting code in this GitHub repository.

As usual, it's been great pairing with Álvaro, thanks mate!

Refactored Numbers Spelling kata in Clojure

I've refactored the Numbers Spelling kata I recently did in Clojure to remove some duplication.

Before refactoring it, I had to make the old spell-out-number-over-99 and spell-out-number-up-to-99 functions similar enough for the duplication pattern to emerge.

Then I could use the same function for both cases and also made some other minor changes such as using when-not form and renaming several bindings and arguments.

This is the refactored code:


You can find the code in this repository in GitHub.

Kata: Numbers Spelling in Clojure

I've just done the Numbers Spelling kata in Clojure:

These are the tests using Midje:

and this is the code:

To document the TDD process I commited the code after every passing test and every refactor. You can find the commits step by step here.

If you look at the commits, you'll notice that it took me some time to find a simple algorithm using TDD but once I found it I could simplify the code quite a bit.

You can find the code in this repository in GitHub.

Interesting Paper: "Design Patterns in Dynamic Programming"

I've just read the slides of a very interesting talk by Peter Norvig:

• Design Patterns in Dynamic Programming

Reading GOOS (XI)

These are the links mentioned in our last conversation about the 15th chapter:

• Talks:
  • La economía del refactoring. Una visión desde la gestión económica del proyecto. by Xavi Gost
  • MIT 6.001 SICP, 1986 Lecture 3A by Harold Abelson
• Posts:
  • Object Functional Patterns at C2 Wiki

Clojure Developers Barcelona: Reverse Polish Notation Calculator kata

Last Tuesday I facilitated a kata for the Clojure Developers Barcelona Group hosted by Akamon.

We've been doing several Clojure katas and talks during the last two months within a small study group (mainly composed of people who work in Akamon) as a preparation to bring back to life the Clojure Developers Barcelona Group.

This kata was the first one we did as Clojure Developers Barcelona Group.

We did the Reverse Polish Notation Calculator kata which is a very nice kata to practice.

Although 10 people had RSVPed that they were coming, in the end we were seven people: 4 Akamon workers, 2 people non-related to Akamon (a second-timer and a newcomer) and me. We formed 3 pairs and worked in the kata from 18:30 to 21:00.

I had a great time facilitating the kata, solving doubts and talking about Clojure.

If you like you can share your solution in the Clojure-Barcelona Google+ community. At the moment of writing this post, you'd find there two solutions: Rafa's and mine.

To finish I'd like to thank Akamon for hosting our events and all the attendants (Jorge, Jordi, Sergi, Álvaro, Rafa and Eloi) for their enthusiasm to learn and share in an afternoon of Clojure.

Interesting Talk: "CQRS y los beneficios surgidos de la necesidad"

I've just watched this great talk by Ricardo Borillo:

• CQRS y los beneficios surgidos de la necesidad

Reading GOOS (X)

These are the links mentioned in our last conversation about the 14th chapter:

• Talks:
  • Design How Your Objects Talk Through Mocking by Konstantin Kudryashov
• Posts:
  • JMock v. Mockito, but Not to the Death by J. B. Rainsberger
  • Is it possible to do strict mocks with Mockito?

Conferences in 2014

These are the conferences I attended last year:

• Craft, Software Craftsmanship Matters
• Barcelona Ruby Conference
• Software Craftsmanship Barcelona 2014* 
• PyConEs 2014
• Conferencia Agile Spain 2014**

* I was part of the team that organized it.
** I co-chaired the Dev Practices & Craftsmanship track.

Interesting Talk: "Is TDD dead? Of course not! But what´s all the fuzz about then?"

I've just watched this great talk by Emily Bache:

• Is TDD dead? Of course not! But what´s all the fuzz about then?

Interesting Talk: "Tell, don't wait to be asked"

I've just watched this great talk by Kevin Rutherford:

• Tell, don't wait to be asked

Interesting Talk: "Programming with Values in Clojure"

I've just watched this great talk by Alan Dipert:

• Programming with Values in Clojure