
       THE OS/2 WARP MONTHLY NEWSLETTER
http://www.austin.ibm.com/pspinfo/newsletters.html
         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.z
ip.  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: 
  0. by incorporating content directly from
     its source instead of manually
  0. by adding new content easily 
  0. 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/o
bject-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.)
_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________







