Skip to Content

At TechEd this year in Amsterdam I got the opportunity to arouse Marilyn Pratt’s curiosity for some gamification we applied to our development process and she asked me to write a blog about it.

And if someone like Marilyn asks kindly, you cannot reject. So let me introduce you to a game we played among the developers. Let me first explain to you my motivation:

As in every custom development, one somehow has to ensure coding quality. Usually, this leads to code reviews which are one-on-one discussions about one specific part of an application which the culprit (developer owning the code) has produced. The sheriff knows how it’s supposed to be and documents the failures (such as not adhering to the most important naming conventions) neatly in one or the other form of virtual paper. This artifact of bad style is then passed on to the quality team which magically somehow derives figures from that which are – well, we don’t have to proceed with that; I believe you got my intention and you are surely figuring: I don’t like it too much. And don’t tell me that everything will be better with code inspections and an objective reader! It’s not that I believe that there should not be something like responsibility for code and that it’s not good to check the quality by someone who should know it better. I simply don’t like the side effects (given non-perfect code, of course):

  1. In a review, it’s really tricky not to blame the author. Particularly for me: I’m very passionate when it comes to code and knowing that the person sitting opposite to me has hurt the system with the way he implemented brings out the Batman in me – or at least Robin (Hood). As I’m emotional too I have to really control myself not to jump at the poor code-owner or at least yell out loudly (though I managed not to yell a people anymore).
    All this is not only bad for the mood of the culprit, it’s also bad for the efficiency of the review: The developer usually either concentrates on defending, rather than on understanding my and the system’s pain or he completely gives up and simply agrees to everything I say – which has the same effect on not-learning.
  2. Assuming that there is some learning within that session, this is restricted to the attendees, so usually two or three persons. Sharing the learning is an extra effort and leads to a continuously enlarged lists of Dos and mostly Don’ts which no developers looks at – before he’s “invited” for another trial.
  3. The experienced reviewer is usually one of the key-resources of the project – otherwise, he’d not be the experienced one. And his time is valuable and very limited. Having that guy review one artifact of each developer sequentially means that the code reviews are effectively even more expensive than on paper. This corresponds to the last aspect of why I rant about that process:
  4. Time. There is no spare time in a development project. Particularly not for the knowledgeable guy. From my experience, this is one of the reasons why reviews are skipped, shortened to duration where it’s not possible to really discuss and learn. Alternatively, they are being held toward the end of the project (into the component testing phase or even later, whenever seems to be “enough sparse time”). After the review, the poor culprit understands that he has misunderstood a general concept and has to change that finding in multiple resources which he has created during the last year and thus invalidates the first phases of testing.

Having experienced what I said from both sides, I thought about how I could change the code-quality-assurance in my project in such a way that I like it. So let me explain to you what are my objectives are when having code reviewed:

  • Finding errors in code. Of course, this is one intention and I’m quite sure we all agree on that. But I’m talking about errors here. Not naming conventions – unless they produce the error of making the code hard to understand. And yes, we do have naming conventions, but let’s not discuss about that, as this is not core of this blog.
  • Even more important to me: Sharing knowledge. Someone knowing why something is not good to do and what the alternatives are will not only like to correct his code, but he will also not do this again. And he will share his proudly acquired knowledge with others, if he’s an outgoing person.
  • Having fun. This is a core goal of everything I do, so this has to be an objective of this task as well. And actually, it’s not difficult. Assuming that producing code is something a developer likes to do, he also likes to talk about it. Everybody likes to be engaged in something he likes to do and talking is one kind of engagement. It’ not only explaining why one has gone for one approach and not for something different, but also understanding concepts which you to be better at the thing you’re doing. This is also one major reason why a sports addict joins a sports club – to get better at your activity and to score the important points next time.
  • Sharing pride. In a lot of code, there are not only places you’d like never to have seen, but also brilliant ideas and sometimes funky solutions which solve a problem in a veeeeery unique way (most probably this should be a place in your code which is introduced by a huge block of comments). Valuing someone’s brainy efforts and motivating with appreciation is something I believe should be part of every common code-reading.

This should be enough for explaining why I came up with the following idea in my project:

Developers idol.png

The game is set-up as follows:

  1. The good, the bad, the ugly: One week prior to a common meeting, every developers starts searching the system for three samples of something brilliant, something that leads to an error and something which is strange but does no harm to the system.
  2. The whole team meets in a game-show. The duration of the meeting depends on the size of the team. I experienced that about 20mins per developer are needed. This can be quite long for a bigger team, as usual plan for some break after 90mins.
  3. One by one, each developer presents his three favorites and explains why his samples are most appropriate for each category. After each code snippet, the whole team is allowed to question the snippet or discuss about the presentation. Finally, each team member judges not only the quality of the sample, but also the quality of the explanation.
    Important: Identifying the owner of the samples is not subject of the game! Naturally, this will become evident during some discussions, but there are no points awarded or reduced for the fact of being the author of brilliant or crappy code.
  4. The meeting ends with celebrating the winner – and with kindly asking the anonymous owners of the not-so-brilliant samples to clean up their deliverable.

We’ve played this game only once during our development so far, but I felt that it was working really well: We got rid of most bad aspects I ranted about and achieved what was important to me. Particularly the sharing of knowledge was much more intense and in fact, we had a lot of fun!

What do you think? Do you also play games as part of your development process or do you have suggestions for improvement? I’d be happy to read about it!

To report this post you need to login first.

5 Comments

You must be Logged on to comment or reply to a post.

  1. Marilyn Pratt

    Enjoyed your blog immensely.  Thanks for rising to the challenge.

    Now wondering a few things as I reviewed your game.

    Is there a way for the owner of the “ugly or bad” code to find a creative way to present what she or he learned about remediatngi it or fixing it.

    In fact one of the “word shifts” that we thought about while discussing FAILFaire failfaire was to move from retaliating to remediation.  This is not just a “cosmetic” shift.

    When we get into the cycle of fault and blame we hardly can shift to appreciate learning and correction. You yourself say it’s tricky “not to blame the author”.  So what if we shifted to accountability and had the author responsible for training others to avoid the mistakes he/she have made?

    Thanks for sharing this here and I’ve added a tag for the Design Thinking with SAP space and also moved it to the space for SAP Gamification where I hope it will get many more eyeballs.

    (0) 
    1. Oliver Jaegle Post author

      Dear Marilyn,

      Thank you so much for your review! Approaching the concept in a more structural way with respect to failure, I admit that the remediation is not as much part if the game as it maybe should be. I know about that “flaw”.

      I accepted it not only because of time restrictions: I experienced that many errors in code are repetitive and that the actual corrective is clear to most participants. Presenting them has only a limited absolute value.  Having the code owner play an explicit part would mean to expose him as father-of-error. This is something I wanted to avoid.

      Thus, Developer’s idol focuses on creating an atmosphere where blame is not directed towards an exposed culprit – and where the pointing towards failure is not perceived as humiliation. Actually, it tries not to blame the code owner but to value the research-skills of each presenter.

      Do you (or other valued readers) have an idea of how to add a resolving element to the game without exposing the code owner? I’d be most happy to read about it!

      Cheers, Oliver

      P. s.: thanks for moving the blog! I did not find the gamification space myself…

      (0) 
      1. Marilyn Pratt

        Hope you don’t mind that I took the liberty.  In fact I “gamed” the system somewhat because now Laure Cetin who is responsible for gamification on SCN has rated and commented LOL!

        Also gives others the ability to view this in the context of the topic.

        Great work!

        I’d need to think further of how to resolve without improper exposure, but I’d go along the lines of taking pride in being the owner who remediates….meaning there is NO shame in having made the error once it is corrected and there is understanding so that it isn’t repeated.

        (0) 
  2. Laure Cetin

    Hi Oliver,

    Very nice blog! I enjoyed learning more about quality assurance on the developers’ side and I think you have done a good job of gamifying this process without going too far. It seems that the results are very positive and like you I would like to see if other members have done something similar, or if they would be interested in improving their processes like you did.

    Kind regards,

    Laure

    (I’m responsible for SCN gamification)

    (0) 

Leave a Reply