During the Unexpected Meetup: 1st Open Space I had an opportunity to discuss the topic of changes with fellow Scrum Masters / Team Leads / Agile Coaches. Here are some notes (subjective and incomplete):

  • Books to read:
    • Our Iceberg Is Melting
    • More Fearless Change
  • You shouldn’t expect that your team will come with new change proposal every day. It will be rather your task to help them to discover that some changes are required and decide that they are worth the effort.
  • External experts can really make a difference. Somehow people from the same company are less credible (“No prophet is accepted in his own country’)
    • New hires – especially if they are seniors – are treated similarly to external experts. At least for some time.
  • Imposed changes are much less effective than grassroot changes.
  • No sense to order changes (e.g. “you will do the pair programming 100% of time starting today!”). Much better is to show the idea and let people use it at their own will.
    • Onboarding (especially with fresh devs) is a great time to inject some desirable behaviours.
  • A nice way to introduce a change is to run an experiment (e.g. “Let us do the pair programming 1 hour per day for 2 weeks. Then we decide whether we like it or not”.) Be prepared that people might not like the change. But this is fine.


One year ago I blogged about a game we played during retrospecitve. A year has passed and it was time to open this “time-capsule”. No one guessed the right answer to all 13 questions, but some people were pretty close on many of them. Some questions got kind of outdated – e.g. we asked about the number of traffic-handling servers but in the meantime this functionality was split in two.

We liked the idea so this year we played it once again. The questions were similar to the previous ones but we tweaked them a little bit. Also, we invited our account managers to join the fun so the number of players grew to 14 (last year it was devs-only event, and there was only 9 of us).

P.S. Some people decided it would be fun to play it at company level so we prepared 5 questions and played the “New Year Predictions game” together. Will see what 2016 brings!

Recently I have spent some time thinking about teams. How it happens that few people become a team? What factors are at play? This is pretty important to me right now because few weeks ago I moved to a new team. And I want this team become fantastic. So there is plenty to think about and plenty to do.

As usual, when the topic is broad and vague I created a mindmap to put some structure around my random ideas. Here is the result.


I have shared and discussed this mindmap with my teammates during one of the first meetings we had. It somehow helped us to realise that this is not about just sitting together. To become a team, a really successful team, we need much more.

In case you use XMind you can download the original file here.

So obviously such things need time. Group of people doesn’t become a team just like that. Unless they go through some pretty intense stuff like volcano eruption, Sharkando, or Amazon S3 breakdown. Since such things do not happen everyday (with the exception of S3 failures) there is fat chance that you will need few months till a team is formed.

What you can do is to create an environment to make things happen faster. Let us see what we can do for various aspect of “being a team”.

There is also a question of decisive power that your team has. Probably not everything is under your control. Your organization might impose some things on you. For example, there could be a rule that each team should organise retro every 2 weeks or that we all use XYZ as your build server. Also team structure might be imposed. Thanks God this is not the case for us, as we have a lot of freedom in how we arrange our working environment.

And last but not least: some of the things won’t ever happen if you have wrong people on your team (meaning you will never really be a team). As always: hiring is the king!



Roles might be imposed by your organization. Or not. What you can do here is to have a discussion. Like what roles do we need to fulfil our goals?. This leads to further discussion – do we really need a devops or can we handle the deployment on our own? Do we need a QA or can we keep the quality of the product ourselves?
Then comes more personal questions, i.e. what roles do you think you could take? or more generally what do you bring to the team? (what skills).

Such discussion might sound boring but it is not. If the environment is right and people are in good mood then there is some laughter and fun involved. It works. At least, it worked for us. We learned that some of team members would be very happy if we let them code and left them alone 🙂 Others do not mind configuring production environment and writing end-to-end tests. Good. At least we know what can be expected of whom. It is good to know it beforehand.

Skills and roles are obviously connected, but there is no simple one-to-one mapping. I see skills as a very broad term: it could be Java mastery as well as staying calm even in case of cryptic JavaScript errors.


Obviously we share a lot of time and space. Let us see about other topics.

Goals are interesting. Why do we exist (as a team)? What is the purpose? Where are we going? Would be nice to see if people see things similarly.

We talked about it with my peers. I asked everyone to write down the goals as he/she sees it. Not much discussion on the topic because it occurred we all see our team goals similarly (which is probably good). What was unexpected is that we added one more goal to our list: “have fun and write good code”.

As for the values we plan to discuss it as well. I guess this is a standard team-building-retro-exercise. What do we value? Speed? Code coverage? Fun? No-IDE development? Respecting each other? Whatever – would be nice to discuss it.

Exchanging knowledge is our daily bread. We talk, we talk a lot. In fact, currently we are rather talking than coding. Or talking while coding. Or coding while talking. Hard to say. Anyway. We are on the same boat now as we inherited some old projects to maintain (and new exciting features to develop). So sharing of knowledge happens all the time. And I hope we keep it this way.

And BTW. obviously one of the best ways of knowledge passing is pair programming. Or rather doing stuff together. Some time ago I assisted Łukasz deploying one of our applications to production. OMG, I tell you, I haven’t expected it at all, but I’ve learned a lot! It occurred Łukasz uses shell scripts to perform tasks that I used GUI for. Nice, really nice.

We also hope to share a similar coding style. We already started by discussing our DDD approach so that we all keep it consistent. One day probably you won’t be able to tell which one authored which part of code. Right now different styles of coding are probably easy to spot.


Hm, you can’t make people like each other. But if you haven’t hired some assholes it will eventually happen. Same with respect or understanding.

What you can do is to help by creating opportunities. For example go to a pub or eat dinner together so people learn/like each other. Or encourage to do intensive pair programming – it always induces some discussion, which usually entails understanding, which usually entails respect, which sometimes entails friendship, which sometimes entails love… errr… well, understanding and respect should be enough.
Anyway, even simply meeting and talking is a good start. Yes, it is. Find some excuse to move people away from their laptops and have some discussion.

Feedback is something we all crave. We have already established some strict rules regarding code reviews so we expect to get (and give) a lot of feedback.
I also hope one day to have a kudo box so we can compliment each other. And later on we will probably try some form of peer-reviews.

As for pride I hope we will be very, very proud of our code we write. Being proud of what we do and who we are means also that we will be willing to share our experiences with other teams.

Separate / mark out

This also requires time. We do not have any custom habits yet. Some artifacts are ours (e.g. kanban board) while other (e.g. build server) we share with others. And this is fine. Sometimes it is simply easier to use some common resource. What we did in the case of build server is that we have our own view which presents us only jobs that we are interested in. A small step but it makes the build server more as if it were ours, even if it is still the same machine shared by many teams.

As for meetings we already have them set. Regular daily meetings and retrospectives, and (not so regular) planning sessions.

Doing things together

It is all about experiencing things together. Will see what the future brings.

Reasons to celebrate? I hope so. The thing is not to miss the opportunity to celebrate. Oh, you can celebrate even small things. I need to remember about this.
Production issues so we have to work overtime? I hope not, even though that would probably make us stronger (as a team). But it is not really something I’m looking forward, you know.

We definitely share a passion for clean code. What is left is that we need to agree what do we all understand by this. 🙂 But it will eventually happen as we code together and review what we have previously done.

This is it for now

This is not the end, but this is it for now. I hope you find some inspiration here. Good work building your super team! 🙂

ACE! Conference 2015 is (unfortunately) over. Great time, great people, great event!

It was the first time I attended an agile conference, and I have to admit, I enjoyed it. I listened to few really interesting talks, and I had some interesting conversations with other attendees. There were also some very interesting discussions during the Open Space Market.

Some comments and things to remember:

  • Talk with people during breaks. Choose random victim and start the conversation. 🙂
  • Badges / achievements seems to be a cool idea (not sure if the link is right: http://signup.badgerbadger.io/)
  • Thinking Fast and Slow by Kahneman https://en.wikipedia.org/wiki/Thinking,_Fast_and_Slow was probably the most often mentioned book during this conference. All kind of biases were also mentioned many times.
  • Some conferences do WiFi right – ACE! did.
  • 250 people is a very reasonable number. The rooms and corridors were full but not overcrowded.
  • It seems there are at least few (small) companies in Cracow getting quite well with flexible working time, flat hierarchy, netflix-like culture, and some ideas taken straight from Jurgen Appelo’s books. Good!
  • You are very lucky if your team is collocated.
  • Some people like to work with stars programmer, while others would happily get rid of them (cause they harm company’s culture).
  • Many teams start with http://hipchat.com and then move to http://slack.com Never heard of any team moving in the opposite direction.
  • Do not build cool products but rather solve problems of your customers.
  • Feedback – important thing! https://www.psychologytoday.com/blog/psychology-writers/201206/giving-good-constructive-feedback
  • I loved the fact, that the organisers were able to improve some things the 2nd day, after reading feedback from the 1st day. Kudos!

My ugly slides are available at Slideshare:

It was good to see you there! Thank you all!

The question is what to do with the kanban cards after they were taken from your kanban board?

The simplest answer is to “throw them away”. Well, yes, sure, they are not needed anymore.

My colleagues from the next-door team (hello @tkowalcz!) have a different idea. The cards end up on a stake. Sweet, isn’t it?


And you? Do you have any creative/fun/useful idea of what to do with the finished cards? Please let me know!

The beginning of a year seems like a good time for some predictions. Today I planned a very short and simple game for my team to check our future telling abilities.

(picture from http://freedomwatch.ipa.org.au)

I have printed out a short form with some questions related to our product and the team. The questions were are aimed at the end of the year (Dec 2015). I have prepared a mixture of technical and “team” questions, for example: “how many TPS we will handle at the end of year?” or “how many kids will we have in total by the end of 2015?” etc.
There were 13 questions in total, all to answer with simple yes/no or a number.

I have also provided a data sheet which described the situation right now so it would be easier to predict.

And now what? Well, I have gathered the answers and put them into an envelope. They wait for Dec 2015 when we open this “time capsule” and have a laugh. 🙂

P.S. The best “future teller” will be appointed the task of doing estimates. 😉

P.S. 2 – Short info about the results is here.

Code reviews. Very helpful if done right, completely useless if done recklessly.

Below you will find a mindmap of “code review” (using Xmind). I simply sat down and tried to gather everything related to code reviews. Hopefully you will find some food for thought here.


Some comments:

  • I knew one team lead (hello Marcin! 🙂 who had a very nice system of publishing code reviews by email to project’s mailing list. He believed (and had some good results to support this belief) that by doing such “public” code reviews he educates the whole team, and not only the author of the particular code. It worked for him and his team pretty well!
  • Marking code with TODO and FIXME during the review works pretty well for me. Nope, I haven’t used gerrit or any other tool like this yet.
  • IMHO code review should be a part of Definition of Done – no task is finished until someone else checked the code.
  • I don’t like the idea of team lead doing code reviews for the whole team. He has probably no time for this. The other thing is that some people find it hard to discuss with your “boss” (so they will follow blindly what the reviewer says). I like much more the idea of peer reviews. Even if some junior guys are not capable of performing code reviews properly (at least from the very beginning).
  • There is a great discussion regarding code reviews here.

When can you say that a task is done? This is an old topic but still important and still being discussed over and over by almost any team. Lately my team decided to come with a definition of done. This post presents our view on “what is ‘done’?”.


We tried to address every aspect of development – from coding & testing to documentation.
BTW. the order of things on our cheat sheet does not determine the order of work. For example TDD is more than welcomed so it is not like tests come after the code. Similarly javadocs don’t have to wait for the finishing of code activities.
The important thing is that our cheat sheet groups all things that should be done in one place.

Another issue is to realize that you will never be able put every detail on such cheat sheet. If you want it to be readable you need to choose words carefully. The point is, that everyone should follow the spirit of the law more than the letter of the law. If there is a point on “code quality check with Findbugs/PMD” it is rather obvious that you should use Codenarc instead, if you code Groovy. It is also obvious that often only some of these points are relevant for certain tasks (e.g. if your task is to write a user manual you won’t write integration tests for it, will you?). Common sense is always more important than strict rules.

This is What Done Means To Us

So, here it goes – our definition of “done”. As you can see it is quite generic in nature but at the same time contains some things specific to our team (like issue tracker schizophrenia uh…). It also addresses some issues that we had earlier with our code (like poorly commented TODOs or lack of information sent to project partners about some significant changes).

These cheat sheets now hang on the two opposite walls (so everyone can see it) and we treat them seriously, which means that if a task is marked as “done” this really means it is DONE.

A very important aspect (at least from my point of view) is that the points were discussed, changed and rearranged by all team members. Even the graphical form of these cheat sheets was done together (in fact in 3 days we had 4 different versions hanging on the walls cause we believe that details are important, so we polished it till we all agree both with the content and with the form).

What surprised me (and made me very happy!) is that my teammates set some expectations regarding “done” tasks higher than I would!

Lets say few words on some points of the cheat sheet.


These are the tags that we put into comments to mark fragments of code that should be reworked (and later find them using IDE or Maven Taglist Plugin).

  • TODO is for minor stuff. The code works, but it might and should be improved but at the moment we have some more serious things to do than to make the code pretty.
  • FIXME is for serious issues – if you don’t fix it, the code won’t work.

We decided to clear (that is to solve) all FIXMEs before the task can be marked as done. But we are less strict with TODO comments – as long as they say precisely what is to be done they are ok. So, a comment like

//TODO change it

is not permitted but

//TODO change variable name to be consistent with DAO naming conventions

is ok.
BTW., we are still discussing if it is ok to mark a task as “done” if the code still contains some TODO comments. The experience tells us that they tend to stay in the code forever (because of their low priority) which is bad. Ideally TODOs should also be removed. If we find it to be an issue, we will rethink our policy.

Code Coverage

We don’t set any strict coverage percentage. We write a lot of “integration code” which is not easily tested with unit tests, and I don’t feel like we would gain anything by setting some high threshold here. What is expected of every team member is to have a look at the coverage report in order to find untested regions and think if it is sensible to write some tests that would cover them. That is all.

Does it Work?

It is too early to say if it works because we introduced this “feature” a week ago (along with Kanban board, but this is another story).
Right now I can only say that it helps me to remember about all petty but important things that one have to do before moving on to another task. Will it have a same impact on the team? Will see about this soon (I plan to write some more on this in few weeks time).

Why do we Need it?

Answering question asked by Jacek:

why did you think you’d have to formalize what’s DONE?
Did you notice teammates don’t follow your take on it or was it something else?

Few things here.

First, as mentioned before, we started to implement Kanban. So now we have this board with few columns and the last one is called “done”. Fine, the board looks nice, but what tasks can be moved to this last column? So we needed a definition of “done”.

The other reason is that we had some issues with our code like the thing with poorly commented TODOs (that no one knows right now what should be done there). Or issues related to “code ownership” which means that each person on the team knows his code and not much more. This will be hopefully addressed by peer reviews that now have to be done before a task is finished.

I also believe that such simple thing like preparing together such a cheat sheet is very good for team health. Definitely I would like to have more stuff done together in the nearest future (I guess that is the outcome of my recent interest in Agile and Kanban).


No links this time, because search will give you plenty of answers if you ask for definition of done or sth similar. Many of them really worth reading and quite inspiring. I would encourage you (and your team) to have a look at them before you start working on your own definition.

What is Your “Done”?

How do you define “done” within your team? Is it just a common sense of decency floating around in your heads, or do you have it “carved in the stone” somewhere like we do? Please comment.