A couple of weeks ago, we held the First International Conference on Software Archaeology (TICOSA) here in London. Duncan McGregor and I chaired the conference, and we had a great day of interesting talks and discussion.
Some people asked what had caused us to put on this conference in the first place. The story is that Duncan and I were sitting at breakfast at another conference (ACCU) back in April of last year, and the topic of working with decompiled code came up (as is not unlikely whilst breakfasting at ACCU). I asked Duncan if there were any lessons that he’d taken away from the exercise of decompiling and trying to make sense of the code he’d been working on recently. He thought there were, and we posited that perhaps this might make the basis of a conference session. But where to submit it? Over the following couple of months, we looked at various conferences, but just couldn’t quite find the right audience for this session on what seemed to be, not exactly software development, or engineering, but more like software archaeology. A colleague jokingly (I think) suggested that maybe we should create our own conference, all about software archaeology, but we took him at his word and TICOSA was born. Though as it turned out, after looking at all of the other interesting work in the area, we ended up not including our own session in the programme!
The conference was one day, hosted at the Museum of London (for a sense of history) and we had a great and varied series of presentations throughout the day, and much discussion between the delegates during and afterwards. You can find the details of the talks, and quite a few of the presentation slides on the conference website. We didn’t really define what Software Archaeology was - on the website we just wrote that we wanted to focus “what we can learn about our present by digging up the bones of old code, and techniques for bringing ancient code back to life.”
Quite a few of the talks showed us some nice visualisations of looking back through version control repository history. Dmitry Kandalov showed us some animations that looked into the history of projects like JUnit, and we were able to postulate about the development culture of the team that built the product, based on the related artifacts in the version control history. The moving dots in Dmitry’s presentation made me think of Hans Rosling.
Later in the day, Robert Smallshire gave us more visualisations. Rob animated the history of a project, so we could see the codebase change frame by frame. What looks good? What looks like a problem? What’s going on here? The visualisations don’t give us definitive answers, but they allowed us to quickly find things that looked conspicuous, places where we might like to dive in and take a look.
A lot of what was talked about was looking back into the past and finding things out, calculating metrics, changes etc. The main question I was left with was how can we take this information mined from project history, and use it day-to-day as we develop to help us build new systems.
Together with some of my students at Imperial College, we’re working on building some new tools that can support developers by providing them with more contextual information about the code that they are working on, based on insights mined from version control. These are just prototypes at the moment though, and we haven’t experimented with them in the wild. Let me know if you’re interested in trying them out!
So, will there be a TICOSA again next year? We’re not sure - maybe. It certainly seemed like there was a lot of interest during the day, and there doesn’t seem to be another destination for people to discuss quite the same topics, so maybe we will, if there’s demand?
Some other people penned some more detailed write-ups of the day, here are a couple of links:
Thanks to Alice Gonzalez for the photos used in this post.