Imagine you are going to a new car showroom. Would you take along a suitcase filled with money, walk into the showroom, plop the suitcase down on the table, point to a car and say "I will take that one"? Probably not. You would ask the salesperson what type of fuel costs you could expect, what the average payload the car could carry, how many people could it hold comfortably, and a whole series of other questions. The salesperson would probably think you were a little strange if you did not ask any questions. They realize that although cars are generally "the same", there are many areas where they are different, with each manufacturer trying to innovate and improve over their competition.

On the other hand, you now walk into a supermarket, and you see a stock clerk putting cans of corn on the shelf. Then you walk up to the clerk and ask them questions like these:

• "How many people does that can of corn feed"?
• "Is that brand of corn much different from that other brand of corn?"
• "Can I put two different cans of corn in the same pot for cooking, or do I have to separate them?"
• "Can I have my corn in a purple color?"

By the time you had the second question out of your mouth, the clerk would probably be looking for the store bouncer, since they would think you "a little strange". And while certainly the methods of manufacturing cans of corn have changed over the years, the basic "can of corn" remains the same from the consumer’s standpoint.

This is because the canned corn is a "commodity", while the car is more of a "standard". With fewer areas to innovate, the number of questions to ask drops dramatically. Basically a can of corn is a can of corn.

How would you feel if you went out to buy a new car, and found out that there was only one manufacturer of car that you could buy? Even if the manufacturer of that car had a small, compact model that only stalled two or three times a day, but also offered you a larger utilitarian model that would be ready to carry your entire family "any day now"? You probably would be upset. You might even write your congressman, talking about lack of "freedom of choice", and monopolies in the automobile marketplace.

Of course the automobile marketplace would never get to that. There are many manufacturers of cars, which produce cars to our every need. But what would happen if one car manufacturer became very, very popular? You might find that it became harder and harder to find spare parts for *your* favorite manufacturer. And when you did find the spare parts, they were very expensive, or not stocked "in-house" because there was less of a demand for them. These parts did not fit on the "standard" car made by this very, very large car manufacturer. After a while, you might even decide that it was not worth the fight, and by changing your lifestyle slightly, you might be able to live with one or the other of the "standard" cars produced by that one manufacturer. Perhaps you only had to get rid of the family pet, or perhaps you made two trips to the lake, or (since your spouse can drive) you take two cars to carry the same payload that the one car used to carry. After a few years you noticed that the one large automobile manufacturer only changed the body style once in a while to stimulate sales, but the engine, the drive train and the brakes never improved. Even then the models came out slowly….the ’95 model, the ’98 model……

In the automobile industry there are a certain number of "standards" which allow the average person to own and operate a car, yet have areas of innovation for the car manufacturers. Tire sizes, placement of pedals, steering wheels, turn indicators, bolt sizes, etc. are all covered by standards, both formal and informal. They allow the car to be driven by people of all sizes and shapes, and serviced by a wide variety of independent mechanics.

Of course we are talking about computers in this paper, not automobiles. But a lot of the same ideas apply.

Standards in the computer industry have allowed the computer industry to cut costs. Standard programming languages such as COBOL, Fortran, "C", and others have allowed people to write programs independent of the hardware architecture of the CPU. Standard protocols such as TCP/IP, standard file formats such as MPEG, and standard hardware standards such as RS232 have allowed computers to communicate and share data for a long time.

One of the last hold-outs for standards was the operating system itself. While languages had been standardized, the interfaces to the operating system for doing things like starting a new process, or allocating memory were different from machine to machine. This caused a programmer to make massive changes to their programs when they wanted to reach a new customer that had chosen a different manufacturer’s computer system. This was the age of the "proprietary operating system", so called because it was proprietary to one manufacturer, and only ran on their equipment.

Along came the concept of "Open Systems". Open Systems had the unique (for its day) feature of having the same operating system interfaces on a lot of different hardware manufacturer’s systems. At about the same time, the IEEE started to create a standard for operating systems, called "POSIX". This standard, loosely based on Unix-like systems, was to define all of the programmer and user interfaces of importance. Once these interfaces were defined, the manufacturers of operating systems would be able to implement the interfaces the best way they could. This allowed innovation in the implementation, while making sure the interfaces were available and standard for the programmers to use. This could be compared to every driver knowing that a car will have a steering wheel, brake, turn signal, and driver’s seat, but allow the manufacturer to innovate in materials used, manufacturing process and colors.

POSIX had a couple of issues, however. Not all of the interfaces needed for software development were immediately defined by the IEEE. Some vendors considered POSIX "too little, too late", and went off to develop other interfaces, normally implementing POSIX where they could, but adding other interfaces when needed. This caused the divergence of Unix systems common during the 1980s and early 1990s. Finally another major standard evolved into existence. The brand "Unix", formulated and maintained by X/Open, utilized the formal standards of POSIX, added other formal standards, added informal standards where appropriate, and created a called the "Single Unix Specification". It is this specification for which most Unix vendors strive, and some succeed in meeting. It is this specification (as well as POSIX) that, year by year, is improved and expanded to include more and new interfaces.

In the same timeframe, Microsoft was developing a "standard" of its own. DOS, and later Windows was becoming a "defacto" standard, due to the volume of customers using it. Eventually as Microsoft realized that Windows had a restriction on the size of systems that it could handle, Microsoft started designing Windows NT (WNT) and used its marketing might to stage it as the next "standard". Indeed, Microsoft’s marketing power was so great that some analysts were declaring that WNT was "the future standard" before the first copy of WNT had even shipped.

The difference, however, between the Microsoft standards and the Unix Standards were several.

In the Unix space, the standards were proposed, voted on, and tended to be implemented by several different groups at the same time. Often there were "sample implementations", either done by a University, by a neutral vendor group such as "The Open Group", or by a neutral consortium such as the X Consortium. While the interfaces were fixed, and might change slowly over time, the implementations were free to show innovation. The vendors were free to purchase a "sample implementation" from someone else, then innovate on top of that, or to implement the standard from the specification, often saving royalty charges in favor of increased initial investment. Sometimes vendors shared implementation charges by working together. Changes to the standard were announced well ahead of time, voted on by committees made up of vendors, ISVs, and end-users alike, and made available to everyone. Standards testing was encouraged by branding and by participation in testing sessions attended by many vendors.

In the Microsoft situation, Microsoft implements the code, which becomes the new "standard". Microsoft may or may not tell ISVs and customers about changes to the "standard" as the new version of the operating system comes out, but there is only one implementation of that standard, and that is the Microsoft implementation. To be fair, this allows ISVs to create one distribution of their application, written to one specific set of APIs, for one specific hardware architecture, and sell it to millions of people. This is the main reason why Microsoft products are dominant in the industry today, as each can of corn is exactly the same.

Microsoft has put forth an appearance of following POSIX standards on WNT. Microsoft has implemented a set of the POSIX interfaces, but which are only usable in "the POSIX environment". Therefore ISVs can not mix POSIX library and system calls with those of the rest of the Win-32 environment, which typically means that POSIX programs running on Windows systems have a different "look and feel" than the native Windows counterparts. Likewise when Microsoft announced support for DCE, it was not for the entire standard (which most Unix vendors were striving), but for the part of the standard that was "interesting". Even in the case of JAVA, Microsoft has stated their intention to create a JAVA environment that could limit applications developed on their products to only run on their systems. To paraphrase George Orwell’s book "Animal Farm", Microsoft seems to think that while all standards are equal, some standards are more equal than others.

Several years ago the United States Government made a policy of only buying operating systems that supported the POSIX interface. This was a good policy, for it forced manufacturers (including Microsoft) to put POSIX interfaces into their products. Unfortunately the policy did not go far enough, for it allowed ISVs to ignore the standard interfaces, and write their code to non-standard interfaces, locking them in to a single vendor. As the Microsoft marketplace grew, this choice of vendor tended to be Microsoft. The Government agencies (wishing to utilize those applications) got exceptions from the policy on a wider and wider scale.

The policy on POSIX should have been made more rigorous. It should have also included the extension of only buying layered software products and (to a certain extent) hardware products that are certified to use standard interfaces. The POSIX policy should also force vendors to publish specifications as standards on data file interchange, to allow other vendors to read, process and produce files produced by a specific application. This would force manufacturers and ISVs who wish to do business with the Federal Government, Federal Government contractors (and to a large extent state and local governments and state and local government contractors) to write programs and hardware drivers that would have a great deal of portability to other vendors’ platforms and programs.

It would be particularly effective if non-governmental customers took the same attitude, and drove the same policies.

Recently, Uniforum moved from an organization best remembered for a large trade show in San Francisco, to an association of "People Advocating Open Computing". People joining Uniforum today are people who believe that the innovation of developing a specific implementation of code as a "product" is best done to a published standard, not that the implementation simply becomes the standard. They know that "cheapest" is not always the "least expensive", and that they would rather have purchased products meet their needs of business, rather than change their business to meet the capabilities of a single vendor’s products.

From what I can see, the Uniforum member would want that element of choice, whether it be buying a new car, or even just shopping for a can of corn. This is standards-based computing. This is the way.