07/20/98 ONLINE ORIGINAL: MICROSOFT AND OPEN STANDARDS: DIALOG WITH A READER

Return to main story

MICROSOFT AND OPEN STANDARDS: DIALOG WITH A READER

David Michelson, a research scientist specializing in computational electromagnetics and a full-time consultant in antennas and propagation to AT&T Wireless Services in Redmond, Wash., and AT&T Labs-Research in Red Bank, N.J., responded to my July 20 column on browsers with a forceful argument that Microsoft should commit itself to the use of open standards in its operating systems. I responded to him, and an E-mail dialog exchange between David and myself on the subject of open standards ensued, resulting in the following dialog:

DM: The real issue isn't whether Microsoft should be allowed to incorporate a Web browser into Windows 9x. It's whether Microsoft should be allowed to freely compete on others' turf while they deny others the opportunity to compete on their turf. That's what antitrust is all about. In the world of telecom, the RBOC's [regional Bell operating companies] aren't allowed to offer long-distance service until the long-distance companies are able to offer local service. So why, in the computing world, should Microsoft be allowed to develop functional clones of Netscape's Web browser and, say, the Borland/Inprise C++ compiler while they effectively prohibit Netscape and Borland/Inprise from developing functional clones of the Windows API?

SW: Microsoft is not (yet) a regulated public utility, which strains the analogy with phone companies, and I for one hope it never becomes one. I don't want a cure that is much worse than the disease, and I can't imagine anything worse for the industry than the heavy hand of government.

DM: I don't want to see Microsoft become a regulated public utility, either. It's not necessary. However, Microsoft *is* a monopoly. Anyone can write a compliant C compiler or Web browser based on the relevant standards. Why shouldn't anyone be able to implement a compliant Windows Applications Program Interface (API), based on a documented standard?

Microsoft has benefited greatly from the many Open Standards that others in the computer industry have contributed to the community. From C and C++ (developed by AT&T) to TCP/IP and the Internet protocols (developed by DARPA, BBN, Sun, and many others), to HTML, Java, and all the rest, these standards have allowed anyone, including Microsoft, to enter new markets knowing that their products will be compatible with, and can compete with, products developed by others.

In particular, without Open Standards, it would have been very difficult (if not impossible) for Microsoft to have developed Java, C and C++ compilers to compete with Sun and Borland/Inprise or a Web browser to compete with Netscape.

But while Microsoft has been quite willing to use Open Standards for computer languages and internet protocols to compete with Borland/Inprise, Sun, and, most recently, Netscape, it has been unwilling to release the Windows API as an Open Standard so that others can compete on *its* turf. As a result, one can choose from numerous implementations of language compilers, office suites, and Web browsers for Windows. But only Microsoft can produce an operating system which fully supports the Windows API.

SW: I think there are two separate issues here. One is the question of intellectual property. Those who have invested a great deal of money in intellectual property generally resist the idea of allowing others to use the fruit of their labors without payment. That's true for Microsoft or Apple or Intel or Novell or even Sun.

DM: In the Open Standards world, one tends to regard the interface as public and the implementation as the intellectual property. For example, Sun has released many of their software innovations as Open Standards. NFS and NIS come to mind immediately. While NeWS was not widely accepted, others in the Open Standards community contributed to and released the X Window System. Were these trivial efforts? Hardly. Did releasing these as Open Standards hurt the companies involved? Not at all. But it enriched the community as a whole and encouraged innovation, especially among smaller companies.

SW: Microsoft is not inclined to open Windows to the point where anyone could write, say, a Windows emulator for Solaris, without licensing Windows from Microsoft. And I can't say I blame them. Microsoft's shareholders bore the risk of the investment in developing Windows, and they are entitled to profit from it.

DM: Sure. But that brings us back to the antitrust aspects of the whole deal. In its quest for success, Microsoft is quite willing to absorb and assimilate all the innovations and Open Standards produced by other companies. But it refuses to reciprocate. It refuses to allow others to compete on its turf while it freely competes with others on their turf.

If others could compete with Microsoft as easily as Microsoft competes with them, I (and probably the Justice Dept.) would be happier. So would consumers, since Microsoft would have to respond to cheaper, better, more reliable implementations of the Windows API in the way Intel and Compaq have to react when their competitors release new and improved processors and PCs. As it stands, Microsoft is a black hole -- innovations and Open Standards pour in, but nothing comes back out. And nobody can make Microsoft accountable.

SW: The open standards question is problematical. As the term is commonly used, it is more or less synonymous with Unix.

DM: Until we agree on the terminology, we're not going to agree on the issues. Open Standards does not mean Open Source.

By my reckoning, C, C++, Fortran, TCP/IP, HTML, XML, NFS, POSIX, and Java are all Open Standards because they're fully documented. Anyone can implement relevant, compliant software based on reading of these standards. In many cases, test suites are available to verify compliance. And anyone in the industry can contribute to future releases of these standards.

SW: I wonder whether open standards are really meaningful without open source. Microsoft will argue that the API is public in the sense that all the API calls are documented, and all the required calling information is available through the various software developer kits, Microsoft Foundation Classes, etc. Independent software vendors reply that the documentation is often incomplete, and the performance of the APIs is erratic and subject to change without notice. As near as I can tell as an amateur, both sides are right.

DM: I guess those of us in the UNIX and X worlds are just plain spoiled :-)

SW: The fact is that Windows (95, 98, or NT) is so hideously complex that it probably never can be, and almost certainly never will be, completely documented.

DM: Microsoft would like people to believe that. I doubt that the Windows API is any more complicated than the X Window System API or the high-level POSIX API. Granted, the Windows API is probably not nearly as orderly or well-organized. But it could be done.

SW: Correct me if I'm wrong, but I thought that the APIs were the interface. Certainly, in a formal sense, the C++ header files that are part of a software development kit, constitute the interface by giving the calling requirements for all public functions.

DM: Absolutely.

SW: I thought the complaint was that the interface information was incomplete or inaccurate in that the functions do not always perform as specified.

DM: That's certainly the issue as I understand it.

SW: I would ascribe that to inexcusable sloppiness rather than any conspiracy on Microsoft's part, which doesn't make it any easier for the poor developers who have to live with the code.

DM: Which brings to mind two quotations which Henry Spencer (of USENET/USENIX fame) has, in the past, featured in his signature

"Never attribute to malice that which can be adequately explained by stupidity."

"Those who don't understand UNIX are condemned to reinvent it, poorly."

SW: In the end, I think open source is the only route to true full disclosure. Unfortunately, it is also the golden highway to the appropriation of your intellectual property. I don't think there's an easy answer.

DM: We do have a first approximation, though: Make the interface public. Make the implementation yours. It works for compilers, Web browsers, and TCP/IP stacks. It works for UNIX and X. It'll work for the Windows API, too.

SW: Openness has been a blessing and a curse for Unix. On the one hand, it allowed Linus Torvalds to write his own version and give it to the world, and it has become something of an underground standard. On the other, it has led to this vast proliferation of incompatible implemtations from Sun, HP, SGI, IBM, SCO, etc.

DM: I'm as critical of the proprietary practices of the Unix industry as you are. Linux was as much a collective reaction of Unix users against those practices as anything else.

But need I remind you that the Win95 and WinNT API's are sufficiently inconsistent that Microsoft had to back off from their requirement that both Win95 and WinNT versions must be available before MS would allow the use of the Windows-compatible logo?

SW: Still, it took a closed but truly standard operating system like Windows (or MacOS, had things worked out differently) to make computing accessible to the mass public.

DM: But the Web, which from TCP/IP through HTML and Java is *completely* based on Open Standards, was even more successful than Windows or MacOS. There is only one standard for the Web, and it's accessible from virtually *any* platform. Would the Web have grown faster or been more successful had Microsoft controlled the standard and restricted it to the Windows platform? I don't think so.

SW: Isn't there a danger with a truly open Windows that other operating system developers will be unable to resist the temptation to "improve" the APIs a little bit, as Microsoft has done with Java.

DM: The Web has shown that competition doesn't necessarily have to result in a Tower of Babel. Microsoft and Netscape both tried to improve HTML. And succeeded, as HTML and XML have evolved. The result has been a winning situation for everyone: Mac, Windows, *and* Unix users.

Contrary to what Bill Gates may claim, most people use Microsoft products because they want to be "compatible" with others, not because Microsoft products are necessarily "the best." A significant fraction of Windows users are sufficiently disenchanted with Microsoft that they would jump to another platform (as they might switch from, say, Internet Explorer to Netscape) if it would allow them to run all or most of their existing Windows software (much of it produced by third parties) on their existing computer.

The idea isn't so far-fetched. The stumbling block isn't the underlying operating system -- it's the Windows API. Others have attempted to implement the Windows API on faster, more reliable platforms (e.g., Sun's WABI or the Free Unix WINE project, both of which run on Intel PC's under Linux, among other platforms). While they've met with some success, they've been stymied by all the hidden, undocumented features in the Windows API that make it impossible for them to be 100% compatible or reliable. And so, Microsoft retains its monopoly.

Until Microsoft fully documents and opens up the Windows API (just as others have done with the computer languages, Internet protocols, and the like which Microsoft so freely uses in its products), it is difficult to see how there can be a level playing field and true competition in the computer industry. In the meantime, supporting the U.S. Department of Justice and the state Attorneys-General in their efforts to convince Microsoft to "play nicely or not at all" is just plain common sense.

SW: This debate has been going on for years and doubtless will continue for many more. I think the public is better served by standards that make the development of inexpensive shrink-wrapped software a reality.

DM: Absolutely. Open Standards are the key to making that happen.

SW: I'd be more enthusiastic about the open standards approach if I thought that would be the result. That said, however, I'm watching Netscape's mozilla.org effort, where they have told developers to go ahead an play with the source code for Communicator, with tremendous interest and I really hope they pull it off.

DM: Once again, let's not confuse Open Standards with Open Source. I'm a big fan of Open Source but am under no illusions that it's always practical. Open Standards are a different matter.

Return to main story