OS/2 Warp Monthly Newsletter. Volume 6 - November 1995

From OS2World.Com Wiki
Jump to navigation Jump to search

THE OS/2 WARP MONTHLY NEWSLETTER

Volume 6: November, 1995

Welcome to the OS/2 Warp Monthly Newsletter

Welcome to our November issue. It's our sixth one, making us .5 years old. (One of the many benefits of writing for an audience interested in software is that you can mark these fractional year milestones - in decimal format. I sort of regret not making a big deal out of our .33333... anniversary in the September issue.)

Anyway, the focus of this month's newsletter is objects and object technology. The respondents to our survey tell us that they want to see more about future plans for OS/2 and more product descriptions. This issue should satisfy both those requests by providing a fairly detailed look at some of the products shaping the future of systems.

We've included three articles on OpenDoc. Maxine Senn-Yuen wrote two, one of which covers what some of the Independent Software Vendors (ISVs) are doing with it. Emily Vander Veer took a more philosophical approach in her OpenDoc article. We looked at other products too. Jose De Jesus wrote about VisualAge C++ and reviewed the SOM Developer's Toolkit. Maxine complemented Jose's review with a general overview of SOM (System Object Model). I wrote an article explaining Taligent's CommonPoint Application System. This article also lets you know about IBM's plans for products that incorporate this technology. And last but not least, Collin Summers wrote an excellent review of Stardock Systems' Object Desktop.

That's not all, either. Instead of our typical Electronic 'Scapes article that directs you to a number of fun, interesting and sometimes even useful web sites, Maxine looks at the Future of the Internet in an Object World. Steve McNally introduces us to an entrepreneur who is exploiting the power of objects.

When people think about objects, if they think about them at all, they often see them only as developer's tools and somewhat futuristic, esoteric tools at that. The non-developer's interest in objects may be comparable to the interest that automobile owners had in assembly line technology when Henry Ford started selling Model Ts. However, Jerome Yuzyk wrote a wonderful Product Tips article that really clarifies how objects allow OS/2 Warp to interface with the user the way that it does. The special benefit from this article is that once you understand how objects work within OS/2 Warp, you gain not only a greater appreciation but also a firmer grasp of the overall structure of OS/2 Warp.

If I had to choose one, and only one, compelling reason to use and to develop for OS/2 Warp it is the current implementation of and future plans for object technology in the OS/2 Warp family of products. This issue of the newsletter is an important one. I hope you enjoy it.

Jeri Dube

Shareware and Commercial Software

Object Desktop by Stardock Systems

by Collin Summers

If you're looking for software that really takes advantage of OS/2 Warp's object technology in visual and exciting ways, look no further than Object Desktop (OD), a new desktop enhancer from Stardock Systems. In my experience, Object Desktop is much more powerful than any other application of its kind. Based on using the Early Experience version of OD for three months and now the shipping code, I am VERY impressed with this product, to say the least.

Object Desktop enhances and adds usability features to OS/2 Warp's powerful WorkPlace Shell (WPS) interface. Object Desktop lets you work in the same familiar way you're used to - click the right mouse button to bring up pop-up menus, drag and drop fonts and color schemes, etc. - so you won't have to learn a new set of skills to use this software.

When you open the OD package, you will find two disks. The first has the Object Desktop program on it. The second contains icons, bitmaps and archivers. The second disk helps to enhance the look of your desktop as well as provides the archivers needed to work with some of OD's features.

OD actually adds new object classes to OS/2 Warp. One of the most useful of these new classes is the archive. This feature allows you to very easily archive and unarchive files. You no longer need to use command line commands to archive files because OD adds archive templates. To archive files, drag one template onto your desktop, change the object name (with an ALT+click), then drag-and-drop whatever files you want archived onto the archive object. To examine a ZIP file, for example, just double-click and the file opens like a folder. You can examine its contents with either an icon or a detail view. If the archive contains directories, they too show up as folders inside the archive. To save space on your hard drive, you can use this feature to keep all the background bitmaps that you're not using zipped. You can then view the zipped bitmap files whenever you like, without unzipping them. This feature also supports ZOO, ARC and LZH files.

Furthermore, OD lets you treat archived files just like objects. When you double-click on an archived file, you can view text files or even start executables. You can also drag-and-drop files out of the archive to the destination of your choice, just as you would any other object in OS/2 Warp.

Speaking of objects, OD adds two new tabs labeled Options and Performance to the Settings Notebook for folder objects. The Options page allows you to add some visual enhancements to the WPS. You can now enhance icons and titles with raised or sunken 3-D effects. You can use these in any combination you like to really jazz up folder icons.

The options page also has a check box for Display status bar. This status bar adds a section to the bottom of folder objects where you can see things like:

  • How many objects are in the folder
  • How much space the objects use
  • How many objects are currently selected
  • How much space the selected objects use.

Of course there are other check-boxes to enable or disable any enhancement for specific folders. You can use these options, like most in OD, in any combination and change them as you wish. You can create a system of folders all laid out differently to suit your taste. These options not only provide some visual enhancements but they also definitely help usability.

The Performance options can help to speed up the folder objects by limiting or enhancing how WPS objects usually work. The browse option is one of my favorites. If the browse option is enabled when I open my OS/2 System folder and I click on my System Setup folder, then essentially the System Setup folder replaces the OS/2 System folder. The System Setup icons look the same way that the OS/2 System icons looked because the browse option maintains the same settings rather than recalculating any specific settings for the System Setup folder. This makes folders come up faster and it is especially efficient when working with a series of nested folders. Whenever you open a new folder, it adds a little back arrow in the top right hand side that allows you to go back to the previous folder contents (sort of like the back arrow in the Web Explorer). This option is also really helpful on my laptop where screen real-estate is constrained. Another performance option, HyperCache, enables the WPS folders to open faster. This option works by caching the folder objects into memory so when you open that folder, the objects immediately appear. You don't want to do this to every folder because your swap file would become too large. But for example, I use this on the two folders I access most, both of which have lots of icons. With HyperCache, I never have to wait for the system to initialize the objects in these folders.

The last performance option, HyperDrive, again speeds up the opening of folders. This time the performance is gained because the system guesses which icons are contained in the folder instead of reading them. To ensure the system gets it right eventually, you can enable the icon read-behind feature. Once the system opens the folder and displays the guessed objects, it can go back and correct any wrong guesses. You can set this last option as a system default to improve WPS response time when reading folder objects.

Another new feature of OD is the enhanced data file. This provides a new data editor for your convenience. If you double-click on any data file, your system automatically launches OD's editor. You can also launch this editor from objects associated with some other programs by clicking the right mouse button, then pressing open and selecting TEXT VIEW. With this editor, you can save and edit data files in the easiest way possible. In most cases it is faster than the E editor included in OS/2 Warp and it also includes a print function.

OD includes quite a few different and sometimes handy features. You can add a Close button (a little X) to the upper, right hand corner of your windows for one-click closing of objects or programs. You can turn this feature on and off in the Object Desktop Master Setup. OD also replaces the minimize and maximize buttons with more aesthetically pleasing ones (in my opinion). Object Desktop enhances the scrollbar buttons. You can enable a window drag mode as well. When I moved folders and programs around on my desktop, I found this feature slowed down my system too much for my liking. But it did look neat. You can select all or some of these features to make your system just the way you want it.

OD enhanced the Window List and Task Manager as well. It makes the Window List more graphical and included buttons on the bottom for close, hide, show, tile, cascade, and help. You can also click on a filter button to control what appears in the window list. OD made the Task Manager function a little slicker too. When you hit the ALT-ESC keys, a little box appears in the middle of the screen. You can change the tasks that appear in the box, by releasing and then pressing the ESC key. You choose the task you want when it appears in the box by releasing both keys.

If you like the idea of launching applications with the keyboard rather than using the mouse on the toolbar, OD adds a Keyboard Launchpad. You set custom key combinations to launch your favorite apps. For example, you can launch your word processor with the CTRL-ALT-W keys. If you liked the WPS's taskbar, then you'll love OD's Tab Launchpad. It is a launch pad with tabs for organizing your icons. You can name the tabs whatever you want. You can also arrange it in as many ways as you can imagine. You can even create a TASK tab to monitor running tasks. You can also make multiple Pads and scatter them about your desktop. With its many options, this feature is just plain neat but you'll need to play around with it to find what works for you.

To monitor the essential elements of your system such as free space on your drives, swap file size and memory use, OD added the Control Center. The Control Center has a System Monitor to indicate CPU usage. And of course there's a clock that can be displayed in digital or analog formats. With the Control Center, you have the ability to create Virtual Desktops. You can open up and maximize an application and then switch to a different virtual desktop to give yourself a clean, empty desktop where you can start running other applications or doing other work. The Control Center is very configurable and you can create multiple ones all monitoring different system elements and doing other things.

One last major feature of OD is the Object Navigator. This is essentially a way to navigate around your hard drives. It works a little faster than the WPS's drive objects because the view does not include some of the information that the WPS view normally includes. It also uses some of the Hyper functions described earlier to speed up the displaying of objects. You can launch the Object Navigator from its icon or from the Control Center. Object Navigator also lets you place the directories and drives you use most in a handy pull down window.

Object Desktop has so many features that it's hard to cover them all. However they are all very configurable and all compatible with the WorkPlace Shell. If you ever wanted to enhance your desktop this is a GREAT tool to help you do it. To see examples of how people have used OD to lay out their desktops, check out the Stardock Systems Home Page at http://oeonline.com/~stardock/. You can either enter your desktop ideas in their Object Desktop contest or just get some ideas for your desktop from the great examples of desktops they have on display.

  • This article is based on the author's personal review of the product and should not be viewed as an IBM endorsement of such product.

SOMobjects Developer Toolkit: Version 2.1

by Jose De Jesus

If you're involved in Object Oriented Programming, IBM's SOMobjects Developer Toolkit was designed for you. SOM or System Object Model is a language-independent technology for building, packaging, and manipulating binary class libraries. With SOM, a class consumer (user) can use a language different than that used by a class implementor (developer), as long as both languages support SOM bindings.

SOM is one of the most interesting object-oriented technologies in the market today, encouraging the creation of truly "reusable" software components. SOM overcomes the difficulties inherent in static binding languages like C++, and Object Pascal. These languages tightly couple objects with their clients, limiting the distribution and reusability of class libraries. For example, a C++ program that binds to a Dynamic Link Library will have to be recompiled if a new release of the DLL comes out. Furthermore, the binaries produced by one compiler are not compatible with other compilers. SOM solves these problems by providing an effective mechanism for sharing class libraries among different languages. Objects and their clients are no longer bound to each other, but to the SOM interface. Essentially, SOM "decouples" a class's implementation from the programs that use it.

SOM is not only language independent, but also platform independent. It complies with the Common Object Request Broker Architecture (CORBA) specifications. CORBA, developed by a consortium of more than 300 corporate and associate members known as the Object Management Group (OMG), defines how applications and objects should work in a heterogeneous network. CILabs' OpenDoc technology, for example, is based on SOM. And OS/2's Workplace Shell is the first commercial implementation of SOM. The SOMobjects Developer Toolkit 2.1 supports the AIX, OS/2, and Windows platforms.

The SOMobjects Developer Toolkit Version 2.1 makes it possible for programmers to use SOM technology to create class libraries which can be shared by programmers using different programming languages. The toolkit, available on CD-ROM and other media, comes with these components:

SOM Compiler
The SOM Compiler creates C and C++ usage and implementation bindings from IDL code. IDL or Interface Definition Language is what SOM programmers use to define classes in a language-neutral manner. The SOM Compiler takes your IDL code and converts it into a set of skeleton functions and header files that you can use with IBM VisualAge C++, IBM CSet++, Borland C++, MetaWare High C++, and other compatible OS/2 C++ compilers.
While not a full-blown object-oriented language, IDL supports encapsulation, inheritance, and polymorphism.
Emitter Framework
The Emitter Framework generates backend programs for customized processing of IDL. This framework allows you to write your own bindings for classes in other languages.
SOM Kernel
The SOM Kernel implements the SOM Application Programming Interface, the runtime environment on which your SOM applications run.
Interface Repository Framework
From your IDL code, the SOM compiler generates an Interface Repository, which is simply a database containing information about your class interface specifications. With the Interface Repository Framework, you can acquire information about an object's interface dynamically.
Utility Classes
Utility Classes consist of metaclasses and classes for event management (the Event Management Framework) and communications. Among other things, these classes support the TCP/IP sockets interface provided by TCP/IP for OS/2 (TCP/IP is sold separately).
Distributed SOM (DSOM)
DSOM allows your applications to access objects across address spaces. DSOM programs can access objects in other processes, even on different machines. DSOM technology is one of IBM's solutions for an industrywide trend toward distributed or cooperative computing.
Persistence Framework
The Persistence Framework supports the creation of classes whose instances are persistent. This means that you can extend an object's lifespan so that it can outlive the process that created it.
Replication Framework
The Replication Framework supports the creation of classes whose instances can be replicated about a network.
Collection Classes
The Collection Classes include classes for polymorphic containers such as dictionary, stacks, set, list, and so on.

The toolkit also comes with sample C and C++ code, and online publications that you can view using FrameViewer, a hyperlink program that lets you jump directly to any part of your online documentation.

Overall, version 2.1 of the SOMobjects Developer Toolkit provides many enhancements and better performance for both SOM and DSOM. These technologies promise new and exciting opportunities for developers, and a whole new class of powerful software for users. With the SOMObjects Developer Toolkit, IBM is offering an easy way for programmers to implement SOM - sweat free|

Review: UniMaint

by Maxine Senn-Yuen

UniMaint version 4.0 is a complete system maintenance and uninstaller package for OS/2 Warp. Available from SofTouch Systems (405-947-8085), this package combines all the functionality of the popular shareware utilities MultiMaint, IniMaint, and SysMaint along with new tools not included in those utilities. While new OS/2 Warp users will probably find UniMaint useful, this product is best suited for experienced power users.

Before using UniMaint, you should observe this precaution: never alter your INI files or desktop without a proper backup. UniMaint provides a facility to perform a compete backup of important system configuration files, which is a good idea even if you don't plan to change those files. Unless you're confident in what you're doing, you probably shouldn't use UniMaint right off the bat either. Instead, use the UniSafe tool that comes with UniMaint. UniSafe looks identical to UniMaint, except all functions which alter the INI files, Extended Attributes or desktop have been disabled. UniSafe allows you to explore your system without causing any harm. If you're a new OS/2 user, you should also read the very well-written background information on INI files, Extended Attributes and the WorkPlace Shell (WPS) included in the manual.

So what can UniMaint do? You can examine of any object on your OS/2 Warp desktop by right-clicking on the object and opening its Settings Notebook. If you want to examine the settings for only one object, it's easier to use this right-click technique. But if you want to display or modify the WPS settings for several objects, UniMaint makes it easy to do so. There are other utilities available that allow you to modify your WPS settings, but few will modify all of them at once. With UniMaint, you can even choose to exclude or include selected WPS classes in your operation.

UniMaint includes tools to view, edit and maintain your INI files. Unlike other operating systems, OS/2 initialization files are stored in binary, not text, format. Binary format allows the data in OS/2 INI files to be stored more efficiently, used more quickly, and maintained with greater accuracy by the system. However, this format also prevents users from examining and modifying the contents of those files. UniMaint allows you to delete obsolete references, as well as copy or move parts of your INI files.

In addition, UniMaint provides a utility that can take a "snapshot" of your desktop, and restore that desktop configuration with one command. You can selectively restore your desktop object by object or you can backup your desktop configuration so that it is portable to other computers. So, if you have your desktop at the office set up with the perfect layout and color scheme, you can easily transfer that configuration to your PC at home.

UniMaint also includes an application Uninstaller to remove unwanted programs and all their associated CONFIG.SYS and OS2.INI entries. The Uninstall feature works very well on WIN-OS2 apps, which is handy if you're upgrading from Windows to native OS/2 applications. Like all the tools in this package, the Uninstaller can be accessed either from a menu in the UniMaint main screen, or by using the appropriate icons in the Tools folder the program installed on your desktop. So uninstalling an obsolete application is as easy as dragging the program object to the Uninstall window.

One final feature I liked about this package was the comprehensive on-line help. Almost every dialog box has a help button to assist you with the specific task you're trying to do.

Altogether, UniMaint is a very useful and powerful collection of utilities.

  • This article is based on the author's

personal review of the product and should not be viewed as an IBM endorsement of such product.

Mr. File/PM

by Maxine Senn-Yuen

Mr. File/PM is an easy-to-use file manager for OS/2 versions 2.0 and higher. This IBM employee-written software was created by Mark Kaczmarski and is widely available as shareware.

Despite the goofy-sounding name, Mr. File/PM is a solid, full-featured application for managing your files. It fully supports OS/2's drag-and-drop capabilities, so it's very easy to copy, delete and move files using this program. You can even copy selected files or directories to the PM clipboard. Mr. File/PM allows you to display and sort files by:

  • extension
  • filename
  • date
  • size.

You can display the complete directory tree for the current drive, or just certain files within a subdirectory. The size of your drive, directory or selected files can be shown dynamically as you navigate between directories and drives. This file manager even allows you to modify file and directory attributes.

Mr. File/PM's performance is also quite impressive. The program is fast and well threaded, with several shortcut techniques to speed up tasks even more. For example, the program allows you to create a directory ring which enables you to move quickly between the directories you use most often. You can then locate files within a directory very quickly. In addition, Mr. File/PM has a toolbar which greatly simplifies common functions once you become familiar with the icons (hint: the truck icon means move).

Its most powerful feature is its ability to execute commands using files from the file display. You can customize Mr. File/PM to define commands that automatically get executed against certain files whenever they are opened. For example, you could launch a spellchecker or special drawing tools whenever you open a business presentation. You can also set commands that get executed against files when they are dragged and dropped over certain windows.

The latest version of Mr. File/PM can be found at ftp://hobbes.nmsu.edu/os2/diskutil/mrfilepm.zip. The program takes up approximately 250KB of hard disk space.

  • This article is based on the author's personal review of the product and should not

be viewed as an IBM endorsement of such product.

Product Tips

Who Could Object? Understanding OS/2 Warp's Object Technology

by Jerome Yuzyk jerome@supernet.ab.ca

If you haven't already, you're going to be hearing the word "object-oriented" (O-O or OO-) a lot in the next few years. It will change your life just like the pervasiveness of computers changed your life.

OS/2 has had its own O-O interface since version 2.0 introduced the WorkPlace Shell (WPS) on your desktop. WPS introduced us to a monosyllabic acronym called SOM: System Object Model. SOM provides all the programming "nuts and bolts" required to create O-O software like the WPS and some of the tools you get in the BonusPak for OS/2 Warp. More than just a library of screen widgets, SOM defines a fundamental method for the way you (as user or programmer) can interact with all the things that make up a computer. As a live demonstration, IBM used it to create the WorkPlace Shell.

Why? Over the years, we've learned to think about programs, when what we actually use is data (or more specifically information, but we'll leave that distinction for another time). Think of it: your job definition does not include "uses word processor X," but rather "creates reports and publications." O-O software, even in its infancy, removes much of the program from the way your reach your data, and finally acknowledges that there are a lot of computer jobs that the machine should really do for you.

Like...

  • Figure out how to print something - Why open a program just to print or fax a document when you can just send the document to the printer?
  • Manage your data containers - Why open a program to move some data (files and related things) around when you can manipulate that data directly? How about a spreadsheet where cells can be moved around (and adjusted automatically) by being dragged into place?
  • Handle hookup details - You should be able to redefine a LAN printer in about five minutes (including unpacking and connecting the printer) and never touch more than its server.
  • Change a ton of things in a wink - Like your desktop subdued and quiet, warm and fuzzy or loud and proud? Change the appearance of your entire system with one Drag+Drop.

All Right Already, What Are Objects? The Webster's dictionary I have lying around defines an object as "something mental or physical toward which thought, feeling or action is directed."

OS/2 objects are all over your desktop. In fact, your desktop is an object. How can you tell? That's what that little-used right mouse button is for. Click that button on anything, and if it's an object (and is listening) it should show you a menu of what it can do.

Take Webster's definition, and you see that a printer is an object, a thing. In the O-O world, give the printer some knowledge about how it does things (its methods) and it becomes a printer object. Give files access to some "knowledge" about how to do "file" things (methods for creating, deleting, renaming and such), and you can tell file objects how to manage themselves.

Objects are like mini-programs, sitting quietly, waiting to be told to do something. The mouse (and keyboard in most cases) are used to send messages to a message queue. If you think of queues as radio stations, you can see that various objects tune into various queues (though mostly just one, the PM Message Queue). The objects listen to these messages, responding if they can. For example, just about every object understands the basic mouse-button clicks.

       SingleClick   DoubleClick   Drag   Alt-Single
      

Left Select Open NA Rename Right Show Menu NA Move PickUp

Messages can appear in the form of other objects, so a printer object can "understand" what to do when you Drag+Drop another object onto it. So can folders - the desktop too, since it's a folder or container for other objects and folders. Some objects don't understand certain messages. The System Clock doesn't know what to do when an object is dropped on it. It just wouldn't make sense and so it has no methods for handling dropped objects.

A simple demonstration of this Command-and-Obey behavior occurs with the Desktop Settings Notebook. If you toggle Icon Display from Normal to Small Size, the results are immediate. Every object on your desktop understands the IconSize message and responds to it immediately. In effect, the button on the Settings page shouts out "Hey, make your icons small|" to the desktop, and all objects that have icons just do what they're told.

A more dramatic example can be found with the Scheme Palette. With a simple Alt-Drag of any Scheme to the desktop (or any other folder) you can completely alter the appearance of your entire system permanently or until you change it again. All open folders and applications will automatically assume a new color scheme, including menus, window frames, backgrounds, and scroll-bars.

As you look around your system you should notice that there are different "kinds" of objects, usually distinguishable by their icon. (I say "usually" because an object's icon is just another feature that can be changed.) The desktop, for example, doesn't use the standard folder icon even though it's just another (although special) folder.

Objects are generally derived (defined) from classes. All OS/2 objects are derived from the WPObject Class, which specifies all the basic characteristics of OS/2 objects in a very general sense. From the WPObject definition, several other classes (sub-classes) are defined:

  • The WPAbstract Class defines Mouse and Keyboard, Clock, Printer, Shredder and Program Objects.
  • The WPFileSystem Class defines DataFile and Folder Classes.
  • The DataFile Class defines objects like Bitmap, Icon and ProgramFile while the Folder Class defines the Desktop, Drives, Startup and Templates.
  • The WPTransient Class defines transient objects like print jobs and Toolbar events.

Every object belongs to the WPObject Class, so they have the basic OS/2 object characteristics, menus and icons. Folder objects are differentiated with a "special" membership in the WPFileSystem Class because they deal with actual files on disk, and do "file" things (like show them in Icon, Tree or Details view). The desktop is a further extension of a folder.

The relationships between the various classes are described in the SOM Class Hierarchy, which is similar in form and function to a diagram from a Zoology class. In a Zoology class, we see that humans and horses are both mammals. So we can expect that they have many of the same parts: heats, lungs, heads, and so on. Yet humans and horses are different enough to be put in their own classes. Similarly, classes like the ones described earlier are roughly alike, but different enough to be labeled differently.

A hierarchical definition of the "things in our world" is very powerful because it provides a very efficient way to collect and organize information. If you know a horse is a mammal and if you know what a mammal is then you know a lot about horses without ever actually seeing one. Knowing that all OS/2 objects can have a settings notebook means that you already have a pretty good idea what to look for in any new objects you encounter. Knowing that the desktop is a folder means you can treat the desktop like any other folder: give it a background, move its objects around, right-click on its background to get a menu, and so on.

And Now a Little Technical Detail I've tried to keep away from buzzwords but, there are a few that are inescapable because they form the conceptual underpinnings for the whole O-O movement. Object-Oriented Design (OOD) involves attention to three key "prime directives": encapsulation, inheritance and polymorphism - big words (and some say mantras), but understanding these three concepts makes the rest of O-O pretty easy. While the initial start-up costs can be high, (unless you have no prior bad habits to break or are pretty flexible) the benefits are enormous.

1. Encapsulation

It's nobody's business to understand how a printer prints except the printer's. Any printer object should be able to receive any kind of object from anywhere and print it appropriately (or advise otherwise).

OS/2 printer objects do just that. You can Drag+Drop any object onto a printer object and if it can be printed, it will print using whatever (SOM-enabled) application that was used (and is still available) to create it.

If an object can't "accept" another, it displays a "No Entry" icon and will ignore the drop. Dropping an object onto itself does not work simply because objects almost never know how to "accept" themselves. Not that this leads to any lack of self-esteem, however.

At the programming level, encapsulation means programs can be divided up into specialized pieces, and work "sub-contracted" out to the pieces to be done as they see fit. Like super-subroutines, SOM objects understand a fixed set of messages and hide all their details (like resource use and memory allocation) from the caller. This can present an enormous amount of "small looks big" leverage because SOM objects provide a nearly-free professionally-written library of software for all the tricky stuff like error-checking, interface-building and operating system interaction.

2. Inheritance

Have you ever noticed how a printer object menu is like a folder object menu except that it has a couple extra entries at the bottom? How about opening the desktop in tree view or details view?

Just like you may have inherited "strong hands" or "tallness" from your parents, objects can inherit traits from a parent. Unlike many things we inherit from our parents, objects can override what they inherited. SOM objects are grouped into classes of similar objects. Printer objects inherit most of their abilities from the folder class and add a couple (or more on a LAN) more features. The WPS Desktop is "sub-classed" from the folder class, with a few features removed (like delete) and a few others added (like shutdown and lockup).

Using OS/2 SOM objects means your work or programming environment inherits all the features available to the system, and as new features are added you inherit them immediately.

  • Connecting OS/2 to a network lets your system automatically inherit all the LAN resources you are allowed: new drives show up in your drives folder (a sub-classed folder), a network applications folder can appear on your desktop with available LAN-provided objects, network printer objects accept files.
  • OS/2 LAN Server 4.0 uses SOM objects, adding a menu and status bar to a folder object to let you manage users and resources as you manage files. Give a user access to a resource by drag and dropping either object onto the other. Drive and folder objects on a server (or peer workstation) inherit file-sharing options when a server is present.
  • Stardock Systems recently released Object Desktop, which through inheritance can radically alter the operation of the WPS and many other SOM-based applications with code from two floppies. Similarly, the NPS WPS Enhancer, freeware written by a Japanese TeamOS/2 member, uses 190k of disk space to change the "personality" of the WPS in amazing (and amusing) ways.

3. Polymorphism

Drag any document to the printer and it should print using whatever printing method is defined for it, or at least use a "default" method. Documents should know how to print themselves, without the printer needing to be prepared for new types of objects.

A printer object can modify its actions to suit the objects it receives. It can just as easily print Mesa/2 spreadsheets as it can AmiPro documents. Just drop things onto a printer and it handles the rest. Polymorphism is the ability for an object to have multiple personalities, adapting to the messages it receives and changing its character to suit data that it may have not been specifically designed to understand.

Examining OS/2 Warp Objects

Want to see some object definitions? Look in

c:\os2\ini.rc  at line 110, for the

definitions of the basic OS/2 objects. While you're at it, look in the other .RC files to see a few other ways that the WPS can be defined. All the Classes I mentioned above are actually called WP-whatever. The Information Folder is an object of class WPFolder, located on <WP_DESKTOP> (which usually points to C:\DESKTOP) with an ID of <WP_INFO>.

For a closer look you'll need some tools. Most OS/2 programming language packages have a Class Browser, required to decode the data that makes up Class and Object definitions. You can browse the OS2*.INI files with some freely-available tools like IniMaint or other INI editors. But beware: if you make a mess with one of these tools, you have some serious work ahead to repair things.

Objects Under the Hood

In OS/2 Warp, object thinking has been taken to deeper levels than just the user interface. Programs allocate memory objects, which are logical "chunks" of total system memory. Memory objects are marked in several ways for housekeeping purposes, including whether they are private or shared (and by who), how much is actually in RAM, and how that RAM is allocated.

Keep your Objects Awake Longer

Objects use a certain amount of memory. After use, an object is kept in memory for a certain amount of time before its memory is released back to the system, 90 seconds by default. This interval is called OBJECTSNOOZETIME and can be SET from CONFIG.SYS. You can "see" this interval if you have a laptop that can turn off its hard-disk to save power. After a while, Desktop Objects like the ToolBar are flushed out of memory and must be re-read from disk, and even passing your cursor over the ToolBar will cause your disk to wake up.

A Very Important Effect of SOM Design

In OS/2, file references are ID-based. File names and locations are merely attributes (like icon or creation date). Thus, a file moved in a SOM-based system automatically updates any references to it on that system. DSOM, the distributed form of SOM, extends this portability out to the network (and thereby the world).

There is another operating system, used by others, that builds its links using File Name references (locations), and must re-establish those references by searching all available file storage, even across a network, every time an object is moved. You can imagine what might happen if this search finds a different copy of that file with the same name. Also imagine what happens when that file is linked to others.

Expect users of SOM-based systems like OS/2 Warp to have a lot more fun with objects as they plan where they're going tomorrow, rather than just where they're going today.

What's the Big Deal about VisualAge C++?

by Jose De Jesus

Have you ever needed more time than you expected to complete a program? Or have you ever delivered a system you thought was complete until the specifications changed? Most programmers--even wizards - have experienced this situation. Over the past 30 years the software development industry has had an overwhelming demand for programs, yet too little time to deliver. Since then, new paradigms for creating software - structured programming, CASE, object oriented programming--have helped alleviate the crisis. But the applications backlog is not over. The ever increasing number of computer users will guarantee more headaches for programmers as they try to meet customers' needs.

If you write programs for a living, you need several things. One of these is the ability to use and write reusable code. In other words, you need to know object oriented programming (or OOP for short). Why? Simple. OOP, despite its learning curve, lets you write, extend, and maintain software more easily, and reliably.

Hold that thought for a minute, and consider one of Murphy's laws: "Users don't know what they need from a program until you finish writing it." This proverb exaggerates, but it is often true that users better define their requirements by interacting with a mockup of the system you are designing. In order to survive the dynamics of user requirements, you also need a development tool that is both powerful and flexible; one that can support OOP but also allow exploratory or visual programming.

VisualAge C++ is a visual programming tool that lets you quickly build OS/2 applications from prefabricated parts or "components." Within VisualAge C++'s Composition Editor, a component appears as a bitmap button on a palette of graphical controls. You can drag and drop components from the palette into your application's form and automatically incorporate their functionality. You can also "extend" the capability of VisualAge C++ by building your own reusable components. Components can be visual (controls, dialogs, menus) or non-visual (system timers, databases, queries).

VisualAge C++ closely couples the visual prototyping paradigm with a fully object-oriented programming language (C++). Inside, a VisualAge C++ component is an object instantiated from a class that is either user-defined or that belongs to IBM's Open Class Library. The Open Class Library provides a powerful OOP applications framework from which your programs can inherit base functionality and avoid complicated or repetitive OS/2 programming tasks.

VisualAge C++ is not just a visual programming tool, but also a powerful object-oriented development environment that allows a fast transition from prototype to deployment. It is IBM's most advanced OS/2 development environment, to date. Under VisualAge C++, testing a prototype also means creating the stand-alone OS/2 program. There is no additional step required to create the final product. That means you can extract specifications from the user as you build your software. This minimizes coding efforts and ensures that the application under construction will survive the user's future changes and additions. In a sense, VisualAge C++ empowers non-programmers to continually influence the form and content of their OS/2 applications. That's a very big deal|

For more information about VisualAge C++, point your browser to http://www.torolab.ibm.com/software/ad/vastub.

ENTREPRENEURS

Entrepreneur: Doctor Sebastian A. Sora

by Steve McNally

Dr. Sebastian A. Sora is a Professor of Information Systems at Montclair State University in New Jersey. He speaks and writes on topics related to this field, and is also a programmer. Recently, IBM has contracted him to develop a program to help their salespeople create customized offerings tailored for their customers' needs. Dr. Sora is using object-oriented programming to develop this application because he can create a reliable application relatively quickly and he can easily modify the application to for businesses other than IBM.

The object of his tool is to integrate all the appropriate information to create a total and accurate proposal for the customer. "The most important step in developing this program," said Dr. Sora, "was creating the objects a marketing person would have to deal with to formulate a proposal. One of the well-defined classes in the program is the Product class. Each different IBM product would be an object in this class. Since customers can order IBM products with a numerous options to meet their needs, these objects have many attributes where the attributes define the product configuration.

Furthermore, many of the objects in the Product class must be configured with other objects. For example, the AS/400 Processor object must be configured with the Storage Device object. To determine how objects fit together within a proposal Dr. Sora needed to create a set of rules. "Many relationship rules must be created to define how objects and their attributes relate to other objects." To help create and define the objects for this tool, Dr. Sora used IBM VisualAge C++.

"VisualAge allows you to create the objects and rules and then compile the program. The program itself is driven by text rules that define the data on which the program runs. VisualAge has pre-defined objects, and you can save the ones you develop for use by other programmers and applications. Creation of such objects allows for easy change, and the addition and removal of function without effecting the program as a whole."

"There are basically three functions: File (save, get rules, etc.), Calculate (select products, prices, etc.) and Help. One of the File functions will create a letter of the products and the prices for the customer. This, in turn, becomes the customer's form for ordering the products. The key issue that must constantly be understood is how to achieve information availability and flexibility."

The program, including its rules, will fit on one 1.44MB diskette, runs reliably under OS/2, and is easy to use. These are important factors because the sales people use this tool in front of their customers. They are generally working from their laptops and cannot be bogged down by applications demanding heavy resources. The program needed to be simple because salespeople will not tolerate a steep learning curve no matter how good a tool is. Furthermore, the tool needed to be reliable because who would buy a computer system from a sales rep whose software doesn't work?

Object-Oriented Programming (OOP) allows Dr. Sora to customize his program to address a variety of needs. "This tool has wide applicability to any business that sells product. All that needs to be changed are the text-based rules; I mean, rules that define products: cost factors, prices, etc. that are unique to that particular business. These rules can be created using any text editor."

"Object Oriented Programming allows you to quickly code prototype applications with which OS/2 gives tremendous levels of productivity. Even when I need to write for DOS or Windows, I use OS/2 because any kind of programming involves a lot of allowing the application to run until it crashes your system and then finding the code at fault. OS/2 allows me to run several instances or generations of the code in different sessions. Under OS/2, these individual sessions usually won't crash. It will halt and tell me which line of code is at fault. If one session crashes, I simply start another. I used to have to reboot every time. This saves me a humongous amount of time."

You can send a note to Dr. Sora at Sailor@ibm.com.

ELECTRONIC 'SCAPES

The Future of the Internet in an Object World

by Maxine Senn-Yuen

If you already have OS/2 Warp, then you know how easy it is to access the Internet with the Internet Access Kit included with OS/2 Warp. Now that you know how to get to the information on the Internet, the question becomes "what can you do with it?" Or more precisely, "what can it do for you?" While the Internet is a very useful communication and research medium today, object technology promises to open a new world of opportunities for users in the near future. To better understand this potential, let's examine some of the limitations of the Internet in its present form.

To update a document on the Worldwide Web today, someone must rewrite the underlying HTML code. The documents are not dynamic. They are somewhat akin to newspapers, which although informative, can be somewhat stale. Hyperlinks and multimedia content make Web documents livelier than newspapers, but not truly live. With object technology, we'll soon be able to build Web documents out of parts that are live. So a stock price object on the Internet could be continuously updated with a live feed from stock exchanges. And video objects could show what's happening somewhere else in the world in real time. Just as live satellite broadcasts revolutionized the television industry three decades ago, so too will object technology revolutionize the Internet.

The Internet contains vast amounts of information, but much can't be used immediately in the format we get it in today. Here's a trivial example of that fact: we can download a GIF graphic file, but need a viewer or graphics program in order to use or manipulate that file. The goal of the Internet in the future will not be to move around data, but rather objects that are immediately useful. So a spreadsheet object on the Internet in the future will not only contain data, but everything we need to manipulate that data and examine different scenarios. In the context of business, object technology will allow you to integrate the Internet into what you are you trying to do. For example, you could build a finance object with automatically updated interest rates that's directly accessible to customers anywhere in the world. Information on the Internet in an object world will therefore be higher quality, and more valuable.

We are already evolving in the direction of an object-based Internet. You may have heard of Hot Java, a technology that allows you to embed applets (small applications) in your Web documents. Businesses today are experimenting with Java technology to create Web documents that include live animation and sound. Another step toward incorporating object technology is called CyberParts. CyberParts is a convention that allows the in-line embedding of a variety of software component architectures, including OpenDoc and OCX. CyberParts is considered more flexible than Hot Java because it supports a wider variety of embedded objects.

Why is in-line embedding important? State-of-the-art Web browsers, like IBM's WebExplorer (ftp://ftp.ibm.net/pub/WebExplorer/web103.zip ), support in-line rendering of a fixed set of standard data formats including rich text, images, simple forms and tables. Web browsers must use "helper applications" to display data formats that can't be natively handled by the browser. Typically, multimedia data formats, such as MPEG video files, fall into this category. As the popularity of Web publishing increases, the desire to support in-line custom data formats has also increased.

For example, if your line of business is Industrial Architecture you might want to publish Web pages that contain in-line CAD-CAM drawings. This makes for a much more effective presentation as opposed to displaying the drawing out of context in a separate desktop window, which is what would happen if the CAD-CAM rendering tool was specified as a helper applications. CyberParts, currently in development at IBM, will allow you to do this. A prototype of CyberParts will be demoed at the IBM Internet booth during Comdex this November.

It's clear from these examples that object technology will make the Internet more powerful and easier to use, enriching our lives in ways we can only imagine today.

USER POWER

Are You an OS/2 Warp Connect Power User?

by Karla Myers

By today's standards, the power user is someone who takes full advantage of the power of the software. She's not afraid to work with it, to try new things, or to push the known limits. Could YOU be a power user? If you shake your head up and down to at least half of the following questions, you are an OS/2 Warp Connect power user|

Can you do a remote installation? Yes? Then you know you should install OS/2 Warp Connect locally to the first machine, then select Remote Install to create an OS/2 Warp Connect client elsewhere on your network. Remote Install saves a lot of time for network administrators because it can turn a single client workstation into the delivery mechanism for a whole network of clients. Done this already? You are a power user|

Can you connect to a network? Yes? Great| Using IBM Peer for OS/2 (included with OS/2 Warp Connect), you've probably already opened the Network folder on the Desktop to see what resources are available to you. If you haven't assigned any network resources to your userid, you know how easy it is to use Sharing and Connecting to assign modems, directories and printers. The resource browser will give you access to those resources as soon as they become visible or public to the network. You've probably also tested the Peer capability by running Sharing and Connecting to share your CD-ROM with the network. Wasn't it fun letting other peers on the network install applications from the BonusPak for OS/2 Warp to their machines from your CD-ROM? Been there, done that? Then you are a power user|

Can you use Person to Person for OS/2 (included with OS/2 Warp Connect)? You've probably dialled in from a remote location with Person to Person and co-edited a document with someone at the office. You may have also used Person to Person to help users come up to speed quickly on a new application, by placing a snapshot of the new application into Person to Person's shared Chalkboard. To do this, you first established a Person to Person session with the user, then opened the Chalkboard and selected Start from the Mirror menu. Finally, you positioned one of the special mouse pointers over the desired application window and clicked. A mirror-image of the application was stored in the shared Chalkboard where all participating users could see it, type on it, draw on it and store it. If you're a power user, you know that Person to Person makes brainstorming at a distance as easy as being there.

Can you configure TCP/IP (included with OS/2 Warp Connect)? As a power user, you know you most often configure TCP/IP during installation. There are some instances where you need to have the IP address, subnet mask, default and net routers (including the destination address for the Net router), a machine hostname, a local domain name and the Nameserver address. Not a big deal| You know to change configuration by choosing the OS/2 System icon (this is the default setting), then the TCP/IP icon, and then the TCP/IP configuration notebook. You knew this already? Then you're a power user|

Can you make diskettes for OS/2 Warp Connect and for any of the network options? As a power user, you know that if you have a system that is already running a previous version of OS/2 you can go to an OS/2 window and change to the drive letter of the CD-ROM drive. At the prompt, type MAKEDISK and press Enter. Be sure to have twenty-five 1.44MB diskettes on hand.

For the networking products, open an OS/2 window and change to the CD-ROM. Type PRODINST. A list of the networking programs appears at the bottom of the screen along with a button labelled DISKETTES. Click on the program for which you want diskettes (only one at a time|). LAN Distance Remote requires 3 diskettes, LAN Requester - 8 diskettes, MPTS - 3 diskettes, Netware Client - 7 diskettes, NSC - 1 diskette, IBM Peer - 7 diskettes and TCP/IP - 8 diskettes. You've done this already? Then you are a power user|

Can your notebook connect to the network using a PCMCIA network card? Yes? Outstanding| Connection issues are very individual to each notebook and PCMCIA card. You know you should have the latest drivers for the PCMCIA card. You've also checked the Shared RAM Address of the PCMCIA card to eliminate possible IRQ conflicts. Already done this? You are a power user|

You nodded along with several of these, didn't you? See? You really are an OS/2 Warp Connect power user| If you weren't able to nod at most of these, you now have the information you need to become a power user.

OpenDoc Advantages for Power Users

by Joe McIntyre

You will soon view applications in a whole new way. The technologies that are being introduced in OpenDoc will be the catalyst for software developers to focus on delivering software that is focused on solutions, not just lists of features ... software delivered in components.

Imagine this scenario... You are a financial advisor, and want to create monthly reports for your clients with their current portfolio balance. Starting with a word processor, you create a template for the form letter that you will fill in with specific information for each client. Your next step is to set up the mail-merge feature of the word processor to automatically fill in the name, address and other standard information for each of your clients. Being a power user, you also have set up the database used for the mail-merge to include the current portfolio balance for the client, so it can be included in the letter as well. Collecting the balances adds another step to the process, but makes the letter useful to your clients. Your customers like the monthly report better than the terse statements they received before, but would like it even better if the portfolio details were included as well - and for it to look nice. It looks like you are in for a lot of work.

With OpenDoc, consider the scenario again. OpenDoc builds applications from components - small pieces of software that are very good at particular tasks. Thus, a software solution built using OpenDoc starts with the identification of the different tasks that you want to accomplish. So, in this example we identify:

  • a word processing component to create our report text
  • a database component that holds our customer portfolios
  • a mail-merge component

These three components will be very common. Just like software packages we can purchase today, these components will be available from a number of vendors, but will also come in specialty versions for particular markets.

In this example, your word processing needs could be addressed by a component with the equivalent of one of today's "works" products like IBM Works or Lotus Works. Your word processing component won't need to be overly complex. Next identify a database component. If you store the customer data on an existing database, you will need a data access component to retrieve data from that database. If you decide to use a new database, it may provide a component interface or a data access interface. Lastly, identify a mail-merge component. This example assumes that the word processing component did not come bundled with this component. Look for a mail-merge component that supports the text and database access event suites. Since OpenDoc defines standard suites for different types of components, any product that supports a suite can be used by any other product that uses that suite. When you identify the mail-merge component that meets your feature requirements and supports the suites for the other components you select, you are ready to put together your application.

To build the application, install each of the components. Then open up a new document with the word processing component as the root, or main, component. Write you monthly report text, including a field for holding the portfolio balance. Link the field to the database, using the client number as the lookup key to retrieve the portfolio balance. Complete the task of building your customized application by connecting the mail-merge component to the letter and setting it up with your database of clients.

Now onto the details of creating to your monthly report. You want your document to appear in a table format. The component you choose should be able to display values and titles like a spreadsheet and be able to retrieve values from your database. You also need simple formula support to calculate totals. Many OpenDoc components will have these capabilities, ranging from simple table components to sophisticated spreadsheet components. In this case, a simple component will suffice. To use the new component, embed it within the word processing component. Setup the table component to connect to your database, again using the client number as the key. OpenDoc allows components to manage their own size, so on the screen the table could display a scrollbar to allow the user to scroll through a list of portfolio entries, but when the document is printed, the entire list would be printed and the word processing component would manage the pagination.

To finish our customization, we consider the time required to create the statements. If you wanted to create statements for 10 clients at a time so you don't tie up the printer for long periods, you could write a short script to control the printing. For example, the script could fetch a list of clients, instruct the word processor to create a new form letter for the first 10, then wait for 15 minutes before sending the next 10 until all the clients had been processed.

If a few months later, your clients start requesting historical data on their accounts as well as recent prices of the stocks and mutual funds in their portfolio, OpenDoc gives you the flexibility to add more function to the functions you've already developed. To get the recent stock prices, using scripting you can add a component that hooks up to the Dow Jones information source, determines what stocks and funds are part of a client's portfolio and adds this to the letter. To satisfy the request for historical data, you can again use scripting to pull the portfolio balances from the data base and then present the information in a graphical format using your chart component.

In fact, scripting is one of the most important features in OpenDoc from a power user perspective. It provides the means to shape and customize your software to suit your changing needs. The application suites available today have limited feature sets that won't change until upgraded versions of the applications are released. It is virtually impossible to expand their functionality without rebuilding the applications from the source code up. With OpenDoc components, you are in control of your software. You decide the precise set of functions you want, and bind the necessary software components together using scripts. Your applications are now specialized to fit your individual needs. In some cases, vendors may provide prepackaged sets of OpenDoc components that satisfy common needs - but unlike today's applications, when you want to replace or add a component, you can simply snap in a new component and link it to other components using a simple scripting language.

We have now discovered three ways that OpenDoc components will make applications more useful:

  • by incorporating content directly from its source instead of manually
  • by adding new content easily
  • by using a simple user-written script to automate a process.

This example illustrates some of the practical uses of OpenDoc. What are the next steps for you, the power user? Start by considering what the most important tasks you perform are, and what parts of your existing application set you use to accomplish those tasks. Next, think of the features that are difficult to use, or don't exist, in that application set. Now you have defined the OpenDoc components you require, and what you should expect from those components - solutions that will make it easier for you to accomplish your goals.

OpenDoc's benefits for power users, and other computer users, are readily apparent. OpenDoc will provide greater flexibility by allowing us to choose the functions we want in our software components. In this way, it will help overcome the feature limitations of traditional applications. OpenDoc will also encourage us to work in a more productive and intuitive way, by focusing our attention on our work and not our software. Finally, OpenDoc will empower us with the capability to do things we can only imagine today.

FEATURES

Taligent Delivers Object Technology

by Jeri Dube

The Need for Object Technology As information technology becomes more complex with heterogeneous networks, pervasive use of distributed systems, and the movement to client/server configurations, object-oriented systems become more relevant and more necessary. On top of these more technical requirements, businesses demand creating new and updating existing applications on increasingly faster schedules. This pressure moves object-orientation from the realm of interesting but somewhat esoteric technology to that of required methodology.

Incorporating reusable objects in an object-oriented application can lessen the time pressure in creating new applications. The extensibility of object-oriented design eases the enormous burden of maintaining applications and adapting them to new requirements. Object technology encompasses more than just new programming techniques. The technology pervades all phases of system development from analyzing problems through structuring and programming systems to maintaining and extending systems. Object technology changes how systems and objects communicate with each other.

For systems to communicate with one another using traditional programming methods, each system has to understand how the other works. The object-oriented methodology encourages systems not to know how another system works but know only what the other system will provide. This means that object-oriented systems are independent of the inner workings of the other systems with which they communicate. If one system changes, this does not mandate changing all the systems with which it communicates. (Three object-oriented terms: encapsulation, polymorphism, and information hiding, encompass this concept.) Therefore object-oriented design is well-suited for structuring and developing systems that need to communicate with other systems such as heterogeneous network solutions, distributed applications and client/server solutions.

Solutions from Taligent

Since it's inception in 1992 as an independent software company jointly owned by Apple, Hewlett-Packard, and IBM, Taligent focused on creating solutions using object technology. In early June, Taligent reached a significant milestone by completing the CommonPoint Application System reference release and delivering it to its investors. The CommonPoint Application System is a complete system that provides the structural foundation and tools for creating object-oriented solutions as well as an execution environment.

The CommonPoint Application System include a comprehensive set of approximately 100 integrated object-oriented frameworks. System developers use frameworks instead of developing their own version of commonly-used functions. For example, a developer creating a banking system would use a set of integrated graphic interface frameworks to build a user-friendly, attractive front end to his application. He could then focus his attention on improving the finer points of the banking system. If the frameworks he needs don't quite meet all of his requirements, he can extend and modify the frameworks to meet his system specifications.

Taligent divided the CommonPoint frameworks into two categories: application frameworks and system service frameworks. CommonPoint includes application frameworks for rich compound document structure, saveless document storage model, integrated 2D and 3D graphics, photo realistic imaging, international text, localization services and task-centered user interface extensions. The system service frameworks include vendor-independent database access, shared document collaboration, and multi-cast command routing.

Today's Hopes, Tomorrow's Imperatives

These and other CommonPoint frameworks advance the state-of-the-art of computing and raise the bar for minimum feature requirements included in applications. They provide the design and code to create the features critical to the next generation of applications. Three of these significant feature areas are:

  • task-oriented user interfaces
  • internationalized applications
  • collaborative workgroup solutions.

A truly intuitive user interface does not force the user to change the way he thinks or does something just because he is using the computer as a tool. So although the computer completes tasks within applications, it is more intuitive for a person to just focus on the tasks rather than worry about which application performs the task.

An interesting example is the way a person creates a presentation, using different sources of information. The natural way to do this is to figure out what type of information is needed, determine its location, go get it and position it in the presentation. With today's application-centered way of using a computer, the user has to open a presentation application such as Freelance to initialize the presentation. To include any information created by a non-compatible application in the presentation, you need to start up the application and then meld the resulting data or picture into the presentation with some computer technique like cut and paste.

The intuitive system would let the user just name (or point to) the location and the type of data to include without having to start an application. The base document (or in this case, presentation) would simply start up the necessary application based on the type of the data requested. Furthermore, the execution of the secondary application would be transparent to the user. He wouldn't even know the system was doing it.

The structure of most of today's application inhibits developers from easily modifying applications to satisfy international requirements. It can take weeks or months to deliver different language or localized versions of an application. Since most large enterprises have a worldwide scope, it's often essential to have a timely rollout of these alternate versions. Not only do the CommonPoint frameworks include the necessary code for internationalizing applications, they also enforce the separation of the program logic from the way information is presented to the user. With both the required structure and function included in the international text and localization frameworks, companies can now quickly internationalize their applications and get them up and running wherever they need to be.

Collaborative workgroup solutions address both the problem of distance between co-workers as well as the problem of increased pressure for fast turn-around time. These solutions let co-workers in any location simultaneously look at documents on-line as they are being created, updated or reviewed. Perhaps even more importantly, collaborative applications allow people to interact with one another via computers in a very natural way. The benefits of this capability are so great in terms of increased productivity, saved time, and decreased travel, that collaboration support will be mandatory for any commercial application that hopes to be competitive. CommonPoint applications are inherently collaborative because Taligent built the collaboration facilities into the underlying structure.

Inherent Reliability in CommonPoint Applications

Using CommonPoint frameworks not only simplifies development and therefore improves programmer productivity but it can improve system reliability as well. The object-oriented principles that serve as lemmas to that theory are reusability, inheritance, and encapsulation. Almost by definition, reusable code is more reliable than newly-created, single-use code. That is, if the code did not run well in the first place, it would not be reused or it would be fixed before it is reused. Furthermore, over time reused code is run more often and under more conditions than single use code, therefore; the bugs are more thoroughly rung out.

Inheritance is a mechanism by which code is reused within the same application. Sub-classes inherit properties from more generalized, parent classes. In this way, sub-classes share common code but also contain, details which differentiate them from one another. Inheritance provides object-oriented programmers a great deal of flexibility, while minimizing their coding effort. If a program needs a variation on a class, the programmer can create another class that uses some or all of the properties of an existing class. He can then add additional capabilities to the new class if needed. CommonPoint also allows for multiple inheritance. In this case, a class could inherit properties from more than one class. The result of the inheritance mechanism is a well-structured hierarchy of classes. The reusability as well as the controlled structure resulting from inheritance contribute to the inherent increased reliability of object-oriented programs.

Many system reliability problems occur from inconsistencies and interface problems at module boundaries. Encapsulating function within objects forces explicit rather than implicit dependencies between related modules. In procedural programs, many dependencies are implicit, therefore the dependencies are hard to find and cause errors when a program changes. Explicit dependencies between modules enforces that the communication between modules be precise. For example, if one module, the client, needs some information from another module, the supplier, the client needs to ask for the information using the precise format required by the supplier. In turn, the supplier needs to return the information in a format that the client can use. On the other hand, neither module needs to know what the other module does with the information it receives.

More on CommonPoint

Applications written using CommonPoint frameworks require the CommonPoint Application System execution environment. This environment lets new object-oriented applications fit into current operating system environments. This co-existence lets companies incrementally adopt object technology without losing their current investments in procedural applications. Initially the operating system independent environment will run on AIX and then OS/2. In a few years, it will run on a wide variety of operating systems. The execution environment includes the class libraries and the other support mechanisms that the CommonPoint frameworks need to run.

In addition to the frameworks and the execution environment, the CommonPoint system contains tools that are critical to object-oriented development. Included in the toolset is cpConstructor, a user-interface builder. Taligent will add to the toolset on an on-going basis. Their next product is called cpProfessional. This product supports incremental compile and linking and the ability to define customized views for browsing. Both cpConstructor and cpProfessional support rapid iterations for changing and adding function to applications.

IBM's CommonPoint Products

IBM, as one of the Taligent investors, is adding the CommonPoint Application System to its extensive portfolio of object-oriented enterprise offerings. The CommonPoint Application System for AIX and the CommonPoint Application Development Toolkit for AIX are the first commercial offerings of the Taligent technology. OS/2 developers will also soon benefit from Taligent's cutting-edge object technology when IBM releases CommonPoint for OS/2. For OS/2 developers anxious to get started with CommonPoint, IBM is offering a JumpStart Program. This program offers an extended period of support for developers that commit to build CommonPoint applications. The OS/2 CommonPoint products will be available by year end 1995.

CommonPoint products are initially intended for use by experienced C++ developers that are early adopters of object technology. As more and more, developers realize the productivity advantages and the competitive edge they can gain from using object technology, they will require CommonPoint products. Using these products, developers and their users will find a common point for a new generation of computing.

For more information on Taligent, its products and object-oriented technology, explore Taligent's World Wide Page at http://www.taligent.com. For more information on CommonPoint for OS/2 you can send an e-mail to the IBM Solution Developer Operations at objtech@vnet.ibm.com or you can visit their web page http://www.austin.ibm.com/developer/objects/object-tech.html.

Glossary of terms

Class - A characterization of data and its associated manipulations that serves as a template for creating instances of objects in object-oriented systems. Every object in a class has the same basic characteristics. For example, in a bank system there may be a class called Bank Customer that includes the following data: name, account number, social security number, address, and phone number. The manipulations or operations associated with this class are add customer, delete customer, change address, and change phone number. An example of an object in this class would be John Doe, with account number: 1122333, social security number: 555-22-5555, address: 5 Homely Way, Podunk, Indiana 44334 and phone number: 204-555-1212.

Client/Server Solution - A computer solution that involves communication between different computers where one computer is designated as the server and one is the client. The client will request information or processing from the server and the server will send the result back to the client. UI is on the client.

Collaborative Workgroup Solutions - A solution that facilitates two or more people working together.

Compound Document Structure - A structure that allows documents to contain two or more embedded components. For example, a presentation that contains both a spreadsheet and a photographic image is a compound document.

Data Abstraction - A programming technique whereby an object that requires information from another object does not need to understand how that other object works only how to send and receive messages from it. The construction of the messages is based on a generalization of the details comprising the object. Consequences of using this technique are:

  • systems built by multiple designers can be built faster because each programmer does not have to know how the other pieces of the system work only how to get information from them
  • Elements of the system are reusable because inherently there is no dependency on other modules in the system.
  • The system is easily extensible because a change in one of the elements is self-contained and does not have to be propagated throughout the system.

This is also known as information hiding.

Distributed Applications - Applications where different parts of the application are run on different systems.

Encapsulation - Combining data and its associated operations or manipulations into a single software entity. The programming contained within the software entity is protected from the activities that occur outside the module. Furthermore, the code within the entity is not dependent on code external to the module.

Frameworks - Pre-built, reusable software components consisting of integrated sets of classes that are combined logically to perform a function or a set of functions

Heterogeneous Network - A computer network containing multiple types of hardware and software systems.

Information Hiding - A programming technique whereby an object that requires information from another object does not need to understand how that other object works only how to send and receive messages from it. The construction of the messages is based on a generalization of the details comprising the object. Consequences of using this technique are:

  • Systems built by multiple designers can be built faster because each programmer does not have to know how the other pieces of the system work only how to get information from them
  • Elements of the system are reusable because inherently there is no dependency on other modules in the system.
  • The system is easily extensible because a change in one of the elements is self-contained and does not have to be propagated throughout the system.

This is also known as data abstraction.

Inheritance - A mechanism by which a class can acquire the data characteristics and properties of classes that have already been defined and coded.

Internationalized Applications - Applications readily changed to meet the requirements of different countries, languages, and locales.

International Text - Text that is not only represented by unicode character representation but it handles all the rules associated with the text such as the direction in which to print the characters.

Localization Services - Services that handle the variations dependent on local customs and standards such as using a comma or a decimal point when writing the decimal representation of a fraction.

Multi-cast Command Routing - The ability to send messages, documents or whatever to a list of people as you perform commands. This allows collaborators to see what you are doing as you do it.

Object - A software entity that encompasses both data characteristics and operations or manipulations that can be enacted on that data.

Alternate definition - An instance of a class.

Object-oriented methodology - Applying the principles and concepts of object technology to analyzing, designing, structuring and programming computer applications or systems.

Polymorphism - The ability for an object to have multiple personalities, adapting to the messages it receives and changing its character to suit data that it may have not been specifically designed to understand. For example, a printer object can modify its actions to suit the objects it receives. It can just as easily print spreadsheets as it can documents. Just drop things onto a printer and it handles the rest.

Saveless Document Storage - The system automatically saves a document as it changes without the user having to perform explicit save commands.

Shared Document Collaboration - The ability for two or more people to work on a document at the same time where the other people see the updates as they occur.

Task-centered User Interface - An interface where users do not have to adapt to the organization of the computer. That is, the user does not need to manipulate a set of applications to compete a task. The user can perform a task in a natural way that is analogous to the way he does things in the real world.

Vendor-independent database access - The ability to always request information from a database in the same format regardless of what vendor designed the database.

References

Meyer, Bertrand, Object Success, Prentice Hall, 1995.
Cotter, Sean and Potel, Mike, Inside Taligent Technology , Addison-Wesley Publishing Company, 1995.

The SOM Solution

Object technology has the potential to revolutionize the computer world. Before this will happen, the software industry must eliminate the hurdles that keep us from fully reaping the benefits of object technology today. Two of these roadblocks:

  • The steep, initial learning curve associated with object-oriented design
  • The integration of component software with legacy applications

can and will be overcome with time. The other hurdles are more complicated and need more than just time; they require a sophisticated technical solution.

To gain the full benefits of reusability, objects need to be reusable everywhere. If a programmer wants to reuse an object, he shouldn't have to worry about what language was used to develop that object. This is not the case today. If a programmer wants to use a class library that wasn't created in the language he is using, he needs to buy the class library source code and recompile it in his preferred language. If he does use a few of the classes from this library, he will need to recompile his application every time one of his selected classes changes.

This situation occurs because several popular object-oriented programming languages, such as C++, possess a quality known as static binding. Static binding occurs when a program determines what code to run to satisfy a request before the request is actually made. That is, the request is made at run time and the code was determined at compile time. Binding is a result of polymorphism. That is, if an object receives a request from another object (the client), the method that the receiver object uses to satisfy the client depends on what the client is. So any object-oriented language that determines that code at compile time rather than at execution or run time has the problem of static binding. Static binding limits reusability because the resulting compiled code predetermines how everything will work. Consequently, if you make a change in a class definition, you will need to recompile every client of that class and all of its sub-classes.

The last difficult hurdle to overcome is that solutions run on a wide array of operating system platforms and on heterogeneous networks. A reusable component needs to be interoperable and portable.

IBM has devised the System Object Model (SOM) as a solution to these hurdles. SOM is a platform and language independent object-oriented technology. It can be considered a technology for packaging binary class libraries, a toolkit for building classes, and a runtime environment that provides basic functionality to all SOM objects. SOM does not replace object-oriented programming languages but rather supports them by letting applications use object-oriented dynamic link libraries (DLL).

To let objects implemented in different languages communicate with each other, SOM provides a tool known as the Interface Definition Language (IDL)*. Using IDL, programmers create a language neutral interface for their objects, which does not affect how the object works, but makes the object accessible to all other objects that understand IDL. Therefore a SOM-enabled object can be written in any programming language (not necessarily an object-oriented one) as long as it has an interface written in IDL. In essence, SOM provides a mechanism to separate an object's interface from its implementation. (This is true encapsulation.)

SOM addresses the problems associated with static binding by allowing objects to bind with their clients dynamically at execution time. This means that the code used to satisfy a client request is not predetermined before the code is executed. If you need to change a class or an entire class library, the changes will take effect only at execution time. Therefore, you no longer need to recompile any client or sub-class code associated with the changed classes.

To create the dynamic binding, SOM has let classes themselves be objects. These classes then obtain their properties and characteristics from a metaclass. Therefore, in SOM, a class is to a metaclass what an object is to a class. By considering classes as objects, information about the classes can be updated at runtime. This capability allows a SOM class library to be distributed as a dynamic link library.

SOM attacks the issues of portability and interoperability by complying with the Common Object Request Broker Architecture (CORBA) specifications. CORBA provides an infrastructure that allows objects to communicate, independent of their platforms, languages or implementation techniques. Objects make and receive requests with each other via an Object Request Broker (ORB). Using the ORB mechanism, objects can interoperate on different machines in heterogeneous distributed environments. The ORB seamlessly connects objects from multiple systems.

  • IDL is an Object Management Group defined

language. SOM clearly provides the means for the widespread exploitation of object technology. OS/2's Workplace Shell was only the first implementation of SOM technology, IBM is now implementing SOM across all its operating systems: AIX, OS/400, and MVS. SOM also provides the backbone technology for OpenDoc. Other leading vendors are also embracing SOM. By addressing the inhibitors, SOM truly can enable the software industry for widespread implementation of object technology.

The OpenDoc Revolution

by Emily Vander Veer

It's not an exaggeration to say that OpenDoc is poised to revolutionize the way software is developed and used.

The software industry is approaching critical mass. While there are still a few small companies churning out applications, the market is controlled by huge application suite vendors whose products have grown exponentially in size and complexity over the last few years. These large vendors have suffered a dramatic increase in maintenance cost and schedule slips as a result of this growth. Small shops, on the other hand, face being squeezed out of the market altogether unless they can afford to compete with the feature-rich applications dominating the market. And because application code is tied so closely to operating system software, developers must constantly rewrite their applications to keep up with version levels of the de facto operating system standard. To keep up, developers are often forced to endure pre-Industrial Revolution working conditions (60 to 100-hour work weeks aren't uncommon in this industry). Of course, cumulative stress and fatigue generally negatively affect product quality. Consequently, consumers have become resigned to program crashes, system lockup, data loss, and software incompatibility, especially from first releases of shrink-wrapped applications.

In no other industry does the consumer, simply by opening the package, implicitly accept liability for the purchased item not only failing to work as advertised, but also destroying other assets. The reason consumers accept these terms reminds me of a story related to me by a good friend. When my friend asked a car dealer why the small, simple part he was purchasing cost over $80, the dealer replied, "because your car won't run without it." Like my friend, software consumers don't have much in the way of choices. All commercial software is developed and marketed the same way, using the same methods and subject to the same limitations.

Why is the industry in this state? It's not as though software developers are evil, or even incompetent. It's just that up until this point in history, there have been no standards, no scientific or even manufacturing principles brought into play for software construction. Software development is very much an art practiced by people of differing talents and managed, for the most part, by people who may not understand the technological issues facing their employees on a daily basis.

Gradually, this ad-hoc approach to designing, implementing, maintaining, and managing software projects is becoming infeasible. As the saying goes, there are only so many times you can patch code before you end up with all patches and no code. And unless they come up with a soft drink that contains substantially more caffeine than Jolt Cola, there are only so many hours of productive programming labor you can wring from developers.

Enter OpenDoc, an object-oriented component software architecture that finally enables both developers and users to realize the benefits of object-oriented technology. OpenDoc, promoted by the vendor-neutral industry consortium CI Labs, was designed by several leaders in the software industry -- IBM, Apple, Novell/Word Perfect, and Lotus -- to provide a cross-platform component software development environment. The current platforms targeted for release are the Macintosh, OS/2, Windows, and AIX. Since CILabs' mission includes making the source code for OpenDoc generally available, anyone interested in porting OpenDoc to additional platforms can do so.

But what exactly do we mean by "component software?" A classic example often used to illustrate the value of component software is the purchase of a stereo system. As a consumer who wants to buy a first-rate system, you will likely go from store to store searching for specific components that fit your needs: the CD player that provides the features you're most likely to use, the best quality speakers, etc. It never occurs to you, when you arrive home with your purchases, that these components won't fit together and work as an integrated whole. You plug them in and you've got a functioning sound system. It doesn't matter that each was produced by a different manufacturer.

Now apply this paradigm to software. Say you've got a personal computer running OS/2 Warp, and being a musician, you want to purchase Transcript-O-Rama, a program that allows you to create and modify music transcriptions electronically. Before you buy it, however, you need to check whether or not there's a version that runs on your system. If there's not, you have two choices: you can buy a copy of the system that does support Transcript-O-Rama, or go without.

Component software offers developers and system integrators the simple connectability available to the buyers in our stereo example. If you want to build an accounts receivables system, you can include the definitive accounting components from a vendor, customize them if necessary, and assemble them with any other company-specific components you need. Besides connectability, component software also implies cross-platform capability. It doesn't matter that your stereo receiver wasn't designed specifically to work with your CD player; the same should be true of your application and operating system software. Since today's systems often include multiple machines on multiple platforms, software components must be distributable as well as cross-platform. these characteristics define the component software model.

OpenDoc, through standard interfaces and an overall architecture, provides much of the base function common to most applications: a way to make data persistent, a way to present information to the user, and a way to process inter-application communications. Most of this common function can be accessed by developers through a cross-platform application programming interface (API).

What this means is that developers no longer have to provide all the code necessary to handle persistence, display, and interaction. All they need to do is call the appropriate OpenDoc API's. In addition, OpenDoc is based on IBM's SOMObjects. SOMObjects is an object request broker (ORB) that is compliant with an industry standard specification called CORBA (Common Object Request Broker Architecture). SOMObjects provides all the code necessary to ensure that object components interact dependably, even when distributed on heterogeneous systems. More than anything else, it is this capability that makes developing true component software with OpenDoc a practical reality.

Customer solutions, traditionally called "applications," will be composed of one or more OpenDoc components. Either developers or system integrators can assemble components; and in simple cases, end users themselves will be able to construct applications from various components. Consider the example of a travel expense authorization form. This kind of application is used in almost every industry, but the requirements are a little different from industry to industry and from company to company. Custom travel applications can be assembled by using off-the-shelf parts such as scanning and imaging (to view travel receipts), word processing (for notes), spreadsheet (for tabulating amounts), database (to extract employee information based on employee's name), handwritten signature (to authorize the travel form), speech enabling (to allow users to use voice dictation instead of a keyboard to input into the form), and communication (to transmit data to an off-site check disbursement facility). Since this type of application generally involves non-trivial business rules, it would likely be assembled by a developer or system integrator.

On the other hand, for simple applications where no complex logic is needed to describe component interaction, an end user will be able to perform the assembly with no need to understand complex programming or macro languages. Imagine your boss requests a report assessing the marketability of your department's newly prototyped Super Widget. Since the bulk of your report will be text, you select a word processing component as the "base" component of your report. Into this base you drop a picture component, so that you can insert a schematic of the Super Widget into your report. Finally, you decide to add a soundbite of favorable focus group reaction, so you also drop in an audio component. After you've composed your report, you drop the entire thing into a electronic mail component and mail it to your boss. Your boss, on another system in another city, receives the report as one integrated document containing the text, the picture, and the audio clip.

One of OpenDoc's more powerful abilities is the ability to create an extension to OpenDoc itself. An OpenDoc extension makes function available to every component in an OpenDoc application. Take, for example, a spell-checking component. Imagine being able to use the same spell-checking utility for word processing, for text on charts and spreadsheets, or for any other text-based component. Another example of an OpenDoc extension currently being developed for OS/2 is a speech extension. With a speech extension, any OpenDoc component can be speech enabled. This means any OpenDoc component will be able to accept dictation input as well as keyboard and mouse input, for displaying text or for menu navigation.

OpenDoc finally delivers the many benefits ascribed to the component software model. One of the benefits for developers is that they get to concentrate on their area of expertise. Instead of having to write descriptions and logic for yet another basic manufacturing application (which is one of those tasks which is only interesting the first time you do it), you can build on someone else's base and contribute your unique added value. This shortens your time to market and decreases maintenance costs, since the total code you have to write is greatly reduced. Developers who provide these base business, technical, and scientific objects will have a huge market for their products. And end users also benefit: They should see shorter development times, because a substantial portion of the systems they will be purchasing will be assembled rather than hand-crafted. They should also see a better quality product, because the less new code that goes into an application, the less chance there is to introduce bugs.

Widespread adoption of the component software model is key to the software industry's long-term viability. Through standardization, using the manufacturing techniques made famous by Henry Ford, software development can be made simpler, cheaper, and more manageable. OpenDoc provides the infrastructure necessary to bring the promise of this model to reality and subsequently revolutionize the industry. Because OpenDoc encourages task-centric solutions, users can -- like the buyers in our stereo system example -- purchase or create systems assembled from reliable components that help them do their jobs. Their software applications will adapt to fit the work at hand, rather than the other way around. And after all, isn't the real purpose of software to make our jobs -- and lives -- easier and more productive?

What the OpenDoc Revolution Means to You

by Maxine Senn-Yuen

Today, the software industry is at a turning point. As computers become a more integral part of our lives, our demands on computer technology are changing. Modern computer users now want software that will help solve their problems, not complicate their lives. They no longer want to contend with conflicting standards or compatibility issues. They want software that will give them the precise set of functions they need in simple, inexpensive and easy-to-use packages. Most of all, users want more software choices, so they can find the best solution for their particular needs.

At the same time developers face their own set of concerns. Corporate developers are strained by the effort to develop programs for more than one platform, and by the constantly changing and expanding needs of users. Commercial developers are challenged by the increasingly costly process of developing feature-rich software, and the diminished profitability of their products. OpenDoc is the industry's answer to the concerns of both users and developers. Before examining it in detail, here's a little background on the software evolution that led up to OpenDoc:

About four years ago, Microsoft introduced Object Linking and Embedding (OLE), a technology that allows applications to share data in a way more dynamic than a simple "cut and paste."Before OLE, PC users who wished to use data from Microsoft Excel in a Word document, for example, had to export their spreadsheet in text format and then insert the data as a text table into their word processing documents. Not only was this process cumbersome, but it also left users with just a static snapshot of their data. OLE greatly improved this process by allowing the spreadsheet data, including formulas and functions, to be edited and managed by Excel. In addition, OLE allowed you to keep your data up-to-date by linking the spreadsheet "object" in the Word document to its source. Changes made to the original Excel spreadsheet were automatically reflected in the Word document. Although this was a vast improvement over "cut and paste" techniques, OLE still remains a fairly primitive technology which isn't truly object-oriented or network enabled. However, OLE was a small step in the direction of OpenDoc because it allowed you to build your document out of pieces of different applications - a Word piece here, an Excel piece there, and so on.

By the time Microsoft unveiled OLE, Apple Computer Company had already developed several technologies to build documents out of pieces, which it collectively called document-centric computing. Apple had also developed an advanced data storage technology, named Bento after those very compartmentalized Japanese lunchboxes, and Open Scripting Architecture (OSA), a technology which defines how documents and components communicate with each other. Apple was interested in contributing these technologies toward developing industry-wide standards for document preparation. To that end, Apple enlisted the help of WordPerfect Corporation, now Novell, to move its technologies to the Windows platform, and write code (called ComponentGlue) to enable the "components" or "parts" created with Apple's technologies to work with OLE objects.

The Apple-WordPerfect collaboration was missing one crucial piece -an object model accepted on an industry-wide basis. The object model is the underlying "plumbing" that defines how objects interact with each other, no matter what tools, language or platform are used to develop them. The industry standard for object models is Common Object Request Broker Architecture (CORBA), which was set by the Object Management Group (http://www.omg.org), an industry standards committee. At the time Apple and WordPerfect formed their alliance, IBM had just implemented Systems Object Model (SOM) version 2.0, one of the first CORBA compliant object models. IBM decided to donate SOM technologies to complete the foundation necessary for OpenDoc. Together, Apple's, IBM's and Novell's technologies form the basis for OpenDoc.

What is OpenDoc?

OpenDoc is an industry standard for software integration. It enables the creation of distributed, cross-platform component software. In other words, OpenDoc component applications are deliverable across networks and OS/2, Windows, Macintosh and UNIX platforms. Unlike Microsoft's proprietary OLE, OpenDoc is based on open industry standards (CORBA) that virtually every major industry vendor supports.

What OpenDoc Means to End-users

OpenDoc's most obvious benefit to end-users is enhanced usability. OpenDoc provides users with a more natural and flexible way to create compound documents combining information of various types. In OpenDoc parlance, the term document includes virtually all applications and almost anything that a computer can output. OpenDoc documents can be alive, not static - animation, background music and a dynamically changing content can all be part of an OpenDoc document. OpenDoc components or parts will not be delivered to end-users as traditional applications. Instead, users will be given templates (graphically represented by "sticky pads" on the desktop) that can be used to assemble documents. To add a certain type of part to a document, the user will simply have to drag the corresponding template for that type of part into the document. So your desktop might have templates representing types such as text, graphics, audio, video, charts, and whatever other types you need.

Parts can also be more complex, such as a part for a monthly report that combines smaller text, spreadsheet, and chart parts. Unlike most OLE objects, OpenDoc components can contain other components or be put in other components, giving the user the unlimited ability to customize the document to suit her changing needs. Changes to parts can be made in place, without leaving the document and without having to stop and think about which application created the original. This technique of creating documents puts the user's focus back on the content and layout of the document, and away from the intricacies of using a particular application.

Another benefit of this approach is that users can purchase only the components they need. Today's software market is dominated by pre-packaged, shrinkwrapped, full-featured applications from a handful of software vendors. Furthermore, these monolithic applications are not expandable or flexible. End users pay for functions they will never use, while being limited by the capabilities built into the application. On the other hand, users who purchase OpenDoc component software pay only for those functions they want because the components perform very specific functions. Users can assemble those small components in creative ways to solve their unique problems, instead of relying on huge, inflexible, one-size-fits-all programs. Users can also mix-and-match components from different vendors without any concerns about compatibility.

OpenDoc will allow users to purchase custom software solutions now available only to those who have the expertise or money to create them internally. OpenDoc components are re-usable and scriptable, which will encourage developers to create specialized solutions to very specific problems quickly with minimal incremental development costs. For example, an invoice generation package can easily be custom tailored for the mail order industry, and further tailored for mail order clothing companies, mail order software companies and so on. OpenDoc also eliminates the need to replace an application in order to upgrade its functions. New or improved functions can be added as simple, focused parts, preventing the premature obsolescence of software. OpenDoc relieves the headaches and spiraling costs of endless software upgrades.

More sophisticated users will enjoy the flexibility OpenDoc's powerful OSA architecture gives them. OSA allows you to tie together functions using macro-like scripts. If you're used to using spreadsheet or word processing macros today, then you'll appreciate OpenDoc's record-playback facility which gives you the ability to automate repetitive tasks. For instance, let's say you need to complete a form at the end of every business day using information from a wide variety of sources and media. OSA allows you to record that operation once, name it, and run it again whenever you like. And if other users in your organization need to perform similar tedious tasks, they can simply edit the script for your operation (written in language close to plain English) to adapt it to their tasks.

Of course, because OpenDoc is a cross-platform standard, large organizations with heterogeneous networks won't have to work at integrating OpenDoc components throughout their organization. All kinds of information and documents will be able to flow freely to all users, regardless of their networking environment. OpenDoc will make it easier to for workgroups and individuals on a network to collaborate.

What OpenDoc Means To Developers OpenDoc is a simple, open standard that greatly eases the development process. A typical OpenDoc application has far fewer functions than a comparable OLE application. In addition, because of their relative simplicity, OpenDoc components are easier to debug, maintain and document than other applications. OpenDoc also allows developers to respond more quickly to users' changing needs. Its components are small and focused, resulting in faster development cycles. Developers can update their OpenDoc products without having to revise a huge application.

OpenDoc also allows smaller ISVs to focus on their particular area of specialty. For example, instead of creating a complete full-featured word processor, an ISV could create just a single-function equation editor component. This will open new worlds of opportunity for developers to create custom solutions for specific tasks. And OpenDoc documents are scriptable, which allows developers, integrators and repackagers to provide unique solutions to users by gluing existing OpenDoc parts together with a script language such as Object REXX.

All developers are guaranteed access to OpenDoc's nonproprietary technology. This helps to level the playing field between smaller ISVs and the big players who dominate the industry today. At the same time, OpenDoc expands the market for their products by allowing them to deliver their solutions across platforms and protocols. Developers don't need to choose between OpenDoc and OLE because OpenDoc offers a superset of Microsoft OLE's functionality; developers can write for OpenDoc while maintaining compatibility with OLE.

Where Do We Go From Here?

OpenDoc technologies are available to the industry through Component Integration Laboratories (CI Labs), a neutral industry consortium founded by Apple Computer, IBM, Novell, Oracle, Taligent (http://www.taligent.com) and others. CI Labs (http://www.cilabs.org) has the rights to OpenDoc, SOM and related technologies which it then licenses back, royalty-free, to the industry. CI Labs is responsible for certifying OpenDoc components as well as reference implementations of OpenDoc.

IBM has committed to shipping OpenDoc on AIX and OS/2 platforms. OpenDoc for OS/2 Early Experience development kits are now available through the Developer Connection for OS/2 (http://www.austin.ibm.com/developer/programs /DevCon/OS2/dcOS2.html) or by sending e-mail to opendoc@austin.ibm.com. The OpenDoc "Early Experience Package" for AIX is also available now, with general availability of the final product currently planned for October 1996. OpenDoc version 1.0 for the Apple Macintosh will be final and available by Fall Comdex, November 13.

For more information on OpenDoc and IBM object technology visit http://www.software.ibm.com/objects. For more information on object technology for solution providers, go to http://www.austin.ibm.com/developer/objects.

OpenDoc: Coming Soon to a Desktop Near You

by Maxine Senn-Yuen

IBM and the other companies in the CI Labs consortium are not the only ones committed to bringing you OpenDoc components as soon as possible. Many ISVs are taking advantage of the early experience OpenDoc toolkits to get a head start.

Why are so many ISVs jumping on the OpenDoc bandwagon? Their reasons vary. Some want to exploit the technological advantages of the OpenDoc framework. Others want to tap the huge potential market for OpenDoc cross-platform parts.

"The potential of component-based software is almost limitless," says Carla Hanzilk, Vice President of Sundial Systems Corporation, a personal productivity software vendor which has announced plans to produce OpenDoc parts from its award-winning applications. "This technology (OpenDoc) puts the power of design in our clients' hands," adds Chuck Brown, systems manager of DST, another vendor which has publicly announced support for OpenDoc. "With OpenDoc, our clients will be able to design the organization, presentation, and format of their desktop applications."

"If you were to examine the documents that your organization uses, every element has been computerized except one - the handwritten signature," says Jeremy Newman, Managing Director of Peripheral Vision. "OpenDoc offers an ideal framework for PenOp (Peripheral's handwritten signature recognition/verification software), and allows the potential savings in costs and delays to be realized by users with little (if any) programming effort."

If you're planning to attend Fall Comdex '95, you can look forward to checking out some OpenDoc components for yourself. The following companies have committed to shipping OpenDoc parts and will be showing them at Comdex:

  • Cirrus Technology is developing OpenDoc-enabled image manipulation parts that perform scanning, viewing and storage functions.
  • Voice Pilot is working on speech-enabled calendar and memo pad components.
  • Peripheral Vision is working on a handwritten signature recognition part.
  • Athena Design is creating a spreadsheet part and will preview a prototype application that exploits the components being delivered by the other companies while presenting a uniform application to the user.

Several other companies have previously created OpenDoc prototypes. These include:

  • DST who developed parts for workflow applications,
  • Footprint Software who created a charting part and,
  • TrueSpectra who worked on image processing parts.

As time goes on and the next release of OS/2 Warp (the one that contains OpenDoc) gets closer, more and more developers will be creating OpenDoc components. Eventually, you'll find an OpenDoc part on a desktop near you ... maybe even your own.

WARPED ETC.

Extend COBOL to Your OS/2 Workstation

IBM VisualAge for COBOL for OS/2 revitalizes your COBOL applications by extending COBOL to your OS/2 workstation

In addition to bringing COBOL to your OS/2 desktop, IBM VisualAge for COBOL for OS/2:

  • Offers object-oriented language extensions.
  • Extends COBOL to a client/server environment.
  • Increases programmer productivity.
  • Saves you time and money by taking advantage of the current skill base in your organization and preserving your current data.
  • Increases ease-of-use with a variety of development tools.

IBM VisualAge for COBOL for OS/2 is a cost-effective solution that offers the following enhancements to COBOL.

Object-Oriented Language Extensions:

  • Allow COBOL programmers to create objects in a language they already know, eliminating a long learning curve.
  • Offer 32-bit implementation.
  • Provide direct-to-SOM implementation.

Client/Server Enablers:

  • Run COBOL programs on your OS/2 desktop, while your data remains on the host.
  • Easily access remote data from DB2, CICS, VSAM/SAM MVS files, and OS/400 Record Files. Work with MQSeries for OS/2 using MQSeries Three Tier for OS/2.
  • Comply with ISO and ANSI COBOL standards.

Improved Productivity and Ease-of-Use:

  • Easily take advantage of these COBOL enhancements with the help of a rich set of tools.

IBM VisualAge for COBOL for OS/2 is slated to become available in early November.

Watchdog PC Data Security for OS/2

Fischer International Systems has released its Watchdog PC Data Security for OS/2 version 2.11, and announced plans to support OS/2 Warp in December of 1995.

Fischer's Watchdog security solution is the result of a joint marketing and development effort with IBM to create a comprehensive, integrated security solution for OS/2. Fischer International and IBM combined their extensive knowledge and experience in data security and operating system design to deliver this security solution.

Watchdog for OS/2 offers a comprehensive solution for securing and managing mission critical corporate data. The newest Watchdog offering was developed using IBM's Security Enabling Services (SES) technology, which is built into OS/2.

Features in Watchdog for OS/2 include:

  • access control
  • data encryption
  • multiple level user permissions
  • audit trail facility
  • boot and format protection
  • single sign-on
  • and much more

"IBM's development of the SES APIs allowed our developers to fully integrate Watchdog into OS/2 and provide a comprehensive, reliable security solution," said Charles Klinker, Product Marketing Manager, Security Products for Fischer International. "Our joint development effort with IBM illustrates our long term commitment to provide secure electronic workplace solutions."

"Because of the speed and versatility of the operating system, we have standardized on OS/2 as our company direction," said Ralph Langham of U.S. Trust Corp. "The introduction of Watchdog for OS/2 has resolved our demand for comprehensive security and instilled the level of confidence we need. It's what I would expect from Fischer International."

Some organizations that have implemented versions of Fischer's security products include the IRS, the U.S. Treasury Department, Bell & Howell, and Home Savings of America. For additional information contact Fischer International Systems at 800-237-4510 or 941-643-1500.

Virtual Pascal for OS/2

fPrint UK Ltd has announced a new product, Virtual Pascal for OS/2, a 32-bit Pascal compiler compatible with Borland Pascal v7.0.

Virtual Pascal has been in development for more than two years, and development is now reaching its final stages. For developers who want to experience the product before shipment, scheduled for 1Q96, the company will conduct a limited Early Experience Program.

The feature set of the final shipping version of Virtual Pascal will probably include:

  • Full BP7 compatibility wherever possible
  • Integrated Development Environment very similar to BP7
  • Borland Turbo Vision compatible library
  • Borland OWL compatible library
  • Optional Object Pascal extension compatibility
  • Optional Borland Delphi compatibility
  • Full access to most of the OS/2 API
  • Fully integrated symbolic debugger, Turbo Debugger style

Please direct inquiries to fPrint at: Phone: +44 (0181) 563 2359 BBS: +44 (0181) 563 8624 CompuServe: 100327,2035 Internet: mertner@ibm.net


The new OS/2 Warp makes it easier to do more with your computer and your time, while other operating systems still keep you waiting. With OS/2 Warp, there's no need to wait any longer.

Order OS/2 Warp and LAN systems products today by contacting your IBM Authorized Reseller or call IBM directly.

Country            Telephone number
Argentina         	319-6666
Australia          62-1-132426
Austria            43-1-21145-2500
Bangladesh         880-2-231-022
Belgium            02-225-3333 
Brazil             0800-111426
Bulgaria           0035-92-731076 
Canada             1-800-465-7999 
Chile              800-203037 or 56-2-6332292 
China              86-10-437-6677
Croatia            0038-51-624500 
Czech Republic   	00422/67106111
Denmark            45-45-93-45-45 
Finland            358-0-4591
France             16-38-55-7055 
Germany            49-1003-317131 
Hong Kong          852-2825-7878
Hungary            00361/1654422 
India              91-80-526-8344 
Indonesia          62-21-523-8200
Italy              167-017001 
Korea              822-781-6114 
Malaysia           603-735-8828 
Netherlands        030-383773
New Zealand        0800-801-809
Paraguay           595-21-444094
Philippines        63-2-892-3026 
Poland             00482/6251010 
Portugal           1-7915900
Singapore          65-320-1234
Slovakia           00427-786-403
Slovenia           0038-661-1252-154
South Africa       0800-126126
Spain              900-100-400
Sri Lanka          941-440-810
Sweden             08793-1000
Switzerland        01436-7478
Taiwan             886-2-776-7658
Thailand           66-2-273-4286 
United Kingdom     01329-242728
United States      1-800-436-2255
Uruguay            598 2 923617

For Developers: The Developer Connection for OS/2 The Developer Connection Device Driver Kit (DDK) Order Numbers North and South America:

Brazil            	0800-111205
             		(The Developer Connection for OS/2)
                   (011) 866-3222
                   (fax - The Developer Connection for OS/2)
                   02-1-800-6120
                   (The Developer Connection DDK)
Canada             1-800-561-5293
Mexico             91-800-00639
Mexico City        627-2444
United States      1-800-6DEVCON
                	(633-8266)
                  	1-303-330-7655 (fax)

In Asia Pacific: The Developer Connection can be ordered in Asia/Pacific countries. Please ensure that you dial the international access code applicable to your country before the listed phone number. Note that 61 is the country code for Australia.

  61-2-354-7684 (phone)      61-2-354-7766 (fax)

In Europe: The Developer Connection can be ordered direct from the IBM Software and Publications Center (SPC) in Denmark if you live outside the US, Canada, Asia/Pacific, Brazil, or Mexico. Please ensure that you dial the international access code applicable to your country before dialing the appropriate phone number. This applies to both telephone and fax orders. Operators speaking the following languages are available. Note that 45 is the country code for Denmark.

   Dutch 		45-4-810-1400
   Italian  	45-4-810-1600
   English 	45-4-810-1500 
   Scandinavian  45-4-810-1300
   French 		45-4-810-1200
   Spanish  	45-4-810-1100
   German 		45-4-810-1000
               45-4-814-2207 (fax)

Electronic Support for Developers is provided through CompuServe, OS/2 BBS, and the Internet. Obtain technical support or use the forums to exchange messages, ideas, comments, or concerns with The Developer Connection for OS/2 team or other members.

The dedicated Developer Connection section on CompuServe is located in the IBM OS/2 Developer Forum 2. To obtain access to this section, please send a note with your subscription number to the Developer Connection Administrator at CompuServe user id 73423,2767. You will receive notification or access to the Developer Connection q section within 2 business days.

To access the forum, type GO OS2DF2 at the | prompt; then, select the Developer Connection section.

For CompuServe membership information, call one of the following numbers:

  From Germany: 			     0130 37 32
  From the United Kingdom: 	0800 289 378
  From other countries in Europe: (+44) (+272) (255 111)
  From the U.S.: 			1-800-524-3388
  From elsewhere: 			1-614-457-0802

Ask for Representative 239. You will receive a special introductory membership for IBM customers.

Staff Biographies

Jose De Jesus works as a contractor for IBM, debugging VDM and (soon) WorkPlace Shell applications. He is the author of "Borland Pascal With Objects 7.0," published by MIS:Press in 1993. He can be reached at 73141,317@compuserve.com.

Jeri Dube has been working for IBM for 12 years now. She is currently working as a Senior Marketing Support Rep, putting together communication vehicles for OS/2 Warp and LAN Server. She swears this is the best job she has had in a long time. Outside of IBM, Jeri spends time with her family, scuba diving, and practicing Yoga. Her favorite quote is: " Humanity has advanced, when it has advanced not by being sober, cautious and responsible but by being playful, rebellious and immature."Tom Robbins, Still Life with Woodpecker. Contact Jeri at Internet:jdube@vnet.ibm.com.

Steve McNally develops promotions with Marketing Reps as the Editor for the IBM US Promotions and Price Actions Board. He spends his free time with his wife Kim and ten-month-old daughter, Olivia Hope, and tries to put in as much time as possible writing fiction of all shapes and sizes. A quote that came to mind while composing his bio was "It's like a sauna in here." Cosmo Kramer, in the sauna at a health club. He can be reached at smcnally@vnet.ibm.com

Maxine Senn-Yuen joined IBM's Worldwide Marketing Program as an Associate Program Administrator in 1995. Maxine is an incipient yuppie who enjoys golf and shopping at the Gap. She can be reached at msenn@vnet.ibm.com.

Collin Summers' company has been contracted by IBM to help in central Illinois with OS/2 LAN Server and all those other PC Software type stuff. Before IBM took up all his time, he did independent computer consulting in many areas, but focused on OS/2 work (Guess that's how he ended up working with IBM). Collin spends his free time, when there is some, tinkering around and looking for new and better ways to use computers. Of course, he only runs OS/2 and OS/2 LAN Server on his business' LAN. Collin is available at Internet: summers@vnet.ibm.com or 73422,3364@compuserve.com.

Emily Vander Veer is an Object Evangelist with IBM's Object Technology Enablement department. Prior to joining IBM in 1994, Emily worked with Andersen Consulting. She has over four years' experience with object-oriented systems. She has worked in design, implementation and consulting capacities using a variety of tools and platforms. Emily is familiar with OS/2, C++, SOMobjects, and OpenDoc.

Jerome Yuzyk graduated from the U of Alberta in 1984 with a B.Sc. Psychology, specializing in Human and Machine Vision. In 1993 he set out on his own, forming BRIDGE Scientific Services. He consulted to various large and small business in the Edmonton area. Being an OS/2 user since 1992 in the midst of a sea of ignorance and misinformation Jerome started CAOS/2: Central Alberta OS/2 Users Group in August 1993. The group has grown to 100+ members since then. In October of 1994 he joined IBM Canada as a Retail Marketing Specialist, travelling the prairies talking to retailers, consultants and user groups about OS/2 Warp and OS/2 products in general. He also just started teaching OS/2 courses for IBM Education Services. When he's not doing any of that he's a hobby gardener and amateur landscape designer. And when not doing *that*, he takes apart various rooms in his house and (sometimes) puts them back together again. Jerome can be reached at Internet: jerome@supernet.ab.ca.


SURVEY

We want to produce a quality newsletter that meets your needs. Please take a few minutes to answer the following questions and send your responses to:

  • FAX: 407-982-8888
  • INTERNET ID: JDUBE @ VNET.IBM.COM
  • MAIL: Jeri Dube
    IBM Personal Software Products
    1000 51st Street
    Boca Raton, Fl 334
  • IBM VNET: BCRVM1(WARPWIRE)
1.  What other information would you like to see published in this newsletter?
________________________________________________________________
_________________________________________________________________

2.  Is the length of the newsletter: _____ Too short _____ Too long  _____ Just right

3.   Does this newsletter improve your product knowledge of OS/2 Warp and LAN Systems products?
 	_____ Yes   _____ No

4.  Do you currently have an OS/2 Warp or LAN systems product installed?
	_____ Yes   _____ No

5.  Do you plan to have an OS/2 Warp or LAN systems product installed?
	_____ Yes   _____ No

6.  Optional

Name:
Address:
City, State, ZIP:
E-Mail Address:

COMMENTS: Please offer any ideas/suggestions to improve the newsletter.
_________________________________________________________________
_________________________________________________________________

Thank you for answering this survey. We make improvements based on what you tell us|

OS/2 WARP AND LAN SERVER CUSTOMER REFERENCE FORM

If you would like to share your experiences with OS/2 Warp or LAN Server, please fill out the following form and get it back to us. We are especially interested in entrepreneurs who use OS/2 Warp or LAN Server and people who use these products in unusual circumstances.

  • FAX: 407-982-8888
  • INTERNET ID: JDUBE @ VNET.IBM.COM
  • MAIL: Jeri Dube
    IBM Personal Software Products
    1000 51st Street
    Boca Raton, Fl 33434
GENERAL INFORMATION:

Name:
City:
State/Province:
Country:
Fax:
Email Address:
Street/P.O.Box:
City:
State/Province:	 
ZIP/Postal Code:

INDUSTRY:
____Communications ____Cross Industry ____Distribution
____Education ____Finance ____Government ____Health
____Insurance ____Manufacturing ____Petroleum ____Process
____Transportation ____Travel ____Utilities

SIZE:

Annual Revenue US$: ____< $5M ____$5 - 50M ____$51 - 100M
____$101 - 500M  ____$501 - 999M ____$1 - 10B ____> $10B

No. of Employees: ____Small <100 ____Medium 100-500 ____Large >500

No. of Students if College/University: ____<5000 ____5000 -10000 ____>10000

BACKGROUND:  (Briefly describe the business or situation where you used the products.)
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________


NEED:  (What problem/situation existed which caused you to seek 
a solution using OS/2 Warp and/or LAN Server?)
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________

DESCRIPTION OF SOLUTION:  (Please provide a detailed
description.  Describe any mission critical applications. For a
networking solution,  include a description of the network.)
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________

BENEFITS:  (Please describe business or personal benefits.)
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________