|Home » Resources » Rants
It Ain't All Microsoft's Fault
Week of June 28, 2000
Tired of Microsoft's monopolistic power? Think again. Without the bungling of their competitors, Microsoft might never have enjoyed such a market at all.
If Microsoft is anything, it is the company that comes from behind. Time and again Microsoft has been so 'out of it', yet at what looked like the last moment and then some, always pulled a rabbit out of their hat and come out victorious.
Such victories - such corporative successes - are only half the story. The other half - perhaps the more important half and by far - is how their competition screwed up royally.
Coming From Behind - Case I
In 1981 when the PC was introduced, C was a little known language in that environment. C compilers had been available for CP/M machines, but the CP/M market was nothing like what the PC market would become. The C compilers were a mishmash of arbitrary architectures as well, even though a sort of standard had been set by Bell Labs years before. Peter Norton introduced himself to the world with a bugged and leaky program called Unerase, written in Pascal. Most if not all MS-DOS work at Microsoft was done in assembler.
A couple of years later Bill Gates pulled the move of the century. In one fell swoop he bought a source code license to UNIX and bought up the Lattice C compiler. He turned the UNIX source over to Santa Cruz Operations and told them to build XENIX for him, and he set his own engineers to work on Lattice C.
The objective of the C compiler team at Microsoft was to attain UNIX compatibility. The initial release of Microsoft C was just the Lattice C package with a Microsoft banner, but the follow up, Microsoft C 3.0, was a different product entirely. It offered as much as possible of 100% compatibility with UNIX C. It had the same disk layout, the same environment variables, the same runtime library functions, the works. Microsoft C 3.0 was a good compiler, perhaps the best of breed back then, and was the only good compiler Microsoft was to release for more than a decade.
The problems started already with the follow up version, Microsoft C 4.0. A West German insurance company, using customized software provided by a local software vendor, accidentally paid out much too much to its customers, suffered grievous losses, but was able to trace the error to the software itself. It sued the vendor for everything but the lint between their toes.
The vendor, in a fright by now, examined its source code desperately. They had used Lotus Symphony, and were able after a while to trace the error in the software to Lotus Symphony itself. Now the West German software vendor sued Lotus Development Corporation for everything but the lint between their toes too.
Lotus was in a stitch - this was big money - so they set to work trying to find and identify the bug. Lotus Symphony had been developed on mini computers but for release cross compiled for the PC with Microsoft C 4.0. Lotus Development Corporation was able to prove that the error in Lotus Symphony which caused the error in the software in West Germany was directly attributable to a Microsoft compiler bug - the generated code would issue a short jump when a long jump was needed, with millions of D-marks lost as a result. Lotus Development Corporation now sued Microsoft.
Microsoft C 5.0 and 6.0 were, if possible, even worse, but the absolute nadir had not yet been reached. Microsoft C 7.0, the official compiler for Microsoft Windows 3.1, was so bad that Microsoft themselves had to use another compiler to build their operating system. It was so bad that Borland took out double spread ads right inside the front cover of the Microsoft Systems Journal that were no more than testimonials to how bad Microsoft C 7.0 really was - and Microsoft let them do it.
The testimonials said things that were very believable.
'We had Microsoft C 7.0 installed for all of fifteen minutes! It wouldn't even run!'
And it was all true. That's how bad it was.
Microsoft was going to have to come from behind.
Coming From Behind - Case II
By the mid 80's the world had a word processing standard. Moving from An Wang's dedicated machines to this level had taken some time. On everything from the VAX to the PC, WordPerfect was the name of the game. Everyone used WordPerfect.
Microsoft's own Word had enjoyed a satisfactory following from the start but it just could not compete. WordPerfect was a world-wide standard.
Microsoft was going to have to come from behind.
Coming From Behind - Case III
Provo Utah saw the birth of one of the most solid software development corporations in the world: Novell. Their NetWare became a rock hard standard for offices and LANs everywhere. Sure, people ran Windows on their PCs, but NetWare took care of PCs and Apples and Macs and almost anything. Back in those days it was considered secure as well. The sysadmins were happy.
Microsoft was going to have to come from behind.
Coming From Behind - Case IV
From out of the midwest Mosaic Communications Corporation blossomed and was the company. They led an entire revolution if you would have them tell the story, and it's really rather true as well. Their browsers got better and better, culminating in Netscape 3 Gold, still a classic on the market today.
Microsoft had nothing. Microsoft hadn't even realized the Internet was important.
Microsoft was going to have to come from behind.
Coming From Behind - Case I, Part II
Philippe Kahn, founder of Borland, had ventured into 'poor man's compilers' as soon as his SideKick left the ground. For one dollar less than 100, you got a reasonably good compiler with reasonably good documentation and support. It wouldn't be a production compiler, or something professionals would use in a real life context, but it was good - at least to play around with. Philippe Kahn made a lot of money.
When Microsoft started screwing up with their Microsoft C, Philippe saw his opening. Pulling out all the guns and all the stops, he developed Turbo C all the way to Borland C++, putting the corporate name on the product for the first time.
Philippe had good people working for him, and the products Borland C++ 3.0 and Borland C++ 3.1 were amazingly good. Resource Workshop was a wonder in itself, capable of digging into executables and into projects both. Microsoft had nothing comparable at all. Resource Workshop was so smart and so polite that it would leave everything in every source file exactly as is, and change only what was actually edited.
The compiler was a wonder to watch too. It did things Microsoft cannot do even today. Understanding that Windows was an environment of its own, the compiler did everything in its own integrated development environment and didn't bother creating console processes to do the dirty work. One of the greatest things about this compiler was how it worked if the files to be compiled were already loaded in the editor: it simply used the buffers on hand, rather than go back to disk. The cute little '->' in its 'fluff box' was simply amazing. This was a smart program written by some very smart people.
By the time Borland C++ 3.1 was released, Borland had the entire market. And Microsoft was nowhere in sight.
All these companies enjoyed untold market shares and wealth. They were untouchable. So what happened? Was it only the Microsoft behemoth come to visit?
Screwing Up - Case I, Part III
Scott Randell, head of Afx at Microsoft, had toured the world in 1992 with Microsoft C 7.0, touting it as 'bleeding edge technology'. People had bit and were mad. Now he was coming back again - with something called Microsoft Visual C++ 1.0.
Microsoft Visual Basic had given vendors the kind of time to market framework they needed but it was much too heavy to use in serious applications. Microsoft Windows was considered too difficult to program under any circumstances. Microsoft had got their hands on a Windows integrated environment called Quick C from Net Systemes that had been widespread without making any dent in the market for real development tools. Microsoft and Scott Randell's MFC boys put it all together and came up with Microsoft Visual C++, using what Scott called 'a sane subset of C++'.
The MFC was a blatant rip-off of SmallTalk architecture, but nothing wrong in that. It established a basically one on one relationship with the Windows API, perhaps because of time constraints, and the competition actually lauded this move. Most importantly, Microsoft had got the underlying compiler to work again. Executables built with the Microsoft C shipped with Visual C++ 1.0 were anywhere from 40% to 60% smaller than the corresponding Borland C++ 3.1 modules.
Borland went into a tiff. They produced a 78 page white paper trying to deny the fact that Microsoft's EXEs were so much smaller - all the while the truth was there, hitting them smack in the face. Borland both looked and felt bad.
But was the battle over? Certainly not. In all other respects, Borland's package was still by far a 'best of breed'. The Microsoft tools were put together in great haste and its environment was, to say the least, aggravating to work in. Smart developers did everything but make the final release module with Borland, then quickly switched horses to the moronic Microsoft package and built again. All Borland had to do was get their act together on EXE size and Microsoft was toast.
What did Borland do instead? They panicked by all accounts. Microsoft had woken up again, Microsoft was back in the racing. Borland - its suits or its developers or both - went completely over the top. As heard so many times since from so many crashing corporations, there were great things expected for the next release, which would be revolutionary, which would have things other people had not even thought of before, this was going to be sensational, etc. And as with the other crashers that would later come, there were delays. There are always delays.
When the product finally hit the market close to one year after it should have, it hit like a wet fat piece of blubber. It was horrendous. As to all these fantastic things no one had ever heard of before, they were not to be found.
What Borland had done was to completely rebuild the entire architecture of its compiler and build environment, as well as its class system. Programs which built like a breeze with Borland C++ 3.1 generated so many errors that it was almost pointless to even pursue it. They moved all the directories around. They moved the macros around. They even moved the class members around. It was a fantastic mess.
No to speak of how it ran. It didn't. It was the biggest bloat monster of its day, by far. Talk about leaks - a re-boot after starting and stopping it twice was an absolute necessity. Yes, it was that bad.
Learning Tree International was a very egalitarian company back then. Their Windows programming courses always included both the Microsoft Visual C++ and the Borland C++ environments. All project files provided for the delegates were compatible with both Microsoft and Borland. Project files for both environments were included, and when necessary, pre processor statements could be used to determine which compiler was running and include and exclude the right statements. Every effort was made to be fair and give the students every possible opportunity to test everything, and to learn how both environments worked.
When Borland released Borland C++ 4, Learning Tree felt it incumbent to warn its students. Some classes used the new Borland environment along side the Microsoft offering, others stuck with the previous Borland release, but all classes specifically warned all delegates about the Borland upgrade, and recommended they not use it. This was absolutely necessary. This was part of teaching. This was not Microsoft pressure: this was simply relating the truth.
Screwing Up - Case II, Part II
When Microsoft got ready to unleash its Windows 3 on the world, WordPerfect contacted them and asked for some specifics on how the environment would function. WordPerfect contends Microsoft never gave them what they wanted. WordPerfect contends that they had to 'wing it' for areas of their program about which they were not certain, because they'd never received the answers to their queries from Microsoft.
Perhaps. And perhaps it was somewhat decisive. But it can't be the whole story.
WordPerfect for Windows 3.1 was often accused of screwing up network printers. When the LAN started sneezing, sysadmins would say 'someone's trying a print-out from WordPerfect again!'
And Microsoft Word was on the march. Both corporations published incontrovertible statistics which proved that their word processor was used by far more people than the other, both tried to claim being 'best of breed'.
WordPerfect had their (in)famous code window. Something necessary before the advent of the WYSIWYG word processor, something questionable like an inflamed appendix afterwards. They still had this technology as they moved on to version 6. And by now, the wounded minority were joining camps: Borland and WordPerfect programmers were working together on both corporations' products. Meaning WordPerfect had such excellent development tools as Borland C++ 4, the environment Learning Tree was so shocked by they had to warn all their students world wide.
WordPerfect 6 came with its own soundtrack CD (sic). Yet its release was the biggest non-event in PC history in the early 90's. It just didn't happen - it was just a bit of a 'thud' in the market, and then just as quickly, WordPerfect was gone.
Both WordPerfect and Borland started getting tossed around like helpless rowboats in a typhoon. From one day to the next they'd got new homes and new owners. They became hot potatoes that no one really wanted - at least not for long.
Screwing Up - Case III, Part II
Novell NetWare 3.12 was an industry standard. It was also one of the most bullet proof pieces of software ever written for use in a LAN. The Provo programmers were legendary, the status of Novell unchallenged. They had won everything, and had no way to lose a thing.
Back in 1986 Novell had begun research into what was to become many years later NetWare 4. This product took all of about ten years to develop to the point of satisfactory stability and functionality.
But by 1988 David Cutler was all but on board at Microsoft, and Novell started to panic. They started to rush their NetWare 4 project. In short, they started, as so many other corporations before them, to screw up.
Betas of NetWare 4 started hitting the general populace before the word got out too much about NT. That was the whole idea. Provo was scared that NT would come out first, eclipse the NetWare 4 project, and devour the market. Vaporware was the answer, and vaporware doesn't stay credible long. Provo developers started making major mistakes and actually delaying the release of NetWare 4 rather than speed it up.
Ten years later NetWare 4.12 was a solid product, but who cared anymore? By releasing first so many horrendous betas and then so many terribly bugged releases, Novell had tarnished their image for all time. It wasn't so much a question of NT beating them into the market: LANs weren't going to change that quickly from one LAN OS to another, especially when things worked well as they were; it was the way Novell screwed up.
Today Novell CNEs are given courses in Windows NT Server administration, just so they can stay ahead of the times. And this attempt to keep them ahead of the times is also, for the rest of us, a very easy to read sign of the times.
Screwing Up - Case IV, Part II
By the time Jamie Zawinski jumped ship at MCOM the Netscape browser was a mess. Jamie jumped when AOL went in and bought them out, but that wasn't the only reason Jamie quit. That was only the last straw, as he says himself. By the time Steve Case got his hands on the Netscape browser and the Mozilla project, all that was left was a big piece of blubber fat.
The front end for Netscape was built wrong from the start. Today IE can outshine NC in any number of ways precisely because this part of the code is built correctly. IE does not use the leaky MFC. NC does. IE gets the guts of the program running correctly and running well and makes sure it's fast and efficient. NC just builds new layers of fat on top of the old ones. It's the same old story - the competition screwing up, going from unparalleled success to bloat champion - and for seemingly no good reason either.
Mozilla Milestone 17 will soon be released - something Bruce Jensen, author of the well known 'Revenge of Mozilla', calls 'the biggest non-event in the history of computing'. The blubber only gets worse, the performance poorer, the sag on the system more insufferable - and the AOL and MCOM programmers know what is wrong, they have always known what is wrong, but they are thinking wrong is the problem, thinking wrong like all these losers, and they're not doing a thing about it.
Microsoft came from behind - in each of the above four cases, and in so many more. They suddenly woke out of their reverie and noticed a market was evaporating and a new king had come and been crowned. And in each case, in addition to all the dirty tactics they're so good at, that they're getting their knuckles busted in Washington today for, their programmers just slugged along, drudgery of drudgeries, day in and day out, and tried and tried and oh how they tried to improve their code, a bit at a time, and they never lost sight of what the market is all about, and they never panicked.
So if you're mad at Microsoft for being so monopolistic, if you're mad because Microsoft has been able to hold back the hands of the clock so you can't get all the really cutting edge technology that is out there, if you're mad and disappointed that things have come to the deplorable impasse we're at now - go ahead and be mad at them. They deserve your scorn to be sure.
But don't forget the others. Without their bungling, a lot if not most of this would never have happened.