Author: Kerry Buckley

Government IT waste

Money down the drain There’s an article in today’s Guardian called Not fit for purpose: Â£2bn cost of government’s IT blunders, with the following summary:

The cost to the taxpayer of abandoned Whitehall computer projects since 2000 has reached almost Â£2bn – not including the bill for an online crime reporting site that was cancelled this week, a survey by the Guardian reveals.

I have no doubt whatsoever that the government wastes a vast amount on IT contracts, but I think that, by concentrating on the cost of cancelled projects, the article misses the point slightly.

If a project is clearly never going to deliver, it’s far better to cancel it than to fall into the trap of the sunk cost fallacy, and keep pouring money in in the hope that eventually everything will turn out OK in the end.

The real questions for me are ‘are the government’s IT needs being met at the most cost-effective manner?’ and ‘why does it take so long to realise that a project is doomed?’

I don’t know anything about the projects discussed in the article, or about how government IT contracts are handled in general, but I’d be willing to bet that the following guesses aren’t too wide of the mark:

Someone decides that a new system is required, and produces a huge list of everything they think it needs to do. This goes out to tender, and the job goes to whoever manages to produce the lowest quote while still giving a reasonably credible impression that they can actually complete the work in the specified time.
The contractor goes off and starts work. They talk to the civil servants who are responsible for specifying the system, but probably not to the people who will actually have to use it. They then go off and produce a design, get it signed off, and set up teams to work on all the identified subsystems.
Every few months they deliver a progress report, assuring the client that everything’s progressing according to plan. After a year or so the schedule probably slips a bit, but they assure everyone that it’s jsut a blip, and the final delivery won’t be significantly affected (we can always trim the testing phase a little, right?)
Because the contract fixed time, cost and scope, there’s only one thing that can be adjusted to keep the project profitable when the estimates turn out to have been optimistic: quality. Of course this ripples forward, with more and more time spent chasing problems caused by poor quality work in existing parts of the system.
When (eventually) the first version of the system is delivered, there are integration problems, it doesn’t quite do what the people specifying it actually wanted, and it turns out that large parts of the specification weren’t that important, but some vital features have been missed out altogether. Depending on just how big a disaster it all was, one of two things happens:

The project gets cancelled. The contractor moves on to the next lucrative contract, and an enquiry’s set up to investigate the specific reasons for the project failure, completely missing the big picture.
The problems are slowly ironed out, and the missing features are added to the requirements for the next release. The contractor rubs its collective hands at the thought of the massive fees they can charge for the change requests, and a huge amount of time is wasted arguing about whether each change is a new feature or a bug request.

I’m not (quite) naive enough to suggest that all these problems could be solved by wholesale adoption of XP, but I get the impression that the government (and the media reporting on these fiascos) isn’t even aware that there is a better way. With major companies adopting an agile approach now (or at least pretending to), how long before the people responsible for spending our taxes wake up?

[tags]government,it,waste,agile[/tags]

Web 2.0

Valuing Openness

An interesting insight from, of all places, a clip of CSI, where they’re looking at someone’s Twitter feed:

Greg: “Some people just don’t value privacy.”

Archie: “They don’t expect privacy. They value openness.”

I came across the clip purely by accident – it was in the ‘what’s related’ box on Youtube for a clip of psd asking Evan Williams a question at LeWeb.

And on a completely unrelated note, finding Evan’s site for the link above (via his Twitter profile, naturally), I see his comment on Twitter’s elusive business model:

I agree with Fred on this issue. It’s not that we don’t care about the business model or aren’t thinking about it, but, as Fred says: “But every ounce of time, energy, money, and brainpower you spend on thinking about how to monetize will take you away from the goal of getting to scale. Because if you don’t get to scale, you don’t have a business anyway.”

Which kind of ties in nicely with this tweet from JP.

Oh, and looking for that tweet, it appears Twitter now don’t SMS you @replies from people you follow to people you don’t. Maybe it’s worked like that for ages, but I hadn’t noticed before. Which relates slightly to my previous post, and also brings us neatly back to Paul’s question, which is where we came in.

[tags]twitter, privacy, openness, csi, psd, jp[/tags]

Web 2.0

Modes of Conversation

Tower of Babel This post has been languishing in my drafts for a while, but JP’s musings on ‘asymmetric tweeting’ reminded me to get it finished.

Before the Internet came along, there was a fairly clear boundary between publishing and conversation. You could reply to a newspaper article via the letters page if you felt strongly enough, but the publisher decided whether to print your comments, and the relationship was still heavily one-sided. Conversations, in turn, could be largely divided into synchronous (face-to-face, telephone etc) and asynchronous (letters, fax and so on).

The more traditional internet communication tools follow a similar pattern: publish a web site; converse synchronously (instant messaging) or asynchronously (e-mail). A new addition was the many-to-many conversation – again either synchronous (IRC) or asynchronous (newsgroups; mailing lists).

With the advent of what I’ll call ‘Web 2.0’ for want of a better term, things start getting a whole lot stranger.

Let’s start with blogs. At first glance a blog is just published content, but what sets it apart is comments and links. Anyone can reply to a blog post, either by commenting on the post itself, or by writing a response on their own blog, and using trackbacks. If it’s a popular blog, you often end up with conversations between commenters which don’t even involve the original poster. With trackbacks, it’s not always obvious to people reading an article that it’s a response to another, so you can end up with several conversations on the same post: one in the comments, and the others in ‘the blogosphere’, held together loosely by hyperlinks. People will read later contributions without necessarily even realising that they’re part of a conversation of sorts. There’s no guarantee that the original poster will even read everything that links back to his post, and reading links to links is even less likely. Similarly many people comment on a blog and never get round to going back to look for replies to their comment (bloggers: please provide RSS feeds for comments on individual posts!)

Then we have the weird and wonderful world of ‘social networks’. Facebook, for example, provides several ways to converse with your friends. There’s personal messaging, which is basically a walled-garden, non-standard e-mail service and not especially interesting. You can write on people’s walls (not to mention superwalls, funwalls and who-knows-what-else-walls), and have ‘wall-to-wall’ conversations. Even ignoring the fact that they’re hidden from the Web at large, these are only semi-public, in that only people who are friends with both of you can see the whole conversation – non-mutual friends can only see one half. Or people can have more ephemeral conversations just using their statuses, which can look very odd to those who are only privy to part of the conversation, or who come in late when the statuses no longer make sense together.

Twitter, for such a simple service, also leads to a surprising variety of conversations. There’s the original simple broadcast “what are you doing?”, and direct private messages (again, not much different from e-mail or SMS), but things get interesting when people use the @username syntax to reply to other messages. As observed by Phil and discussed by JP, this can get confusing (and annoying) when you aren’t following the person being replied to (although watching who your friends reply to can be a good way of finding new people to follow). On the other side of the coin, if you reply to a tweet from someone who doesn’t follow you, they won’t even see your reply, unless they happen to look in the replies tab on the Twitter website (or subscribe to their replies using RSS).

And as if that weren’t complicated enough, what happens when all these tools meet up? Lots of people automatically post their tweets to their Facebook status, or create Facebook links to their blog posts, or aggregate just about everything to Jaiku, and inevitably some people will reply to the link or the second-hand message rather than going back to the source.

So can we cope with all these semi-visible, partly-asymmetrical, multi-homed conversations? We seem to be managing so far, and at least we have the choice. I was reading something recently that I wrote in my student days (when mobiles were for yuppies, and student houses didn’t generally have phones, let alone internet access). A bunch of us from various places were going camping in Wales for the weekend, and apparently there was confusion because someone had sent a letter saying they didn’t know where the campsite was, but it hadn’t arrived in time to send a reply. Life was simpler then, but sometimes the simplicity made things more complicated.

[tags]conversation, facebook, twitter, blogosphere[/tags]

Java Software

Java ‘Good for Nothing’?

In Language Explorations, Ola Bini (of JRuby fame) suggests that there won’t be any more ‘big languages’, but instead more of a mix-and-match approach, with different languages used for different parts of an application according to their strengths, all running on the JVM (or presumably .NET if you’re on the dark side).

An interesting opinion (which I’ve slightly mischievously taken out of context here) from the article:

In fact, I’m not sure if Java the language is good enough for anything, anymore.

Software

Happy New Year

Janus So, that’s 2007 over with. Is it just me getting old, or did the past year go by even quicker than normal?

Amongst other things, 2007 was (for me at least) the year of Ruby. Obviously Rails had already been around for a while, and the language itself even longer, but they both seemed to be popping up all over the place last year, and gaining acceptance where they had previously been ignored as not mature or “enterprisey” enough. It’ll probably still be a while before large companies look at Ruby and Rails in the same way they currently look at Java and J2EE, but at least in my little corner of a large company I was able to spend the whole year writing Rails apps. It doesn’t look like there’s going to be any slacking of the pace in 2008 either, with the last few weeks of 2007 seeing the release of Rails 2.0, RSpec 1.1, Ruby 1.9 and JtestR (the last of which should be cool for Ruby people still stuck in a Java world).

It was also the year of ‘social networking’ websites in general, and Facebook in particular. Halfway through the year they introduced their developers’ API, and the web was awash with people praising their openness. Over the following months people started to realise that that ‘openness’ was very much one way, intended to get your applications running on their platform rather than allowing users to expose their data on the Web, and much of the shine wore off. Of course, most of us still use it now and again (if only to play Scrabulous), and there are a few signs that they’re starting to open the door to the Web ever-so-slightly in the other direction, so we’ll see what happens. There’s also OpenSocial to keep an eye on, of course, with Google so far managing to stay just on the right side of the good/evil line (all-seeing eye notwithstanding).

At the lighter end of the social networking scale, the star of 2007 was undoubtedly Twitter. Never has something so simple and apparently pointless been so intriguing and useful. Their business model (at least in the UK) is still a mystery though.

Some would say that 2007 was the year when Agile Software Development finally crossed into the mainstream. Unfortunately I tend to side more with Simon and Gus, and call it the year of compromised agile. It seems that for many large companies ‘agile’ has just become another buzzword. They talk about ‘enterprise scale agile’ and introduce a few of the easier, non-technical practices (daily stand-ups, retrospectives and so on), and put off making the real changes that are required for a truly agile organisation (co-located self-organising teams, daily customer involvement, devolution of decision-making, genuine focus on business value, an emphasis on technical excellence, test-driven development etc), while persisting with anti-agile behaviours such as outsourcing development, big up-front design, ivory tower architecture and fixed time, scope and budget. Baby steps are great, but there’s an implicit assumption that you take lots of them, instead of a few large ones.

Last but not least, 2007 was, of course, the year of the lolcat!

So what does 2008 hold in store? Unfortunately I didn’t get a crystal ball for Christmas, but here are a few guesses and hopes.

Will 2008 really be the year of Erlang? It seems to be building up the same kind of following (amongst many of the same people) that Ruby had 18 months ago, so who knows? It’s an interesting language, but I still find that the syntax grates.

Perhaps this will be the year when everyone finally realises that ‘Web 2.0’ has become so overloaded as to be meaningless. Sadly, even if that happens we’ll probably just see the buzzword bandits start calling something ‘Web 2.1’ or ‘Web 3.0’, so that’s a battle that’s never likely to be won.

Finally, could it be the year of OpenID and OAuth? If it weren’t for my poor security practices when it comes to personal site registrations, I’d have no chance of remembering account details for the myriad sites I’ve registered on, so wider adoption of OpenID would be nice. Similarly, it’s a pain finding and adding friends in yet another ‘social network’ application. I don’t really want to be handing out my GMail password left right and centre, and OAuth would (amongst other things) provide a neat way to request friends lists from other sites (and of course using OpenID would make it easier to identify people). Personally, I’d prefer it if everywhere just exposed my friends list publicly like Twitter does, or at least gave me that option. If they all used ~~FOAF~~XFN, so much the better.

Anyway, I ought to post this while it’s still New Year’s Day. Whatever technologies 2008 has in store, I hope it’s a good year for you.

[tags]ruby, rails, rspec, jtestr, facebook, agile, enterprise, compromised agility, lolcats, erlang, new year, 2007, 2008, web 2.0, openid, oauth, foaf[/tags]

Agile

The Neglected Practice of Iteration

Post author By Kerry Buckley
Post date 19 December 2007
No Comments on The Neglected Practice of Iteration

“It’s not iteration if you only do it once.”

I’ve already mentioned Jeff Patton’s XPDay keynote, where he talked about the importance of working in iterations (as opposed to increments). Jeff has now written a column, The Neglected Practice of Iteration, on StickyMinds, making the same point (but without the music!)

Excellent stuff, and well worth a read. I suspect most people who claim to follow an iterative development process are prone to lapsing into an incremental mentality – I know I am.

[tags]Jeff Patton, iteration[/tags]

Rails rspec Ruby

“You have to declare the controller name in controller specs”

Post author By Kerry Buckley
Post date 18 December 2007
1 Comment on “You have to declare the controller name in controller specs”

For ages I’ve been getting an intermittent problem with RSpec, where occasionally I’d see the following error on a model spec:

You have to declare the controller name in controller specs. For example:
describe "The ExampleController" do
controller_name "example" #invokes the ExampleController
end

The problem seemed to depend on which order the specs were run in, and for rake it could be avoided by removing --loadby mtime --reverse from spec.opts. It was a real pain with autotest though, and today (my original plan of “wait for RSpec 1.1 and hope it goes away” having failed) I finally got round to looking into it properly.

It seemed that the error was being triggered by the rather unpleasant code I wrote a while ago to simplify testing of model validation. Digging into the RSpec source to see what was happening, I found that that error message only gets returned when (as you’d expect) you don’t declare the controller name in a controller spec (specifically in an instance of Spec::Rails::Example::ControllerExampleGroup). The code that decides what type of example group to create lives in Spec::DSL::BehaviourFactory, and according to its specs, there are two methods it uses to figure out what type of spec it’s looking at:

it "should return a ModelExampleGroup when given :type => :model" do
...
it "should return a ModelExampleGroup when given :spec_path => '/blah/spec/models/'" do
...
it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\models\\' (windows format)" do
...
it "should favor the :type over the :spec_path" do
...

I began to suspect that the problem was caused by the fact that my specify_attributes method wasn’t declared in a file in spec/models, so I thought I’d try specifying the type explicitly. So instead of this:

describe "#{label} with all attributes set" do

I changed it to this:

describe "#{label} with all attributes set", :type => 'model' do

Sure enough, it worked! Not sure whether anyone else is likely to see the same problem (unless they’re foolish enough to use my validation spec code), but hopefully if you do, a Google search will bring up this post and it might point you in the right direction.

Uncategorized

Chocolate Type

Mmm…

web

BarcampLondon3

As you may have guessed from my other postings over the past few days, I spent the weekend at BarcampLondon3, at Google’s offices in Victoria, London.

This was the second Barcamp I’ve participated in (‘attended’ is probably too passive a word for a Barcamp), and was even better than BarcampBrighton in September. This was, of course, largely thanks to all the efforts of Ian and the other organisers, and to the wonderful hospitality shown by Google. From my own point of view, I think I also benefited from not going with a group of colleagues, which forced me to overcome my natural reticence and speak to people I didn’t know (it helps that the Barcamp crowd are a friendly bunch!)

If you have any geek tendencies and have never been to a Barcamp, I highly recommend it.

Oh, and as a footnote, I experimented with blogging some of the talks more-or-less as they happened. That’s why the posts were a bit rough, but at least they’re there – I still have notes from Agile2007 back in August that I haven’t got round to writing up.

My photos from the weekend are on flickr.

[tags]barcamp, barcamplondon3, google[/tags]

General nonsense