Presentation from the authors of the book “Agile Retrospectives - Making Good Teams Great” at Google. Lots of great tips on how to improve your sprint & project retrospectives.

One tip I picked up on was to ask “how was the energy for this sprint?” rather than the bland “how are you feeling?”.

Their structure for a retrospective is:

• Set the Stage
• Gather Data
• Generate Insights
• Decide What to Do
• Close the Retrospective

The way to succeed with a process such as agile is through continuous improvement. The forum for reviewing what needs to be improved and to decide on how to improve things is the sprint retrospectives.

Retrospectives are critical for having a successful project.

Hopefully this isn’t something you need to do. The server that I’ve been using to collaborate on a few git projects with had the domain name expire. This meant finding a way of migrating the local repositories to get back in sync.

Update: Thanks to @mawolf for pointing out there is an easy way with recent git versions (post Feb, 2010):

git remote set-url origin ssh://newhost.com/usr/local/gitroot/myproject.git

See the man page for details.

If you’re on an older version, then try this:

As a caveat, this works only as it is the same server, just with different names.

Assuming that the new hostname is “newhost.com”, and the old one was “oldhost.com”, the change is quite simple.

Edit the .git/config file in your working directory. You should see something like:

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = ssh://oldhost.com/usr/local/gitroot/myproject.git

Change oldhost.com to newhost.com, save the file and you’re done.

From my limited testing (git pull origin; git push origin; gitx) everything seems in order. And yes, I know it is bad form to mess with git internals.

The new Google Command Line opens up some interesting possibilities. One that I wanted to explore was using TextMate to edit basic Google Docs.

First, install Google’s Command Line tool. Details are on their wiki for each OS. There are lots of tips in the comments and even a packaged installer. (I used ports to install)

The next step is to create a symlink from the “mate” command to “mate_wait”. What this does is default the wait argument to true. This is needed for the Google script to detect changes to your document.

sudo ln -s /usr/bin/mate /usr/bin/mate_wait

You can now open a document in TextMate:

google docs edit --title "Ideas" --editor "mate_wait"

If you select a title for a document that doesn’t exist, it will be created. Once you close the file in TextMate, control returns to the shell and the document is updated on Google’s servers.

You are only able to edit in text only mode. So it works best on documents without any formatting.

To list your existing documents, try:

google docs list

Clojure has been getting a bit of press recently, such as prominence on the ThoughtWorks Technology Radar. Having spent some time learning Lisp in the past, I thought it could be a good holiday project to play with.

This post pulls together some of the resources I found for getting started. I’m not going to try and sell you on a Lisp dialect that integrates into the JVM, it should be self evident.

TextMate Setup

TextMate has a bundle that makes it very simple to get started. It includes the clojure runtime, and so you can run clojure code after installation. To install (assuming you have git):

cd ~/Library/Application Support/TextMate/Bundles
git clone git://github.com/nullstyle/clojure-tmbundle.git Clojure.tmbundle
osascript -e 'tell app "TextMate" to reload bundles'

Then create a folder, open it in TextMate, create a file (ie. test.clj) and put some sample code into it:

(+ 1 2 3)
(println "Hello from the console")
(. javax.swing.JOptionPane (showMessageDialog nil "Hello World"))

Put the cursor into one of the expressions and press Apple-R. TextMate will figure the rest out and show the result. Apple-Shift-R will run all the expressions.

(The Vim setup looks really good, but I’m committed to learning TextMate at the moment)

Tutorials

I’m not going to be exhaustive on this, but thought I’d include a few pointers (see also Alexandre’s summary). There is a video series available on YouTube, and also on BlipTV.

This is an overview in a cheatsheet, and there is a fairly complete language reference here and a longer list of references as well.

Given that Clojure is Lisp based, it would make sense to understand Lisp. The best option is a book called Practical Common Lisp. This is available on the web for free, or can be purchased from Amazon.

Update: Apparently I was off a bit on the utility of the Common Lisp book.

From @cemerick: @gmwils FYI, Clojure is a lisp, but has little to do with Common Lisp. For books, try http://bit.ly/ccSw2Z or http://joyofclojure.com/

Agile is something that I’ve previously found to work very well with in-house R&D projects, and rather more challenging when negotiating projects with customers.

The challenge is getting from the sales cycle through to the agile development iterations, be they sprints or otherwise.

By using an agile process, the advantage is that many smart people have been here before. Some of the knowledge is locked up in consultancy houses, while some of it is shared.

Gerard Meszaros has a good presentation highlighting some of the challenges and what often gets missed. The slides are available here.

For me, this is the key slide:

The section on adding more time into the Product Planning phase fits well with how customers often see projects. By providing scope at the feature level, it allows boundaries to be placed around time and money.

This is certainly an area of agile that I would like to understand more.