Software Tailors

I came upon an article a few days ago relating software developers to tailors. The author (Patrick Rhone) wishes to have software tailors: people who will customize (or custom-make) software for you, for a price. It’s an interesting idea and not without its practical merits. In particular, given how most software today is “mass-produced” and customization options are in general, limited at best, a cottage industry of software-tailors might not be a bad idea. But for all its merits I think the idea is somewhat short-sighted. Software is sufficiently different from physical goods (including clothes) that applying the same concepts and processes to software and clothes is fundamentally flawed.

Operationally, software is much easier to change than physical matter. There’s no physical matter to change and if you make a mistake you can revert and go back to what you had. Undo is your friend. That means that even new programmers can create things of values, make mistakes and learn quickly by doing. However, conceptually, making software is as hard, if not harder than manipulating physical objects. I’m not a tailor, but I would wager that hacking on a complex piece of software requires as much skill as making alteration to a jacket. In fact, understanding million-line codebases might well be harder than tailoring a suit to custom dimensions.

The second flaw in the software tailor argument is that our software needs are far more varied than our clothing needs. Humans all have the same general body plans, you only need a handful of numbers to make a shirt fit. But our software requirements are far more varied. The text editing requirements for a novelist are different than that of a blogger which in turn are different from that of a programmer. To really understand what each person needs the programmer needs to have a pretty thorough understanding of what the problem domain is. This in turn means that the programmer either needs to be using that specalized software on a regular basis or the customer needs to able to communicate very clearly what they want. As anyone who’s written software for clients knows, getting proper requirements is often the hardest part of the project. This is why the best software is often “dogfooded” – the developers have been using what they’ve been developing. Furthermore making changes to any part of a codebase often requires understanding more than just the component you’re changing. What might be “just a few changes” to Mr. Rhone would probably end up be hours of diving into foreign source code (or at least learning an API). Writing good software is hard, writing good custom software is harder still. I don’t want to dismiss the idea of software tailors out of hand, but I want to make it clear that the job would not be like the analogy that Mr. Rhone provides.

If we can’t have neighbourhood software tailors, then what can we have? Customized software is good, because as I’ve said, people have very varied software needs that standardized software often falls short of accomodating. What I think we need is twofold: a technological shift where developers write extensible software by default and a cultural shift by which users are no longer afraid to modify their own software. Programmers (especially open source developers) are used to modifying and extending their own tools, I want to see common software users modifying their word processors and email filters.

But, but, but, does this mean we should make our own clothes and do the servicing on our cars ourselves? No, of course not. Like I said, the tailor (and the mechanic) analogy is not the right one. A better analogy is cooking. You can eat your meals at restaurants and fast food places (use standard consumer software) or you can cook your own. If you can spend an hour or two a day putting together ingredients in exact proportions and heating them at specific temperatures for specific times, you can spend half an hour a day typing some some code to make your software work the way you want it to.

Now this cultural shift is only possible if the software supports it and right now most of our software doesn’t. But that can change. Text editors like Emacs and shells like Bash and Zsh are meant to be customized and its not hard to do so once someone shows you how. Browsers are also customizable, though not quite as easily. Luckily software is malleable and with more and more people being software literate I think this is a feasible change in the not-too-distant future. Mr. Rhone wants a shift to developers making it easier for software to be extended, but those some changes could just as easily make it easier for users to adapt their software.

So with all due respect to Mr. Rhone, I don’t want a culture of software tailors. That’s not any different from the programmer-priesthood we have today. Unlike our clothes, our computers are incredibly powerful machines and we’re increasingly dependent on them in both general and very specific ways. I want a culture of citizen hackers: a generation of people who can mix and match their software just as we can develop our own dressing or cooking styles.

As programmers, our job isn’t to write code or be better craftsmen. It’s to solve problems, everything else is tangential. I believe the best way to do that is by empowering users to better solve their own problems. We fight for the users so that they can fight for themselves.

Advertisements

Published by

Shrutarshi Basu

Programmer, writer and engineer, currently working out of Cornell University in Ithaca, New York.

One thought on “Software Tailors”

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s