[In January, 1998, in my ISP's general discussion newsgroup, we were discussing software and the marketplace, and I mentioned that all too many people don't even know what they're missing. Someone asked what I meant, and this was my response. I have added to it slightly since then.]

From: scs@eskimo.com (Steve Summit)
Newsgroups: lobby
Subject: Re: software elegance (was: Root for the Indians this time?)
Date: 17 Jan 1998 17:56:38 GMT
Lines: 173
Message-ID: <69qrcm$ben$1@eskinews.eskimo.com>
References: <34b7e300.18628677@news.eskimo.com> <69bncf$e0v$1@eskinews.eskimo.com> <69o1ib$qjj$1@eskinews.eskimo.com> <34c057b5.9765222@news.eskimo.com>

In article <34c057b5.9765222@news.eskimo.com>, wayneld@eskimo.com writes:
> On 16 Jan 1998 16:23:39 GMT, scs@eskimo.com (Steve Summit) wrote:
> > -- know what they're missing in terms of software elegance.
> What exactly is the defintion here of "software elegance?"

Why, vague and unstated, of course; otherwise how could we have eternal pointless arguments about it? :-)

Elegant software is compact and efficient. Mundane software is bloated and slow.

Elegant software has features that people need and use. Mundane software has features that may look good on paper and impress magazine editors, but which few people use in practice and which serve only to add to the bloat (and the bug count).

Elegant software lets you do what you want to do. Mundane software lets you do what you want to do, as long as you do it its way.

Elegant software does one job and does it well. Mundane software tries to do two or more jobs, and/or does its job(s) clumsily (or sometimes does no job at all).

Elegant software has a clean model for the data it works with and the operations it performs on it; this model is easy to understand and when you do, you find that it matches the way you think about your data. Mundane software either has no well-defined model at all, or has one so bizarre that only its programmers comprehend it, leaving you largely in the dark, forced to perform operations by rote, without understanding them and powerless to adapt (to new situations or in the face of simple mistakes, either yours or the software's).

Elegant software lets you do things its designers never imagined. Mundane software lets you do only those things its designers imagined.

Elegant software is configurable where it needs to be, but works well out of the box. Mundane software is either not configurable at all, or so overly configurable that no mere user dares delve into its labyrinthine configuration subsystem, and/or installs itself initially with defaults which no sane person would want to use.

Elegant software lets you grow with it, providing shortcuts and advanced features which you can use when you're ready to but which don't get in your way or bewilder you when you're not. Mundane software is targeted at exactly one audience, and is either droolingly user obsequious but maddeningly frustrating for an experienced user to use, or expert friendly but impossible for a beginner to use.

Elegant software lets you explore its features with confidence, and protects you from mistakes. Mundane software punishes you sternly for the slightest misstep.

Elegant software comes with a clearly-written manual, indexed by topic, written from your point of view, which you'll rarely need to refer to because the software is so intuitive and natural to use. Mundane software comes with an enormous and incomprehensible manual (probably not printed but on-line, using a new clumsy interface completely different from any other on-line help system you've ever used), indexed by command, written from the technical writer's best approximation of the programmer's point of view, supplemented after the fact by a cottage industry of third-party books which you can buy to really help you use your new software.

Elegant software is self-contained and easy to install and uninstall. Mundane software requires 73 ancillary components before it will run; and if it is able to install them itself, does so in a way which blows away newer versions of those components if you happen to have them; and if it is able to uninstall itself, deletes those components even if other programs are relying on them.

Elegant software works with your machine and other programs on it. Mundane software takes over your machine.

Elegant software adapts to its environment. Mundane software requires you to configure it or its environment explicitly, and if some aspect of the environment prevents it from running correctly, either crashes or exits with an error message which doesn't tell you what the problem is.

Elegant software can work with as much data as you have memory or disk space for. Mundane software is riddled with arbitrary, fixed limits on the number of pieces of data you can work with and their sizes.

When it has restrictions, elegant software imposes them in such a way that they can be gracefully relaxed in future versions. Mundane software imposes limits which immediately become locked in, and which can never be removed, or can be worked around only with gross kludges, or can be abandoned only by abandoning the old software and everything that it works with, and starting from scratch.

Elegant software is programmable (when you're ready for it), and can be used by other programs. Mundane software (as already mentioned) can perform only those functions which its designers explicitly thought of, and none of those functions can ever be automated, because they depend heavily on visual, graphical, user interactions.

Elegant software conforms (where applicable) to open, industry standards for file formats, networking protocols, and the like. Mundane software invents its own formats and protocols, and depending on the nerve of its vendor, attempts to foist them upon the industry as closed standards.

Elegant software lets you "pop the hood" and inspect your data or work with it in ways that the program can't, i.e. makes it possible for you to access your data with external tools. Mundane software stores your data in inscrutable formats which you can't use standard tools to access, and may actively prevent you from even trying, in part by imposing a software license which forbids reverse engineering.

Elegant software is backwards and forwards compatible with past and future versions of itself. Mundane software might be able to read one or two of its previous version's formats, but it can't write them, and it crashes if it tries to read one of its future version's formats. (For that matter, elegant software uses open-ended data formats which rarely if ever need to be supplanted, while mundane software gratuitously changes its data formats with every release whether it needs to or not.)

Elegant software is relatively free of bugs, and those that it has are minor, or off in corners where hardly anyone notices them, and are usually easy enough to work around. Mundane software is full of glaring bugs, many of which cause unrecoverable crashes if the software is used to do anything its designer didn't imagine, is ever used outside the one narrow usage pattern which the designer had in mind and tested for.

When it happens to contain a bug serious enough to cause a crash, elegant software takes care to save your data even as it's crashing. When mundane software crashes, it not only loses (or subtly garbles) your data, it may also (if running under a mundane operating system) take other applications down with it, or crash the operating system itself for good measure.

Elegant code works for the right reasons. Mundane code just happens to work.

Elegant software works automatically on all machines you would expect it to, with all peripherals you would expect it to, including those which haven't been built yet. Mundane software either works only with the one specific hardware configuration that its designer used and tested for, or has been laboriously tuned to work with a list of 437 existing hardware configurations which does not include yours.

Elegant software is general-purpose. Mundane software is unnecessarily specialized.

Elegant software assumes that you are intelligent and can learn, and that you are interested in using a computer to save time, automate repetitive tasks, and eliminate busywork. Mundane software tries to do everything for you (presuming that you can't), but ends up requiring you to specify everything you want to do in minute, tedious, timeconsuming, mind-numbing detail.

Elegant software is written by programmers who have their users in mind, who listen to user feedback, who are rewarded for their creativity, who code with an eye to demonstrable, lasting correctness, and who are constantly searching for new and better ways to write interesting programs with fewer bugs. Mundane software is written by programmers who have themselves in mind as users, who try to tell other users how to think like they do, who are rewarded for the number of lines of code they write per day or for how well they're able to implement specs delivered from on high, who are happy with a program if it seems to work today, who would like best to keep writing programs exactly as they wrote them yesterday, and who regard bugs as inevitable.

Elegant software is a joy to use. Mundane software is a pain in the ass.

Steve Summit