Contents

IBM System Object Model

This article needs additional citations for verification. Please help improve this articlebyadding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "IBM System Object Model" – news · newspapers · books · scholar · JSTOR (March 2013) (Learn how and when to remove this message)

IBM SOMobjects

Developer(s)	IBM
Stable release	3.0 / December 1996
Operating system	OS/2, Windows, AIX, Classic Mac OS, Copland, OS/390, NonStop OS, OS/400
Type	object-oriented shared library system

The System Object Model (SOM) is an object-oriented shared library technology developed by IBM that supports defining an interface to an object so that its interface is separate from its implementation.

DSOM, a distributed variant based on CORBA, allowed objects on different computers to communicate.

A SOM library can be updated without requiring client code to be rebuilt. If a library is changed to add new classes or methods, or to change the internal implementation of classes or methods, a consuming program can still use it without being rebuilt. In this way, SOM addresses the fragile binary interface problem that affects other library technology such as C++.

SOM allows classes to be defined in one programming language and used in another. A client can create and use objects from the exposed classes and derive subclasses from the exposed classes even if the client language does not support class typing.

SOM provides an application programming interface (API) that provides access to library metadata. Each object exposes methods that provide the class name and whether the object implements a particular method, for example.

SOM was intended to be used universally in IBM's mainframe and desktop (OS/2) computers, allowing programs designed for the desktop to use a mainframe for processing and data storage. IBM produced versions of SOM/DSOM for OS/2, Microsoft Windows and various Unix flavors (notably IBM's own AIX). 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.

Perhaps the most widespread uses of SOM within IBM were in later versions of OS/2, which used it for most code, including the Workplace Shell. Object REXX for OS/2 is able to deal with SOM classes and objects including WPS.^[1]

SOMobjects were not completely shut down by IBM. They were ported to OS/390, and are still available on this OS. One can read documentation on IBM website.^[2] In 1996 Tandem Computers Inc. obtained SOMobjects technology.^[3] Tandem was sold to Compaq, Compaq was sold to Hewlett-Packard. NonStop DOM and some other technologies eventually merged into NonStop CORBA, but current documentation of NonStop products does not contain signs of SOM technology still powering NonStop products.

This section possibly contains original research. Please improve itbyverifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (July 2013) (Learn how and when to remove this message)

With the "death" of OS/2 in the mid-1990s, the raison d'être for SOM/DSOM largely disappeared; if users would not be running OS/2 on the desktop, there would be no universal object library anyway. In 1997, when Steve Jobs returned to Apple and ended many development efforts including Copland and OpenDoc, SOM was replaced with Objective-C already being in use in OPENSTEP (to become Mac OS X later). SOM/DSOM development faded, and is no longer actively developed, although it continues to be included and used in OS/2-based systems such as ArcaOS.^[4]

Despite effective death of OS/2 and OpenDoc, SOM could have yet another niche: Windows and cross-platform development. SOM 3.0 for WinNT was generally available in December 1996. The reasons for not advancing in these directions go beyond market adoption problems. They involve opportunities missed by IBM,^[5] and destructive incompatible changes:

• The first version of VisualAge C++ for Windows was 3.5. It was the first and the last version to support SOM. It had SOM 2.1 bundled in and Direct-to-SOM support in the compiler. Versions 3.6.5 and later had no trace of SOM.
• SOMobjects largely relied on makefiles. VisualAge C++ 4.0 introduced .icc projects and removed icc.exe and ilink.exe command line compiler and linker from supply. It is impossible to build any SOM DTK sample out of box with VAC++ 4.0. VisualAge C++ comes with its own samples, but there are no .icc SOM samples even in VAC++ 4.0 for OS/2. vacbld.exe, the only command line compilation tool, doesn't support SOM.
• VisualAge C++ bundled-in Object Component Library (OCL) was not based on SOM. It was probably meant to be ported to SOM using C++ Direct-to-SOM mode, but in VAC v3.6.5 this mode was abandoned, and OCL has no SOM interface so far.
• Near the end of the 1990s, IBM shut down SOMobjects download sites and never put them back online. SOM 3.0 DTK for WinNT can't be found on IBM FTP, despite much other legacy stuff lying around freely. Despite general availability of SOM 3.0 for WinNT, it was nearly impossible to locate until the end of 2012.
• Finally, IBM never open-sourced SOM (as done to Object REXX), despite several articles^[6][7] and petitions.^[8]

Two projects of open-source SOM implementations exist. One is Netlabs Object Model (NOM), which is technically the same, but binary incompatible. Another is somFree, which is a clean room design of IBM SOM, and binary compatible. ^{[citation needed]}

SOM can be compared compiled libraries: ^[9]

• Smalltalk
• Common Lisp Object System (CLOS)
• generic C++
• SGI Delta/C++
• Sun Object Binary Interface
• Objective-C
• Java

As of 2015, most of the information in the linked table is applicable to modern versions, except Objective-C 2.0 getting so called non-fragile instance variables. Some solutions remained experimental: SGI Delta/C++ or Sun OBI. Most approaches based on one programming language were phased out or were never used actively in the same way. For instance, Netscape Plugin Application Programming Interface (NPAPI) browser plugins were written using Java API initially (LiveConnect), but Java Virtual Machine (JVM) was later excluded from the chain. It can be seen as Java replaced with Cross Platform Component Object Model (XPCOM). Common Lisp Object System (CLOS) and Smalltalk are not known as being chain links like Java in LiveConnect. Objective-C is also not known much in this role and not known to be marketed this way, but its runtime is one of the most friendly to similar use cases.

Generic C++ is still being used in Qt and the K Desktop Environment (KDE). Qt and KDE are notable for describing efforts it takes to maintain binary compatibility without special support in development tools.^[10]

GObject only aimed to avoid dependence on C++ compiler, but RRBC issues are the same as in generic C++.

Without special runtime many other programming languages will have the same issues, e.g., Delphi, Ada. It can be illustrated by so-called unprecedented approach it took to produce Delphi 2006 binary compatible Delphi 2007 release: How to add a "published" property without breaking DCU compatibility Archived 2015-12-08 at the Wayback Machine

Objective-C is the most promising competitor to SOM (although not being actively marketed as multi-language platform), and SOM should preferably be compared to Objective-C as opposed to COM as it happened historically. With non-fragile instance variables in Objective-C 2.0 it is the best alternative amongst actively supported.

COM, XPCOM are being used actively, but they only manage interfaces, not implementations, and thus are not on the same level as SOM, GObject and Objective-C. Windows Runtime under closer look behaves much like COM. Its metadata description is based on .NET, but since WinRT does not contain special runtime to resolve RRBC issues, like in Objective-C or SOM, several restrictions had to be applied that limit WinRT on procedural level:

Type System (C++/CX)

A ref class that has a public constructor must be declared as sealed, to prevent further derivation.

Windows Runtime Components - Windows Runtime Components in a .NET World

Another restriction is that no generic public classes or interfaces can be exposed. Polymorphism isn't available to WinRT types, and the closest you can come is implementing WinRT interfaces; you must declare as sealed any classes that are publicly exposed by your Windows Runtime Component.

SOM is often compared to component object model (COM). Both support a library format that can be used from more than one language.

Some consider SOM to be more robust since it only supports a language-neutral calling mechanism that is similar to COM late binding. COM also supports early binding, a.k.a. custom interface, that is less safe although more performant. It allows a client to access an object via a function table that is compatible with C and therefore compatible with the binary layout of the virtual table of C++ objects (at least in Microsoft's C++ compiler). With a compatible C++ compiler, a custom interface can be defined as a pure virtual C++ class. The interface can be called by any language that can call C functions via a pointer.

A risk of a custom interface is that an incompatibility can result in undefined behavior. In particular, if a version of the object is published with a modified custom interface, a client may crash. This is an example of the fragile base class problem. To prevent the problem, a rule for COM development is that once published, a custom interface cannot be changed. To add or change the exposed features of an object, it can implement additional custom interfaces.

SOM avoid this issue by providing only late binding – allowing 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.

SOM is more robust in terms of supporting object-oriented (OO) features. Whereas COM essentially defines a cut-down version of C++ to program to, SOM supports almost all common features. It also supports some less common features such as multiple inheritance, metaclasses and dynamic dispatching, which had led most SOM/COM-like systems to be simpler at the cost of supporting fewer languages. Multi-language support was important to IBM as they wanted to support both Smalltalk (single inheritance and dynamic dispatch) with C++ (multiple inheritance and fixed dispatch).

A notable difference is support for inheritance. COM does not. Although may think it odd that Microsoft produced an object library technology that could not support such a fundamental concept of OO programming; the main reason is that it is difficult to know where a base class exists in memory where libraries are loaded in a order unknown at design time. 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 an algorithm, looking for potential base classes by following the inheritance tree and stopping at the first one that matches. This is the 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 a problem can become difficult to resolve if it exists in someone else's code. In SOM, the only solution is testing of new versions of libraries.

While SOM and COM were contrapositioned by IBM, they were not mutually exclusive. In 1995 Novell contributed ComponentGlue^[11] technology to OpenDoc for Windows. This technology provided different means to integrate between COM and SOM components. In particular, SOM objects can be made available to OLE2 applications by either late binding bridge (based on IDispatch) or COM interfaces having higher performance. In essence, SOM classes are implementing COM interfaces this way.

Similar technologies, such as Distributed Objects Everywhere, also support full inheritance. Portable Distributed Objects avoided these issues via a strong versioning system, allowing library authors to ship new versions along with the old, thereby guaranteeing backward compatibility at the cost of disk space.