Timeline Retrospective

The Timeline Retrospective is a technique used to reflect back on major events that occurred during a Sprint or a Release

The process is as follows: 

1. Silently write down on sticky notes the major events that occurred
2. Create a single timeline on a wall 
3. One by one, layout the notes in order of occurrence on the timeline
4. Place positive events above the timeline and negative events below the timeline
5. Discard duplicates
6. Have one person walk through the final timeline
7. One by one, rank the events on the timeline using dot voting 
8. Identify actions for the highest ranked events
9. Rerun the time line with the actions and see what changes and if you get the desired outcome. 

 
Adapted from: Putting the fun back in your retrospectives @ Agile2011

The Code Christmas Tree

The Code Christmas Tree is a technique used to visualize the quality of your code. It is based on a treemap which is an information visualization technique to display hierarchical or tree-structured data as a set of nested rectangles. Branches are represented by rectangles and sub branches are represented by smaller rectangles and so on. The leaf node’s rectangle has an area and color proportional to a specified dimension of data. In the case of the Code Christmas Tree these can be lines of code, cyclomatic complexity, and test code coverage. The different colors and sizes make it easy to see patterns that would be difficult to spot in other ways. Looking at the tree you can quickly identify which code areas are clean and which ones need more tests or major refactoring.

The chart examples shown here were generated by Michael Kaiser and Guy Royse using a utility that displays Big Visible Metrics (BVM). It takes XML metrics generated by Sonar and parses the data and converts it to CSV data that is then consumable using the Microsoft Treemapper and Excell Add-in to generate these colorful charts. The size of the rectangle represents lines of code. The color represents cyclomatic complexity or test coverage. The large red rectangles are the code targets that need to be refactored or need increased code coverage. BVM is on GitHub and you can find out more about it here.

Adapted from The Code Christmas Tree @Agile2011

Draw me a picture

Draw me a picture is a retrospective technique that can be used when people are tired of the same old routine and when verbal communications are failing.

The process is as follows:

1. Ask the attendees to silently reflect on the on the events of the last iteration or release 
2. Ask them to draw a picture reflecting their feelings 
3. Place the picture on the wall
4. In turn, let each participant describe their picture and provide a title
5. Try to observe patterns to highlight significant events or impediment

Adapted from: Putting the fun back in your retrospectives @ Agile2011

The 1st ever bug

In 1946, the 1st ever case of a bug was reported when an actual moth trapped in the relay of a Mark II caused it to malfunction. The bug was removed and taped into a log book and recorded as the 1st actual case of a bug being found! The log book (with attached moth) is on display at the Smithsonian National Museum of American History. How’s that for error tracking!


The term bug however was coined earlier as records show that Thomas Edison used it in 1878:

“It has been just so in all of my inventions. The first step is an intuition, and comes with a burst, then difficulties arise—this thing gives out and [it is] then that 'Bugs' — as such little faults and difficulties are called—show themselves and months of intense watching, study and labor are requisite before commercial success or failure is certainly reached.”

Adapted from: Refactor your wetware @ Agile2011

The Kata in the Hat

At Agile 2011, Emmanuel Gaillot and Jonathan Perret performed a coding Dojo entitled "The Kata in The Hat." Emmanuel and Jonathan are behind the original coding dojos in Paris. Usually, katas are performed by practicing TDD and applying baby steps. The main kinds of Katas include:

1. Prepared Kata  where someone comes prepared with a full solution to the Kata and presents it to the group.
2. Randori Kata where the group rotates pairs so solve a particular problem.

The Kata in The Hat is a twist on these katas. Here, the hosts had a hat in which audience members can write-in rules and requests and drop them in the hat. The presenters start with a main idea, but every five minutes one paper is pulled out of the hat, the instructions are read and the timer is reset. The hosts continue to pair program, but now they incorporate the new requests into their code. And so on... The interesting part is seeing how they can finish each request by doing the simplest thing that can possibly work. They quickly adjust and keep the code moving as they try to solve the main problem no matter what is thrown at them. This type of Kata is definitely not for the beginners, but it’s a great show that is fun, entertaining and educational. If they are ever touring at a conference near you, I highly recommend you attend.

"The big idea we want to get across is that programming can be beautiful, and that through creativity and beauty and poetry programmers have much more power than they think."
 http://thekatainthehat.com/ 

Captions

Captions is a retrospective technique that can be used as a collaborative and safe way to share feelings. The technique is fun and the results can be very insightful and hilarious at the same time.

The process is as follows:

1. Announce a specific topic for discussion 
2. Each team member gets n number of index cards where n is the number of team members. The cards are numbered sequentially in each stack. 
3. Individually, on card #1, members draw a picture to illustrate the topic at hand 
4. The decks are passed to the right 
5. On the new deck received from the left, members study the picture on top, then move the card to the bottom of the deck. 
6. On the next card, members write down a caption for their interpretation of the picture they just saw 
7. The decks are passed to the right 
8. On the new deck received from the left, members read the caption, then move the card to the bottom of the deck 
9. On the next card, members draw a picture based on the caption they just read 
10. This process is repeated for several rounds until each stack is back at card #1 
11. Members take turns laying out the decks and reading out and sharing the results with the team 

Note: If the number of team members is even, then start with drawing a picture, otherwise, start with writing down a caption.

Adapted from: Putting the fun back in your retrospectives @ Agile2011

The Spinning Lady

Look closely. Is she spinning clockwise or counter-clockwise?

Think of happy places, found memories, poetry, and music. Let your mind wander.

Look closely. Is she spinning clockwise or counter-clockwise?

Solve 3*5=?
Solve 15+5=?
Solve 20+5=?
Solve 25 + 3 =?
Solve 28/2=? 14.

Look closely. Is she spinning clockwise or counter-clockwise?




Did she switch direction? The idea here is that our brain switches between left and right. If she is spinning clockwise, then we are using the right side of our brain which is responsible for feelings, beliefs, imagination. If she is spinning counter-clockwise, then we are using the left side of our brain which is responsible for logic, math, and science.


Adapted from "Refactor Your Wetware" @ Agile2011

Source Code Word Clouds

Here’s a neat way to look at code quality - use source code word cloud generators.
A word cloud or tag cloud is a visual representation for text data. Tags or words are listed and the importance of each word is shown with different font size or color. When applied to well written and clean code, word clouds give us a quick way of understanding what the code is about.
 
 Below is an example from http://fragmental.tw/2009/04/29/tag-clouds-see-how-noisy-your-code-is

Clearly, looking at the second cloud, we know a lot more about the domain than the 1st cloud.

Try it out using the original http://www.wordle.net or http://sourcecodecloud.codeplex.com

Adapted from "Code" @ Agile2011

Back to the Future!

At the conclusion of the Agile 2011 conference, Todd Little jokingly looked back to the 1st Agile conference in 2004 when agile experts made predictions of the future and came up with the top 8 things that will happen once main stream gets hold of Agile Software Development:

8. The 1st Agile software development conference will undergo historical revisionism, in which it will be told as originally taking place on a farm outside Sundance, with lots of music and on-demand pairing, and announcements in middle of the conference to not eat the brown acid.

7. The Spike channel will ask Ron Jeffries to host an Apprentice-type reality show where agile teams will compete against each other to build software for rocket-packs, X-ray goggles, and invisibility rays. The catchphrase when he gets rid of the failing team each week is “You’re dead fish!”

6. GE will develop 3 year, six sigma certification programs for becoming Agile Certified.

4. You’ll see personal ads like ”Certified SCRUM master seeks product owner with large product backlog for promiscuous pairing”, and “Single Agile Developer with data envy and analysis paralysis seeks customer for private requirements collection; expect failure”.

3. Sun will come up with an innovative, elegant Agile programming language, get people to use it, and proceed to totally screw up the marketing for it and name it with really confusing release numbers.

2. Woman out at bars together will refer scathingly to the guy at the end of the bar who keeps starring at them as a “scope creep”.

1. A paperclip in Windows will pop up periodically and say, “Looks like you’re trying the waterfall method. Want me to pair with you?

Measuring Code Quality

A common measure for code quality is to measure Cyclomatic Complexity. Cyclomatic Complexity is used to measure the number of linearly independent paths through a program’s source code. The more conditionals (if statements) or the more loops (for, while …), then the more branches run through the code and thus the code becomes more complex. But what is considered to be a good number for Cyclomatic Complexity? What should developers target?


A study by energy (http://www.enerjy.com/blog/?p=198) reveals the following:

There is a 50% chance of errors with a Cyclomatic Complexity of 38 and almost a 100% chance of error when Cyclomatic Complexity is 74. On the other hand, with a Cyclomatic Complexity of 11, the chances of errors drops to 28%.

So based on this study and the above graph, shoot for a Cyclomatic Complexity of below 20 per class.

Adapted from "Technical Debt Assessment and Reduction" @ Agile2011

The 5 Whys

The 5 whys is a retrospective technique that can be used when the team needs to focus on a specific symptom that does not have an obvious solution. The goal of the 5 whys is to clearly understand the situation and not necessarily to solve the problem.

The process is as follows:

1. Write the problem statement clearly and concisely on the board.
2.  Divide the team into groups of at least 3 but not more than 5. 
3.  In each group, individually answer why did this happen? Number your answer as #1.
4.  Individually answer why did #1 happen? Number your answer as #2.
5.  Individually answer why did #2 happen? And so on until you have around 5 answers or can’t come up with more meaningful answers (try to have at least 3 answers).
6.  Each individual places their chain of responses in a column below the problem statement. The group then discusses the individual answers and tries to find common patterns.
7.  The group consolidates the chains into a single chain.
8.  If necessary, the team consolidates the chains into a single chain.

Participants should focus on exploring the immediate cause of the symptom rather than attempting to immediately jump to a root cause. The intermediate reasons often spark ideas within the group that would otherwise be overlooked.

While this exercise is typically applied against problems, this same technique can also be used to discover what led a team to achieve exceptional success in one area.

Adapted from: Putting the fun back into your retrospectives @ Agile2011