IBM System Object Model
From Wikipedia, the free encyclopedia
The System Object Model is an object-oriented shared library system developed by IBM. A distributed version based on CORBA, DSOM allowed objects on different computers to communicate.
SOM was intended to be used universally from IBM's mainframe computers right down to the desktop in OS/2, allowing programs to be written that would run on the desktop but use mainframes for processing and data storage. IBM produced versions of SOM/DSOM for OS/2, Microsoft Windows and various Unix-flavours (notably IBM's own AIX). SOM/DSOM was also an important part of the later versions of the VisualAge development platform, allowing different languages to call code in a standardized format.
Perhaps the most widespread uses of SOM within IBM was in later versions of OS/2, which used it for most code, including the Workplace Shell. With the "death" of OS/2 in the mid-1990s, the raison d'etre for SOM/DSOM largely disappeared; if users wouldn't be running OS/2 on the desktop, there would be no universal object library anyway. SOM/DSOM development faded, and is no longer actively developed.
For some time after the formation of the AIM alliance, SOM/DSOM was also used by Apple Computer for similar purposes. It was most widely used in their OpenDoc framework, but saw limited use in other roles as well. Most of these technologies were dropped in 1997 when Steve Jobs returned to Apple and ended many development efforts.
SOM is similar in concept to Microsoft's Component Object Model. Both systems address the problem of producing a standard library format that can be called from more than one language. Many disparage this concept because the vast majority of programs are written in a single language, and the language neutrality always adds overhead - sometimes considerable. Yet it is important to note that even a single language from different vendors, or even different versions of the same compiler, may use incompatible formats.
SOM can be considered more robust than COM. COM offers two methods of accessing methods onto an object, and an object can implement either one of them or both. The first one is dynamic and late binding (IDispatch), and language-neutral similar to what is offered by SOM. The second one, called a Custom Interface, is using a function table which can be built in C but is also directly compatible with the binary layout of the virtual table of C++ objects in Microsoft's C++ compiler. With compatible C++ compilers, Custom interfaces can therefore be defined directly as pure virtual C++ classes. The resulting interface can then be called by languages that can call C functions through pointers. Custom Interfaces trade robustness for performance. Once an interface is published in a released product, it can not be changed, because client applications of this interface were compiled against a specific binary layout of this interface. This is an example of the fragile base class problem, which can lead to DLL hell, as a new version of a shared library is installed and all programs based on the older version can stop functioning properly. To prevent this problem, COM developers must remember to never change an interface once it is published, and new interfaces need to be defined if new methods or other changes are required.
SOM prevents these issues by providing only late binding, to allow the run-time linker to re-build the table on the fly. This way changes to the underlying libraries are resolved when they are loaded into programs, although there is a performance cost.
SOM is also much more robust in terms of fully supporting a wide variety of OO languages. Whereas basic COM essentially defines a cut-down version of C++ to program to, SOM supports almost all common features and even some more esoteric ones. For instance SOM supports multiple inheritance, metaclasses and dynamic dispatching. Some of these features are not found in most languages, which had led most SOM/COM-like systems to be simpler at the cost of supporting fewer languages. The full flexibility of multi-language support was important to IBM, however, as they had a major effort underway to support both Smalltalk (single inheritance, dynamic dispatch) with C++ (multiple inheritance, fixed dispatch).
The most notable difference between SOM and COM is support for inheritance -- COM doesn't have any. It might seem odd that Microsoft produced an object library system that could not support one of the most fundamental concepts of OO programming, but they did have their reasons. The main issue is that it is difficult to know where a base class exists in a system where libraries are loaded in potentially random order. COM demands that the programmer specify the exact base class at compile time, making it impossible to insert other derived classes in the middle (at least in other COM libraries).
SOM instead uses a simple algorithm, looking for potential base classes by following the inheritance tree and stopping at the first one that matches; this is the basic idea behind inheritance in most cases. The downside to this approach is that it is possible that new versions of this base class may no longer work even if the API remains the same. This possibility exists in any program, not only those using a shared library, but problem can become very difficult to track down if it exists in someone else's code. In SOM only solution is extensive testing of new versions of libraries, which is not always easy.
The flexibility offered by SOM was considered worth the trouble by almost all, and it is worth noting that similar systems, such as Sun Microsystems' Distributed Objects Everywhere also supported full inheritance. NeXT's Portable Distributed Objects avoided these issues via a strong versioning system, allowing library authors to ship new versions along with the old, thereby guarenteeing backward compatibility for the small cost of disk space.
[edit] External links
- - compares MS's and IBM's approaches to the object library system in terms of inheritance
