From: Mark Kovarski <kovarski@zooid.guild.org>
Subject: A look at 1992...
Organization: The Zoo of Ids
Date: Wed, 16 Dec 1992 22:02:10 GMT

Journal:   PC Magazine  Nov 10 1992 v11 n19 p93(1)
------------------------------------------------------------------------
Title:     The raging debate over OS/2.

Among the staff  at PC Magazine and at other  publications, there is a
mean-spirited  debate going  on over   the merits  of OS/2.  There are
basically  three groups  arguing. The  first consists  of staffers who
can't get OS/2  to run or even load. These  people are usually running
oddball  systems  or  borderline  minimum-configuration  computers.  I
include in this group the ones who do get it to run in, say, 5MB, then
complain about the performance.

The second group includes the OS/2  old-timers who have been using the
operating system since  Version 1.0. They have a  disdain for the rest
of the users, period.

Finally, there are the OS/2 newcomers,  who use it without comment for
day-to-day work. The last group  includes people like myself, who have
to explain to everyone why we disliked OS/2 for so long and now use it
day after day. The arrogant old-timers  keep pointing out that many of
the most beloved features "were there since Version 1.3!"

Well,  maybe OS/2,  Version 1.3,  was great.  I, like  so many others,
never really  bothered to try it.  Things were different in  the early
days of OS/2 hype than they are today. It's those differences that are
contributing toward a newfound life for OS/2.

Let's  go  over  the  differences  and  try  to  understand the social
mechanisms  that have  allowed OS/2   to quickly  sell over  a million
copies in today's world.

There are five  important changes that took place  between the various
releases  of  OS/2,  Version  1  and  Version  2.0.  Each  change  has
significantly affected the market.

1.  The price  of memory.  When OS/2  was announced  in 1987,  we were
beginning to see one of those weird memory shortages. By the time OS/2
was  ready to  ship, memory  was selling  for $400  a megabyte. What I
consider  a minimum  memory requirement  for OS/2  (to make it perform
with snap) is 16MB of RAM. That  used to cost $5,600! A little pricey.
In fact, it was ridiculous. Today, memory  can be had for as little as
$25 per megabyte, and 16MB of RAM  will cost as little as $400. That's
a big difference.

2. The  processor of choice and  the price of the  machines using that
processor. In 1987  there was no 486 machine, and  the fast 386 ran at
25 megahertz--and  it was expensive,  selling for up  to $10,000. This
situation has changed dramatically.

3. Compatibility with Windows 3.0 and DOS. OS/2's inclusion of Windows
compatibility means  users can run the  hot Windows applications. This
is a new feature. It also saves  the user money. The user doesn't need
to buy DOS and Windows.

4.  Proliferation of  utilities in  the DOS  world. Another attractive
aspect of OS/2 is that it  eliminates the need for extensive utilities
such  as memory  managers (and   books on  memory managers)  and other
pricey DOS extenders and enhancers.

5. The price of OS/2. When OS/2 was first discussed it was going to be
priced high,  at around $500. Who  wants to pay $500  for an operating
system? We  want it cheap or  free. IBM lowered the  price and made it
easy to obtain for as little as $49!

The other difference between then and  now is that Microsoft is out of
the picture as far as the  code is concerned. The product seems better
off, making me doubt Microsoft's sincerity in the first place.

There's a  trend to note in  the above list. The  one common aspect of
the changes  in the market  conditions is that  everything is oriented
toward more  power for less  money. Cheaper machines,  cheaper memory,
cheaper  operating system.  Suddenly, a  million copies  are sold.  As
usual,  the  users  send  the   same  message:  Desktop  computing  is
price-driven.     Will     the     big     companies    ever    learn?
------------------------------------------------------------------------

Journal:   PC Magazine  Nov 10 1992 v11 n19 p234(1)
------------------------------------------------------------------------
Title:     The OS/2 programming experience.

Programming for the  OS/2 2.0 Presentation Manager (PM)  is a lot like
programming for Windows, but many differences lie in the details.

Windows  was  first  released  in  1985,  and  when  IBM and Microsoft
designed the OS/2  Presentation Manager in 1987, they  drew a lot from
the earlier  environment. The windowing  and event-driven architecture
of Windows were merged with a graphics system developed at IBM.

Given  the opportunity  to redesign  Windows somewhat  (and guided  by
IBM's  Systems   Application  Architecture  rules   for  function-call
syntax),  the  two  companies  changed  all  of  the  Windows messages
function calls in various ways.

Programmers  familiar with  both environments  generally consider  the
OS/2 Presentation Manager API  (application programming interface) the
more  elegant  and  easier  to  understand.  Function-call  names  and
parameter  orderings are  more  consistent,  and windows  have clearer
relationships to  each other. (Unfortunately,  the differences between
the Windows API and  the OS/2 PM API have been a  thorn in the side of
programmers who wish to support both environments.)

Programmers working  with graphics can make  good use of the  OS/2 GPI
(Graphics Programming Interface), which is much more powerful than the
Windows GDI  (Graphics Device Interface). OS/2's  GPI supports complex
curves in the  form of Bezier splines, rotation  and skewing of images
using matrix transforms, and PostScript-like  "paths" that can be used
to create complex areas and clipping regions.

Beneath the Presentation Manager, OS/2  2.0 also contains an extensive
operating  system  kernel  that  adds   both  joy  and  grief  to  the
programmer's life.  Memory allocation is  simplified enormously thanks
to the 32-bit flat memory model. This is much better than dealing with
the 16-bit segmented memory model still found in Windows.

The  OS/2 kernel  also provides  for multithreading.  Programs can  be
split  into  multiple  threads  of  execution  that  run concurrently.
Generally, a  PM program has  a main thread  that contains its  window
procedures  for handling  messages; secondary  threads are  created to
carry out lengthy  processing jobs in the background.  When used well,
multithreading  gives the  user a  big benefit  in the  form of faster
programs  (no more  hourglass icon!).  But designing  and debugging  a
multithreaded application can be quite difficult for the programmer.

The support of  HPFS (High Performance File System)  under OS/2 2.0 is
another area that provides benefits for users: It lets the user assign
long  filenames. Programmers,  however, must  work to  make their OS/2
applications HPFS-aware. The old rules  for dealing with DOS filenames
are simply not adequate.

Although   the  Presentation   Manager  is   the  primary  application
environment of  OS/2, OS/2 doesn't restrict  the programmer to writing
for PM.  Programmers can write  character-mode applications that  make
use  of  a  healthy  collection  of  function  calls for accessing the
keyboard, mouse, and video display using IBM's REXX language. The REXX
interpreted  scripting  language  provides  a  powerful alternative to
batch files,  including string manipulation,  arithmetical operations,
flow control (loops and if-then-else  statements), and an interface to
OS/2 and the Presentation Manager.

New in version 2.0 is  OS/2's unique object-oriented programming (OOP)
facility: the System Object Model  (SOM). SOM lets you create reusable
objects  in procedural  languages like  C, COBOL,  or Fortran  without
having  to use  specialized object-oriented  languages such  as C++ or
Smalltalk. IBM  plans to make  SOM objects binary-compatible  with any
programming language.  At the present  time, however, SOM  can only be
used with IBM's C/Set 2 compiler for OS/2.

Using the SOM  script language, you can define  object classes, derive
new classes from  old ones, hide data and methods,  and so forth. Then
you  compile  the  script  to  produce  programs  in the host language
(currently C). The PM API has been extended to include Workplace Shell
calls, so you  can create objects that interface  directly with OS/2's
desktop.

Unfortunately, several factors make  OS/2 less attractive than Windows
to developers.  The first is  obviously OS/2's smaller  installed base
and an uncertainty about the  operating system's eventual success. The
second problem is a dearth of available development tools, though many
are on the way. Currently, only IBM has a 32-bit C compiler for OS/2.

While not  nearly as polished  or as  easy  to use as  DOS and Windows
offerings  from Borland,  Microsoft, and  Zortech, OS/2  C++ compilers
from Borland  and Zortech are on  the way. Gpf, Version  2.0, a 32-bit
visual development  tool for OS/2 2.0,  has just been released  by Gpf
Systems. And MultiScope's MultiScope OS/2 Debugger (a 1989 PC Magazine
Technical  Excellence Award  winner) will  be available  for OS/2  2.0
later  this year.  Only when  a broad  base of application development
tools are  available will new  applications for OS/2  really appear in
significant numbers.

Another factor  is reliability. While certainly  stabler than Windows,
OS/2  is difficult  to install,  and once  it has  been installed, the
Workplace  Shell  occasionally  crashes  with  more  or  less dramatic
effects.  Given  the  stresses  that  software  developers  put  on an
operating  system, it  will be  difficult to  ship applications if the
underlying  operating system  is buggy.  Nevertheless, OS/2's  elegant
environment  has the  promise to  be a  software developer's dream. It
will  be  largely  up  to  IBM  to  keep  that  dream  from becoming a
nightmare.
------------------------------------------------------------------------