Good Enough Software, or, Software for the New Hacker Culture

Someone recently asked me to help define “good enough software.” I
had a vauge notion of what they were talking about, so I did my usual
rabbit-out-of-the-hat trick, distilling a few bookmarks from here and
there into something. I’m not really 100%, so to speak, on the
resulting “something,” but it seems like an interesting idea. Anyone
have reactions?

It’s all about lowering the barriers to entry, folks, whether we’re
talking about virtual machine technology and developer strategies, or
blogs and user participation. –James
Governor, RedMonk

The idea of “good enough programming” isn’t that the quality of the
code is low, or that the programming is easier. Indeed, creating good
enough software is often as hard or harder than “perfect programming”
(or whatever the opposite of “good enough programming” is). It’s more
in the way you design and spec out your product. The main goals are
(1.) to keep things as simple for the user as possible, and (2.) give
your users and developers the chance to mold and create the software
to their desires post-install, at runtime.

So far, the primary tactical thing to do is to loosen up the reins
on the ontological
structure of the software. For example:

Unstead of placing everything in a tree, allow
users to arrange everything in flat lists, based on
tags. Chances are, your users can manage meta-data better,
faster, and more reliably over the life-time of the data than you
can.
Or, instead of locking up all our data in a DB, middle-ware, or
behind more “complex” APIs, provide a
very open, and simple to use HTTP and XML based API to allow
customers to extract and insert any sort of data they want into the
system.

The Hack Culture, Pro-Am, DIY, &co.

One of the underlying notions here is the rising tech-litercy of
the customer base, or the “hacker
culture” as some call it. People are more and more willing to do
more of the “programming” work if it means they can get the software
to do exactly what they want. So, instead of providing a
“complete and perfect” solution that’s very difficult to modify and
bend to your will, you provide a “good enough” feature set that has
very open and expressive APIs and UI’s that let users hack it to their
will.

An implicit benefit of this type of architecture is that
integration intra-organization becomes easier. You’ve baked in the
notion that people other than the original programmers will modify and
further code the software. So, when other teams in the same
organization need to integrate with this software, it’s ready, out of
the box for that. Even better, a customer or user of that software
might have already done the integration work.

(See also “The Age
of the Amateur”.)

Examples of Such Stuff

http://maps.google.com -
dozens of people have figured out how to hack this to get it to do
interesting things. For example, here’s someone who’s figured
out how map cheap gas locations onto Google maps. (Select
TX-Houston, and drag the map around to see where the cheap gas
is).
http://www.flickr.com -
(recently bought by Yahoo!) has an extremely open platform, allowing
users to enter endless amounts of meta-data about their
photos. There’re many ways users have re-mixed flickr and other
services into new and valuable services and software (probably a
large part of why Yahoo! Bought them). For example, in combination
with a Google maps hack, this site
allows you query for photos geographically. (It’s a slow site as it’s
in no way a commercial thing, so they don’t have beefy servers).
“
Grease Monkey is to Web Services as REST is to SOAP” – a recent
post of mine on the subject of a “good enough software” approach to
internal enterprise biz apps.

We Still Want Easy to Use Software

Don’t get me wrong: I’m not saying that’s the only
“interface” into software. You still need very easy to use and simple
(as in not overly complex) UI and IA. My point is that this hacker
culture is an additional market to cater and sell to. Indeed,
to frame this in the marketing world-view from Seth
Godin’s latest book (All Marketers Are Liars), the idea of
“good enough” software sells to an under-served market that’s longing
for someone to sell them the story that they’re super-smart, or at
least pragmatic, hackers who like tweaking their software.

Leverage the Genius of Your Customers/Users

All that verbiage aside, the larger point is this: more people are
comfortable with and willing to work with computers. If you buy
the whole Gamer
Generation line of thinking, there’ll be even more of them
soon. As such, they want to be able to interact with and customize
their software. No one wants software to tell them how to go about
their job. Instead, just as they would customize their house, car, or
anything else, they want to customize their software.

As software developers, we currently tend focus on the perfect
feature set and prescribing how to use our software (or implementing
the “prescriptions” customers with fat bags of cash tell us they
want). Instead of listening only to those folks, we should start
opening our system up more and more, catering to the emerging market
of DIY-users.

Most of this group of customers would be new customers for
traditional software vendors: people who had previously dismissed
those companies as too stodgy for them to work with, or too expensive,
either by flat-price, or the TCO that results when they try to
customize the software to their needs. At the same time, it can keep
current customers happy because you’ll delivering them new features
and (if you act fast enough) differentiate yourself from the
competition, both of wich result in one thing: more money.

Coté's Drunk & Retired