11

A gamification experiment with SonarQube

Some time ago I finished a gamification MOOC by Coursera and then I decided to put it into practice in my current job since I found it really interesting. I set up a game in which the more Sonar issues you resolve, the more points you get, and you can rank in a leaderboard and obtain badges.

In this post, I’d like to share with you the results of this experiment, how people were the key to success by resolving many potential bugs and reducing our technical debt.

Update: code is now on github.

Looking for the (business) goal

It started with a very simple idea: apply gamification to some task that at the same time is boring but it is something we have to do. It has to be boring or repetitive since I wanted to avoid the overjustification effect and apply gamification for something for which we should be intrinsically motivated, like creativity or innovation in the company.

I discarded also the day-to-day work resolving JIRA issues, given that in that case, it could have led to a kind of exploitation: definitely it’s not a good idea to have a ranking of employees by the number of tickets they resolve.

At the beginning, I thought there was no use case for us to apply gamification but then I suddenly noticed that there was a case in which all these conditions apply: fixing potential bugs and bad code practices in our legacy code by fixing SonarQube violations.

Modeling the code quality problem with sonar

Sonarqube (formerly Sonar) is an open source platform to manage code quality. It covers many languages, including Java, and it can be extended with plugins to add new rule engines. We use mainly rules coming from FindBugs, PMD, and CheckStyle. It’s able to detect a lot of bad code practices and reports also your unit test coverage and the overall complexity. 

In our company, we use Sonar in an automated way inside our Continuous Integration framework. There is a job in Jenkins that uses Maven and its Sonar plugins to publish the results. We have different quality gates configured and if any important violation is added an email is triggered to the developers.

sonar issues

A big part of our code base is more than 10 years old and it was produced without taking care of good practices, thus the called Legacy Code is a big issue for us. We inherited many Sonar violations and the authors of them are not in the project anymore.

The main idea was to encourage the team to fix the legacy code issues since they are the source of many bugs every now and then and make the code more difficult to maintain. New issues have to be fixed on a daily basis and they can’t be part of the game since someone could, in this case, introduce new issues on purpose and then fix them to win the game (it’s weird but it may happen). So I established the ‘Date of the Legacy’: any issue before that date that becomes fixed will give points to the assignee in Sonar.

To start with, the scoring system would be based only on Blocker and Critical issues. We had many of them from the beginning. So the worse the issue is, the more points you get by solving it. To keep it simple I based the score directly on the technical debt calculated by Sonar.

The last thing to consider was a cleaning of duplicated rules or controversial rules in Sonar. This would avoid big changes in scores and coherence in the game from the first day.

The gameranking

It is a simple PBL (Points + Badges + Leaderboard) approach. Fixing Sonar issues gives you points for ranking up in the leaderboard. Every now and then you get badges for doing fixes if you combine several of the same type or you fix many of them in a row. It’s a really simple game implementation so obviously it was impossible that would have worked without further explanation. I created a wiki page to explain it and provided the team the main reason for playing the game: fun while achieving a business objective.

There is no winner or loser in the game, only a leaderboard with points and badges. Even though there is not a date to proclaim a winner recently we rewarded the team member with the higher score with a mug, with no prior notice. It’s not much, but small surprises are good in games.

Required setup & How to design the micro-web

Your CI framework has to be prepared to analyze your code base. That means Jenkins and maven with corresponding plugins have to send reports to Sonar server. You’ll also need an account for the micro-web game to access Sonar API.

For the micro-web, I used Spring Boot, the Sonarqube REST API, Thymeleaf, and Pure.css.  I’ll dedicate a different post to describe the details and my intention is to publish the code in Github. [Update: the code is now on GitHub]

How users can play the game

The premise is simple: while working you face code that is confusing or badly written that has many possibilities to end up being a bug. Instead of ignoring it and simply introduce your changes better:

  1. Cover the code with a Unit Test, if it isn’t yet. Assign to you in Sonar the corresponding ‘Insufficient code coverage…‘ issue if it does exist. That will give you points.
  2. Once you are sure you’re not introducing bugs you can refactor the code to make it easier to maintain, less coupled, etc. Go to Sonar and assign you the existing violations that you will fix. Once Sonar is executed again it will mark the issues as resolved/closed and you will score points for the game.

sonar-assign

The game’s introduction

It’s important to be honest and that everybody knows what is the game objective. The idea is to increase motivation for doing that, not manipulating people to do something. It’s an incentive to do something typically boring and if you can have fun while you do it that’s perfect.

It was clear from the very beginning that no reward was associated with the game apart from the intrinsic motivation of the competition between colleagues. Anyway, we gave recently a mug for the first classified as a surprise, and the guy really appreciated it.

The first month

Since the very beginning, some people got involved much than others. They were 5 out of 20 more or less the ones who started contributing. In this period many critical violations were quickly fixed, given that they were the ones that scored the most.

And then after a month, I sent an email with a summary and a snapshot of the leaderboard and then some others started to contribute. We are four teams so I introduced the ‘Team Ranking‘. That was powerful to get more people involved: by that time we reach 10 of 20 developers in the game. There were even some business analysts that started introducing comments in the code to fix some Sonar issues related with that, which is also a great contribution.

Eventually, the game was working!

The results (after three months)

Within three months many issues have been solved and in general the motivation for solving them has increased notoriously.

Here you have some stats taken from Sonar. The game was introduced on March 27th. As you can see there is a clear decrement in all types of issues. Also, you will notice that during the first month all the blockers were removed and a big part of critical issues have been also reduced.

sonar-statsMoreover, inside the company, there are goals for the different groups and they soon revealed that we were clearly outstanding amongst other teams!

People are the key

There is something clear: the key to the success of this experiment has been the people. It’s a really collaborative team, people opened to any new idea, that understood perfectly what was the objective of the game and had fun with it.

I want to thank them publicly for the collaboration!

Are you interested in Gamification and Spring Boot?

If so, you can also get my book: a practical guide to microservices that includes some gamification concepts. Get it today: https://leanpub.com/microservices-thepracticalway

Related Posts

How to fix Eureka taking too long to deregister in... If you use Ribbon and Eureka in your Spring Boot application, you'll notice that the default configuration is not optimal. Eureka takes too long time ...
@RestController example with Spring Boot and Swagg... In this article I'll explain how to set up a basic @RestController  in a Spring Boot application, using both @GetMapping and @PostMapping annotations....

11 Comments

  1. Outstanding work !!!

    Legacy code was an issue for us for a long time and nobody knew how to approach the issue. Introducing gamification solved in three months most of our problems neatly.

    You are inspiring all of us on your daily work. It’s a pleasure working with you.

  2. We did something very similar for the very reasons. In our case one of the developers extended the Jenkins CI Game plugin to hit SONAR. This way the scores are kept in Jenkins and can be queried. I have a build monitor built using Processing and some hardware. It displays team scores and individual leaders. It also hooks into twitter,hipchat and a JIRA activity feed so we can display on a wall board. Great write up. Game On!

    • Thanks for your comment! I’ve played with the Jenkins CI game and looks really good, it’s great you extended it. Do you have some screenshots or information about that project?

      • It’s about time I wrote up the details. I might be able get the dev to release his code. He usually wins the game (reset each release) so it is a bit of a perfectionist.

Leave a Reply