Recent Forum Posts
From categories:

After four sessions I'm still very fond of the roman calculator. Yesterday we continued the work where we started. The code was not even compilable after the last pair left it. But after 5 minutes we were up and running. And I must say it was the right decistion to continue on the code, and not to begin again as we have done several times before. Now we see some things to deal with coming up very soon in the calculator. But the best part of it is ofcourse all the discussions about TDD, BDD, and refactoring.
Yesterday we had a great discussion about

  1. why we need to refactor at all
  2. can we overdo refactoring?
  3. what is the next test after a refactoring that make the code more generalized?
  4. what happens to tests if we need to split a class

The third question was perhaps the insight-of-the-day.
After adding a test, then code just to make the test pass over and over again, we had some ugly if-statements with different cases that we wanted to refactor, generalizing just a little bit to remove all the chain of if statements, duplication, etc. The pair did it.
We got a green bar after the refactoring. Good - lets move on. But some protested when the pair wanted to go on with the next test to be able to add more functionality. What if there's something wrong with that refactoring? What if…? What assumptions have we made? Shouldn't we try to break it?
Everybody had the gut feeling that there might be some case we had left out…
The next tests proved that the gut feeling was there for a reason.

Before a refactoring, ask your self - will I generalize the code? Do I need more tests before I get going with it?
After a refactoring, ask your self - have I generalized the code? Then the next tests should be in the same "theme" as the last tests and the code I just added.

The fifth question came during the break, and also in the talk after the Dojo. Some of the participants hoped that we would come longer in the Kata soon, so we would see class splitting and all that somes with that. Of course they had real world experience of the pain of moving tests and all the decisions you have to do there. Some said that it would be fun to do a much longer Dojo, to be able to come into these questions, and that's one reason why we at Responsive have developed the "Developer training course" where you have a full day of TDD and pair programming.

A continued success by ThomasGThomasG, 30 Oct 2008 09:20

Yesterday we started our Dojo again for fall 2008.
This time we created a completely new Kata:
The roman calculator.

"As a roman clerc, I want to add two roman numerals and see the result"

And what a great Kata it is! It's perfect. Not too complicated, very suitable to do in small small baby steps.
We could really concentrate on the TDD stuff, like "what is the first test", "what will be the next test", "how to refactor this", etc. instead of all of other aspects of programming that sometimes comes up.

It will sure be fun to continue this kata next session.

/Thomas Grönwall

A new Kata is born! by ThomasGThomasG, 18 Sep 2008 11:04

First we noticed that this kata was a little harder tp get started with compared to the katas we've done earlier.

We realized ( a bit late ) that we needed to focus on either evaluating separated hands or ranking hands in a game. We got stuck a little in some implementation details, and for a moment we lost our vision. Next time we will have a better focus on whar problem we are trying to solve right now. This indicates that we need better test cases…

This kata really has a difference between acceptance tests and unit tests, and show us how that need to switch between acceptance tests and unit tests to maintain both drive, focus and vision in our testdriven development. Unit tests for drive and focus and acceptance test for vision.

We concluded in our retrospective that we should continue next time where we left of, and see how the code evolves from there. Perhaps in two groups (as we were 13 people and chances are that we will be even more next time.).

Until next time…

/ Andreas

Our first try at Texas Hold'em by AndreasAndreas, 26 Mar 2008 18:04

Yes we are. At least to start with…

/ Andreas

Re: 2008! by AndreasAndreas, 26 Mar 2008 17:54

Good that you are back! Will you be using Java and Eclipse this year too?
I don't mind, just curious.

Re: 2008! by Anonymous (83.254.47.x), 17 Mar 2008 10:41
AndreasAndreas 08 Mar 2008 13:20
in discussion Coders Dojo / Coder's Dojo in Linköping » 2008!

Welcome back to our Coder's Dojo!

Responsive has relocated the office to Mjärdevi Center and now we are ready to continue our Coder's Dojo.

Your can find the schedule on this site.

We welcome new and old participants!

/ Andreas

2008! by AndreasAndreas, 08 Mar 2008 13:20

Hittade en poster på saab med er dojo. Verkar dock vara rätt gammal, är det något som ni kör även det här året?

2008? by Anonymous (85.228.37.x), 11 Jan 2008 22:56

Thanks to all the participants for the great sessions during the spring 2007. I have now uploaded the code we wrote from those sessions to this site.

I think the Reversed Counting Code Lines Kata was really interesting. We started with code that solved most of the Counting Code Lines problem, but it was really messy, contained a few bugs and had no tests. This is the situation many of us face every day.

We started out by writing unit tests. Lots of them. It was surprisingly interesting to write unit tests for existing code when we were hunting down a bug. We had som 12-16 unit tests that covered quite a lot of the base functionality when we cought the first bug. A quick check with the coverage tool showed us which parts of the code was not tested at all. Thats a hint to be extra careful when refactoring in those areas.

With the safety net of out unit tests we started refacoring the old code. Understanding pieces of it and replacing those pieces with clearly named local functions made it easier to understand the flow of the code. Refactoring out expressions in conditional statements also added understanding and clarity.

Piece by piece the code got easier to understand and more readable. After some time we knew where to look for our bug and fix it. Then back to writing more unit tests. Finding more mugs and fixing those. The safety net of our unit tests really helped when we wanted to do more drastic things than renaming and creating local functions. It was an instant reminder when we made a change that affected something we did not think of.

In the end of the session we had fixed three bugs, created a extensive set of unit tests and refactored the code from a sloppy mess into readable, well designed code that was an excellent starting point for further development. And all this without even starting the debugger…

This exercise may be small, but is shows that there are real benefits to get from introducing unit test into existing code, and that it is not all that hard to get started.

See you after the summer for more doing while learning.


15:th of March we had 15 participants, and this time we chose to split into two groups. Since we had an extra laptop (a MacBook by the way), an extra video projector and a large enough room this was quite a simple way to ensure that everyone would be allowed to take active part in both discussions and coding. Training just isn't training if you are just watching others… We ran the Counting Lines Kata in both groups by the way. Our biggest insight from that session was that you can't take too small steps. As long as you force the implementation forward by adding tests that should always be able to run it does not matter if you solve a "whole" feature, or just a part if it. The important thing to remember is not to write tests that checks the implementation, but rather the behaviour of the class.

The 29:th of March we had 12 participants, and this time we went back to a single group. We ran the Counting Lines Kata again (I'm surprised that nobody even suggests that we should change the Kata at the retrospectives at the end of each session. I'll never get to use all my good arguments for why we should be training on "known ground"… soon I'll change Kata just to see if anyone wants the old one back!). This time, and actually the previous time, we spent a couple of minutes discussing design in the beginning. It's feels that the group is more satisfied if we put a couple of design ideas on the table, and then remove all but the simplest that could work, instead of just stating that the first one we think of is the simplest (and will work).

Tomorrow it's time for the next session. See you then?

/ Andreas

Mid-term status by AndreasAndreas, 11 Apr 2007 21:37

Today's session was crowded, but very good. 17 participants, mostly new, took on the Counting Lines kata. We started with a little design discussion (2 minutes) this time and that was definitely worth the time. Next time we will also spend a minute or two on listing a couple of testcases, setting a brief roadmap for how we want to grow our application, before we start writing the first test.

Bo Johnsson from Dataföreningen took some pictures and I hope to be able to publish them on this site soon.

I'm looking forward to the next session. I have installed the Eclemma plugin in my Eclipse so we can check code coverage afterwards, or perhaps during the development.

I should add that the code we write is available for download on the schedule page, just as last year.

Andreas Larsson

Re: Coder's Dojo 2007 by AndreasAndreas, 15 Feb 2007 19:50

OK, the dojo is back after the holidays and the darkest part of the winter.
Our first session was today 15:th of February and we had 9 participants. 6 of them were brand new but got the hang of our style of working in recored time. Finally, I can say, we have switched to a new Kata; Counting Java Code Lines. We also had our first female participant, so now that ice is broken too.

Next session is in two weeks, thursday 1 of March, 16-18 in IT-Ceum.
I hope to see you there.

Andreas Larsson
Responsive AB

Coder's Dojo 2007 by AndreasAndreas, 15 Feb 2007 19:48


då kan jag ju komma.

Nu är det bestämt!

Vi fortsätter under samma förutsättingar som förra året, fast denna termin på torsdageftermiddagar. Information om vilka dagar vi ses finns nu upplagt på denna websida. Första gången blir torsdag 15 februari och sedan var 14 dag (torsdagar på udda veckar) fram till 24 Maj. Välkommen.

Re: Blir det något mer? by AndreasAndreas, 04 Feb 2007 20:19

Ja det blir det! Vi planerar just nu detaljerna kring hur vi skall fortsätta dojo'n under våren.

Stay tuned som det heter. Information kommer inom kort till denna web, som e-post till de som deltog under förra terminen och på lite andra sätt som vi håller på att fundera ut.

/ Andreas

Re: Blir det något mer? by AndreasAndreas, 01 Feb 2007 21:02

Kommer dojo:n köra igen nu under våren?

To our third dojo, nine participants showed up. Two of them were first timers but they got up to speed really fast.
We were getting quite good at the test driven approach, and this time we got into a new design than the one we have used in previous sessions. This showed us some new refectorings that we had not tried before.

One of new participants posted this on his blog afterward.

Third Dojo by AndreasAndreas, 12 Nov 2006 09:19

Today we held our second session in the Dojo.

We had several interesting questions before the second session.

  • Would the participants come back for more?
  • Would we attract new participants?
  • Would the second session turn out similar to the first?
  • How much further into the coding challenge would we come this time?

12 brave participants showed up, same as the first time.
9 of the first timers came back! Very cool!

This session we spent less time for startup talk and less time for off-topic discussions.
Quite suprisingly, we came shorter into the solution of the coding challenge, even though we spent more time coding.
Interesting but not a problem, since the goal of our training is not to solve the problem, but rather to familiarize with test driven development.

All in all, the second session were more focussed and activated more participants into coding and relevant discussions.

Next time we are expecting a higher pace in the development cycle:

  • write new test case - to achieve red bar
  • write code to satisfy all tests - only with red bar until green bar
  • refactor for clarity, readability, maintainability, robustness, extendability etc. - only with green bar
Second training session by AndreasAndreas, 18 Oct 2006 18:31

This afternoon we held our first Coder's Dojo in Linköping!

12 courageous coders found their way to the first ever Coder's Dojo in Sweden.
We ran a randori session on the Bowling Game Kata, didn't come all the way through it, but at least we got our feet wet. The retrospective told us that we found the session interesting and well worth the time spent. Almost everyone showed their interest in coming back for another round in two weeks.

The code from this session is avaiable from the schedule page.

Any comments from the participants (or others) are greatly apprechiated on this forum!

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-Share Alike 2.5 License.