Why Most Solutions to Gilded Rose Miss The Bigger Picture


A couple years ago, I had the pleasure to work with one of the best teams I have ever and probably will ever get to work with again. There was a certain amount of magic we had over the span of a few months that I will probably be chasing the rest of my professional life. I still have links to the members of that team on my blog titled "Team Awesome", even though I have long sense moved on and so have many of them.

One of the things that made this team so spectacular was the constant dedication to learning and helping to make each other better. We even had management's buy off and encouragement which is a rare golden egg. They let us get away with a lot in the name of learning.

At one point we started having team competitions around Code Katas. One member would present a Kata and the other team members would have a week to come up with their best implementations. The presenting member would then publicly critique the implementations and pick a winner. This critique was really cool because you learned a lot about what the presenter considered important and how they thought about problems.

One of these little competitions lead to Terry Huges presenting The Gilded Rose Kata. He actually wrote it himself while he was deep into his infatuation with World of Warcraft. I loved it so much I blogged about it and even put up a starter project on github. The basic gist of the kata is this: Here is a piece of crappy legacy code that works. Along with it goes a textural description of what the code does, some modifications the customer wishes you to implement and some constrains you need to adhere to.

I also posted it to the Software Craftsmanship mailing list, a popular programming meme that I was infatuated with at the time. They went gaga for it. Todd Sedano at Carnegie Mellon University used it in his craftsmanship course. And most receiently, Emily Bache included it in her book The Coding Dojo Handbook.

A couple of things that gnawed at me about the proliferation and spread of the kata where that most of the early commenters credited me as the author, which seems to be mostly resolved with most modern references to the kata. To be clear, it was all Terry. I just really liked the concept.

I was also bugged by all the ports of the kata into different programming languages. The original was done in C#, using the most basic console program structure. Within a week there were Java, Ruby, JavaScript and Python versions. Currently you can find C, C++, SmallTalk.. pretty much any language you would care to do the kata in. I have not seen one in Lua, but it would not surprise me in the slightest. Just hit github and search for Gilded Rose and you will find what you are looking for.

I found this ironic considering the kata is about inheriting someone else's code and having to implement new features while ensuring that you do not break existing features. The obvious choice to accomplish this is to reimplement in another language.

Imagine you having a conversation with a client that goes some thing like this.

Client: I have this system that a developer who is no longer here wrote a couple years back. The system has been running solid for a long time, but I would like to make a couple modifications. These modifications should be pretty simple. Can you give me an estimate on what you think it would take to implement them?

Programmer: Sure! This is totally doable. The first thing we need to do is rewrite the entire app in another language.

Client: ... Really? That seems a bit redundant.

Programmer: Next up we will need to recreate our production environment to support running the new languages platform. Oh and we better migrate all of our data to a new Database platform as well.

Client: .. But how does that help with implementing the new features? This application has run for several years on the existing hardware costing me next to nothing.

Programmer: Oh and now that I think about it we will need to fire all our production support staff and hire new people who understand the new hardware, OS and database infrastructure.

Client: ...

Programmer: After all that, it will be a breeze to implement these new features.

Now I realize that katas are meant to be simple problem solving exercises that allow you to practice your skills. But I would suggest that one of the skills you should be practicing is entering an unfamiliar environment and being productive quickly. I would like to challenge the kata community to attempt the original kata. See what it is like to live in somebody else's shoes and be productive.

If you can't bring yourself to taint your machine with a .NET environment, give it a shot with Mono it runs fine. Or you could pick some other programming environment that you are less than familiar with, there are certainly enough ports of the original. ;)

Follow me on Mastodon!