* * * * *

                              Joel on Bloatware

> **SMS:** Joel, what, in your opinion, is the single greatest development
> sin a software company can commit?
>
> **Joel:** Deciding to completely rewrite your product from scratch, on the
> theory that all your code is messy and bug prone and is bloated and needs
> to be completely rethought and rebuild from ground zero. **SMS:** Uh,
> what's wrong with that? **Joel:** Because it's almost never true. It's not
> like code rusts if it's not used. The idea that new code is better than old
> is patently absurd. Old code has been used. It has been tested. Lots of
> bugs have been found, and they've been fixed. There's nothing wrong with
> it.
>

An Interview with Joel Spolsky of JoelonSoftware [1]

I've been pondering this article for the past few days as I worked on my
project [2] and I still feel Joel [3] is wrong about this.

Yes, it does cost if existing code is scrapped and a rewrite is done. But I
suspect it's not done correctly—with the original authors who learned the
hard way what does and doesn't need to be done. It's done with another set of
programmers who have little (if any) contact with the original authors so any
important information (like Microsoft IIS servers that send out bad Location:
headers) is lost.

That's why it costs so much.

And yet, I've done it. I've rewritten the same program three times [4] over
(once to switch implementation languages) and each time the code base has
improved over the previous version. The latest version had a better base upon
which to make modifications (but it's moot since no version of the program is
in use, but not for maintenance reasons).

And the cases Joel uses as examples are well known cases where a rewrite was
disasterous, but what of NT? That was based upon an entirely different code
base than Windows 3.1 and even my most anti-Microsoft friends admit that NT
3.51 was rock solid and well designed (and had nothing in common with Windows
3.1 or 95 except the API). OS/2 2.0 was a rewrite and vastly better than OS/2
1.x.



> The sheer volume of bugs, it seems, proves that rewriting code from scratch
> does not make for a better code base, it makes it worse. Old code doesn't
> rust, it gets better, as bugs are fixed. Lou Montulli again: “I laughed
> heartily as I got questions from one of my former employees about FTP code
> the he was rewriting. It had taken 3 years of tuning to get code that could
> read the 60 different types of FTP servers, those 5000 lines of code may
> have looked ugly, but at least they worked.”
>

Joel on Software—Netscape Goes Bonkers [5]

And I bet those 5,000 lines of code where a nightmare to maintain. Lou
Montulli probably laughed because he didn't have to maintain that codebase
anymore. Yet another project I worked on involved a program written by a
college student that was so poorly written I can't even begin to describe how
bad it was (let's see, in C, but with random indentation, poor variable name
choice and could produce garbage in rare but most likely inevitable
circumstances). Even the original author refused to help (“Hey, I got paid,
man! I'm not touching that fXXXXXg code again! He [the customer] got what he
paid for!”). So it was without ceremony (since the author was too far away to
sacrafice) that I dumped the code and rewrote it from scratch.

> **SMS:** Yes, but isn't such code tight and small? Don't products built
> this way avoid the dreaded “bloatware” label?
>
> **Joel:** Don't get me started! If you're a software company, there are
> lots of great business reasons to love bloatware. For one, if programmers
> don't have to worry about how large their code is, they can ship it sooner.
> And that means you get more features, and features make users' lives better
> (if they use them) and don't usually hurt (if they don't). As a user, if
> your software vendor stops, before shipping, and spends two months
> squeezing the code down to make it 50% smaller, the net benefit to you is
> going to be imperceptible, but you went for two months without new features
> that you needed, and THAT hurt.
>

An Interview with Joel Spolsky of JoelonSoftware [6]

Now, Joel worked for years at Microsoft, so he's biased, but here's a reason
as a customer to hate bloatware: You don't have to buy a new computer every
two years! You have more resources to store and process your data, not to
store bloatware. The software might actually run faster, or run acceptably on
something less than the greatest and latest.

But as Bill Gates has said—there's no money in fixing bugs, only in features.


[1] http://www.softwaremarketsolution.com/
[2] gopher://gopher.conman.org/0Phlog:2001/11/25.1
[3] http://www.joelonsoftware.com/
[4] http://www.conman.org/people/spc/refs/search/
[5] http://www.joelonsoftware.com/articles/fog0000000027.html
[6] http://www.softwaremarketsolution.com/

Email author at [email protected]