Bought New Kindle Fire, Made Mistake When Going Through Startup To Register, How Do I Back Up?

Netscape vi.0 is finally going into its first public beta. There never was a version v.0. The terminal major release, version iv.0, was released almost 3 years ago. Three years is an awfully long fourth dimension in the Cyberspace world. During this fourth dimension, Netscape saturday by, helplessly, equally their market share plummeted.

It's a scrap smarmy of me to criticize them for waiting so long between releases. They didn't do it on purpose, now, did they?

Well, yes. They did. They did information technology past making the single worst strategic error that any software company can make:

They decided to rewrite the lawmaking from scratch.

Netscape wasn't the first visitor to make this mistake. Borland made the same error when they bought Arago and tried to make it into dBase for Windows, a doomed projection that took so long that Microsoft Admission ate their lunch, and then they made it again in rewriting Quattro Pro from scratch and amazing people with how few features it had. Microsoft almost made the same mistake, trying to rewrite Word for Windows from scratch in a doomed projection called Pyramid which was shut downwards, thrown away, and swept under the carpet. Lucky for Microsoft, they had never stopped working on the sometime lawmaking base of operations, and so they had something to transport, making information technology simply a financial disaster, not a strategic one.

We're programmers. Programmers are, in their hearts, architects, and the start matter they want to do when they get to a site is to drive the place flat and build something grand. We're not excited past incremental renovation: tinkering, improving, planting blossom beds.

There's a subtle reason that programmers always desire to throw away the code and first over. The reason is that they recall the old lawmaking is a mess. And here is the interesting ascertainment: they are probably wrong. The reason that they call back the old code is a mess is because of a key, primal law of programming:

It's harder to read lawmaking than to write information technology.

This is why code reuse is so hard. This is why everybody on your team has a different part they like to use for splitting strings into arrays of strings. They write their own function because information technology'south easier and more than fun than figuring out how the former office works.

As a corollary of this precept, you can enquire almost any programmer today about the code they are working on. "Information technology's a big hairy mess," they volition tell you. "I'd like zip better than to throw it out and start over."

Why is it a mess?

"Well," they say, "await at this function. It is two pages long! None of this stuff belongs in at that place! I don't know what half of these API calls are for."

Before Borland's new spreadsheet for Windows shipped, Philippe Kahn, the colorful founder of Borland, was quoted a lot in the printing bragging about how Quattro Pro would be much improve than Microsoft Excel, because it was written from scratch. All new source lawmaking! As if source code rusted.

The idea that new code is better than quondam is patently absurd. Old lawmaking has been used. It has been tested. Lots of bugs accept been found, and they've been stock-still. At that place's nothing wrong with it. It doesn't acquire bugs just by sitting effectually on your hard bulldoze. Au contraire, baby! Is software supposed to be like an old Contrivance Dart, that rusts just sitting in the garage? Is software like a teddy bear that's kind of gross if it's non made out of all new textile?

Back to that two page function. Yes, I know, it's merely a simple function to display a window, but it has grown little hairs and stuff on it and nobody knows why. Well, I'll tell you why: those are bug fixes. Ane of them fixes that bug that Nancy had when she tried to install the thing on a computer that didn't accept Net Explorer. Another one fixes that issues that occurs in low retentiveness conditions. Some other i fixes that bug that occurred when the file is on a floppy disk and the user yanks out the disk in the middle. That LoadLibrary call is ugly but it makes the code work on old versions of Windows 95.

Each of these bugs took weeks of real-world usage earlier they were found. The developer might take spent a couple of days reproducing the bug in the lab and fixing it. If information technology's similar a lot of bugs, the fix might be i line of lawmaking, or it might even exist a couple of characters, only a lot of work and fourth dimension went into those two characters.

When yous throw abroad code and start from scratch, y'all are throwing abroad all that knowledge. All those collected bug fixes. Years of programming work.

Y'all are throwing away your market leadership. You are giving a souvenir of two or three years to your competitors, and believe me, that is a long fourth dimension in software years.

Y'all are putting yourself in an extremely dangerous position where you will be shipping an old version of the code for several years, completely unable to make whatsoever strategic changes or react to new features that the market demands, because you don't have shippable lawmaking. You lot might as well only close for business for the elapsing.

You are wasting an outlandish amount of coin writing code that already exists.

Is there an alternative? The consensus seems to exist that the old Netscape code base was really bad. Well, it might have been bad, but, you lot know what? Information technology worked pretty darn well on an atrocious lot of existent earth computer systems.

When programmers say that their code is a holy mess (every bit they always do), at that place are three kinds of things that are wrong with information technology.

First, in that location are architectural issues. The code is non factored correctly. The networking code is popping upward its ain dialog boxes from the middle of nowhere; this should have been handled in the UI code. These problems tin can be solved, one at a time, by carefully moving code, refactoring, changing interfaces. They can be done by 1 developer working carefully and checking in his changes all at once, so that nobody else is disrupted. Fifty-fifty fairly major architectural changes tin can be done without throwing away the code. On the Juno project we spent several months rearchitecting at one point: just moving things around, cleaning them up, creating base of operations classes that made sense, and creating sharp interfaces between the modules. But nosotros did it advisedly, with our existing code base of operations, and we didn't introduce new bugs or throw abroad working code.

A second reason programmers recollect that their lawmaking is a mess is that information technology is inefficient. The rendering code in Netscape was rumored to exist tiresome. But this merely affects a small part of the project, which you can optimize or even rewrite. You don't have to rewrite the whole affair. When optimizing for speed, i% of the work gets you 99% of the blindside.

Third, the lawmaking may be doggone ugly. I project I worked on really had a data type called a FuckedString. Another project had started out using the convention of starting fellow member variables with an underscore, simply later switched to the more than standard "m_". So half the functions started with "_" and half with "m_", which looked ugly. Frankly, this is the kind of affair you solve in five minutes with a macro in Emacs, not past starting from scratch.

It's important to remember that when you start from scratch at that place is absolutely no reason to believe that yous are going to do a better job than y'all did the first time. Beginning of all, y'all probably don't even take the same programming team that worked on version ane, so you don't actually take "more experience". You're merely going to brand most of the one-time mistakes once again, and innovate some new bug that weren't in the original version.

The one-time mantra build i to throw abroad is unsafe when practical to big calibration commercial applications. If you are writing code experimentally, yous may want to rip upwards the function you wrote last week when you call back of a amend algorithm. That's fine. You lot may want to refactor a grade to make information technology easier to use. That's fine, too. But throwing away the whole program is a dangerous folly, and if Netscape actually had some adult supervision with software manufacture experience, they might not have shot themselves in the pes so badly.