There are two important aspects to open systems: interoperability and portability [Fis93]. Interoperability refers to the capability for applications running on different computers to exchange information and operate cooperatively using this information. Portability refers to the capability for software to run on different types of hardware. Portability can further be broken down into binary portability and source code portability. Binary portability makes it possible to move an executable copy of a program from one machine to another. Source code portability requires a program to be recompiled when moving from one machine to another. The development of portable application software components depends on portability standards. Interoperability standards are necessary but not sufficient for a complete open systems environment. Software systems that are built on standards for portability and interoperability are called open systems.
A good example of interoperability is provided by the X Window System [RS89] protocol, which specifies how graphics primitives can be communicated between an application program and graphics software running on a workstation. An X Window application running on an IBM workstation can interact, for instance, with a user sitting at a Sun workstation. The ISO Open Systems Interconnection (OSI) standards [iee86] [Ros90] also promote interoperability. The OSI reference model defines a structure, or reference model for data communication standards. The reference model defines seven layers of communications system components, from the physical layer at the bottom to the application layer at the top. The model describes how components communicate with each other; i.e., it is a model for interoperability. Open system standards for application portability do not ``fit in'' to the OSI reference model; they are, however, complementary to data communication standards. Communication standards define communication services, but open system applications require a standard way to use those services.
Binary portability specifications are designed to provide software portability at the object code level. For example, the IBM PC hardware interface can be regarded as a de facto standard for binary portability. Executable copies of software can run on PC clones from many different manufacturers. Another example is the Application Binary Interface for systems based on the Sun SPARC processor. This specification for workstations makes it possible to move executable programs between different makes of workstation as easily as programs can be moved between different IBM PC clones. Binary portability is more difficult to achieve than source code portability, because it places constraints on hardware. Standards efforts have concentrated on developing interfaces for source code.
Open system standards for source code portability define interfaces available to application programs for services such as timing functions, security features, database access and many other essential functions. Standards could be defined by cooperatively developed source code, but within IEEE and other organizations the preferred approach has been to specify interfaces and let vendors develop competing implementations. Thus, two different operating systems may provide the same services, but one may have better performance or fault tolerance characteristics than the other. The application program interface may be specified in terms of a set of procedure calls for a particular programming language, or a language-independent specification may be accompanied by procedure calls for one or more programming languages.
The best-known standards for operating system services are the POSIX standards being defined by the IEEE Technical Committee on Operating Systems (TCOS). (The acronym POSIX is derived from Portable Operating System Interface, with an ``X'' to denote its UNIX origin.) Beginning with the POSIX System Application Program Interface (or kernel) standard (IEEE 1003.1-1988), IEEE has been developing a comprehensive set of standards for application portability. In May 1992, the POSIX effort comprised 20 working groups developing 34 projects.
The POSIX efforts (1003.x) have been supplemented with projects to develop standards for application interfaces to services such as windows (1201.1) and X.400 message handling (1224), that are useful on non-POSIX systems. Other open system standards have been developed through the American National Standards Institute (ANSI), the International Organization for Standardization (ISO), and other organizations. Many of these other specifications have been combined with the developing IEEE standards to define an open systems environment using the POSIX interface standards as the basis.