We use cookies to identify each unique session and to enable state information between pages visited on this site. See Cookie Details for what we store. Accept Cookies
× RexxLA Home About RexxLA About Rexx Community Members Symposium

Contact Us

Melinda Varian's Report

Subject: REXX Symposium Report by Melinda Varian (Princeton)
Date: Tuesday, 26 May 1992 12:58:10 PST

Earlier this month, I attended the 3rd Annual Rexx Symposium.  I
found it to be really invigorating.  The 90 attendees included the
authors of most known Rexx implementations (which now number 17)
and many other Rexx heavies.  The air was filled with enthusiasm
and camaraderie and the sessions were most worthwhile.

One of the first speakers was the author of Personal Rexx, Charles Daney,
of Quercus Systems.  His topic was their new product WinREXX, a port
of Personal Rexx from the PC to MS-Windows.  Charles emphasized that
WinREXX provides an API (application programming interface) that is
completely compatible with the OS/2 Rexx API, so that applications can
be ported between the two.  Charles also established one of the major
themes of the Symposium, the advantages of using Rexx as a universal
macro/scripting language in other systems in the same way it already is
universal in CMS and the Commodore Amiga.

The WinREXX DLL (Dynamic Link Library) can be used to provide a macro
language for any Windows application, and Quercus's literature is
addressed primarily to application developers, pointing out to them
the advantages of using a well known, industry standard macro language
rather than writing their own.  (Later that day, speakers from Lotus and
Borland demonstrated versions of 1-2-3 and ObjectVision that used Rexx
for their macro language.)

One of the problems that must be addressed in providing Rexx for
Windows is that there is no console in the Windows environment.  The
Quercus implementation and another Rexx for Windows (WRexx from the
University of Waterloo) addressed this problem in the same way, by
creating a console window that appears only when it is needed, as
for example when the Rexx Trace instruction is used.  This seemed to
work quite well.

Waterloo's WRexx was demonstrated by one of its authors, Eric Giguere,
of Waterloo's Computer Systems Group.  Waterloo has consciously made
WRexx look much like Visual Basic on the outside, i.e., it is invoked
via a rather flashy GUI interface but, like Visual Basic, quickly gets
down to the user keying in a program with an editor.  (Waterloo has
selected as the WRexx icon a nice brown dog wearing a golden crown;
the dog wears a mortarboard for use with GRAD, their Graphical Rexx
Application Developer.)  Waterloo has made some interesting extensions
to Rexx, such as allowing Procedure Expose to expose variables between
external functions.

Giguere went on to describe how Waterloo is using WRexx within the
windowing environment to create and manipulate user interface objects
to interact with the user in standard GUI fashion.

Objects are manipulated from within Rexx using a set of functions;
for example, UICreate creates an object of a given class, UISet sets
property values for an object, and so forth.  The objects are created
hierarchically; a parent object affects the positioning and other
properties of a child object.

Objects generate an event string when an event, such as a click, occurs.
A Rexx program checks for pending events by calling the UIEvent function,
which returns the next event string.  This little program illustrates the
use of event strings:

   /* click.rex */

   f = UICreate('','Form','caption','Click Example')
   p = UICreate(f,'Pushbutton','caption',"You haven't pressed me!", ,
               'click','call FirstPress')
   e = UICreate(f,'Pushbutton','caption','Quit', ,
               'click','exit 0')

   do forever
      interpret UIEvent()
   end

   FirstPress:
      call UISet p,'caption','You pressed me once!'
      count = 1
      call UISet p,'click','call NextPress'
      return

   NextPress
      count = count + 1
      call UISet p,'caption','You pressed me' count 'times!'
      return

In this example a "form" (window) called "f" is created and given a
caption of "Click Example".  It has two child objects defined, both
pushbuttons, one titled "You haven't pressed me!" and the other titled
"Quit".  (The size, position, color, font, etc., for these objects
are all defaulted, although they could be specified explicitly.)  The
event string for the first button is the Rexx command "call FirstPress";
the event string for the other is the Rexx command "exit 0".

The "do forever" loop simply waits for events to occur.  When an event
(such as the user clicking on a pushbutton) does occur, the UIEvent
function returns the event string, which is then interpreted.  When the
FirstPress routine is invoked, it uses the UISet function to change both
the caption and the event string for the first pushbutton.  After that
button has been pushed once, subsequent clicks cause the NextPress
routine to be invoked, so after the button has been clicked on seven
times, window "f" looks like this:

                +---------------------------+
                |                           |
                |       Click Example       |
                |                           |
                | +-----------------------+ |
                | |You pressed me 7 times!| |
                | +-----------------------+ |
                | +-----------------------+ |
                | |         Quit          | |
                | +-----------------------+ |
                |                           |
                +---------------------------+

And when the user clicks on the "Quit" pushbutton, the UIEvent function
returns the "exit 0" event string, which is interpreted, causing the
application to terminate.

Thus, no language modifications were necessary to add GUI support to
Rexx, only clever use of the interpret function.  As you might imagine,
when the significance of this little "do forever" loop sank in there
were gasps and grins throughout the room.

Waterloo has decided that Rexx definitely works in a consoleless system,
so they intend to port WRexx to the Macintosh soon.

Giguere's paper (entitled "Programming with Objects: A REXX-based
Approach") is available in PostScript form by ftp from Waterloo (see
below).

IBM demonstrated its experimental object-oriented Rexx.  It still looks
good and interesting but no nearer getting out than when I first saw it
two or three years ago.  In one of his talks at the Symposium, Mike
Cowlishaw, the author of Rexx, commented that he isn't sure that anyone
has yet discovered the best way to do object-oriented Rexx.

Mike mentioned that his book "The REXX Language" has now sold more than
100,000 copies, which is said to make it the second best-selling book
about a computer language (after the K&R C book).  He mentioned this in
trying to estimate the number of Rexx users worldwide.  The number is
presumably somewhere between that and 10,000,000, which is the number
of people who have access to Rexx.

Another recurring theme was the question of C versus Rexx.  Two speakers
from an IBM lab in Ireland described their rescue of a software product
that had had serious performance problems.  A significant portion of the
performance improvements they achieved came from rewriting parts of the
product from C into Rexx!  (They attributed much of this gain to having
done away with the loading of the C runtime libary routines.)

On the other hand, another speaker demonstrated his Rexx-to-C converter,
called (of course) REXXTACY.

There were several sessions devoted to Rexx for UNIX.  Anders Christensen
of the University of Trondheim (Norway) described "Regina", his Rexx for
UNIX, which is written in ANSII C and is POSIX-compliant.  He has run it
on SUN, DECstation, Ultrix, SGI, HP, Cray, and others.

Alberto Villarica of Syracuse University described his as yet unnamed
Rexx for UNIX, which is written in C++ and which has so far been run
only on SPARCs.  (Villarica wrote his interpreter as a way of learning
Rexx -- he had just gotten himself an Amiga, so he needed to learn Rexx.
Since the symposium, he has started working on an oo-Rexx.)

Both of these interpreters are available with gnu licenses and are
ftp'able, the former from flipper.pvv.unit.no and the latter from
tony.cat.syr.edu.

Ed Spire, of the Workstation Group, discussed his company's recent
announcement that it will distribute Uni-REXX free-of-charge to
educational institutions and also talked about their view of the future
of Rexx in UNIX.  He explained that the version of Uni-REXX that they
will be giving to academia will be the executables only and that there
will be no provision for embedding it in application packages to be
distributed.

There was, of course, discussion of Perl throughout the Symposium.  As
the Rexx community learns Perl better, it becomes obvious that the two
languages each have advantages and disadvantages in comparison with the
other.  While both have the richness and elegance that gurus love to
wallow in, it is probably fair to say that Rexx has rather better
programming structures.  Certainly Rexx appears to have a considerable
advantage in the ease with which real end users master a subset that is
sufficient for their purposes; one seems to find a much higher proportion
of CMS, Amiga, and PC end users using Rexx than of UNIX users using Perl.

On the other hand, Rexx still has some real deficiencies in the Unix
environment.  The Workstation Group is currently trying to address some
of these.  Specifically, they want to build more UNIX-specific built-in
functions, add regular expression support, improve process management
and communication, add Curses and X support, and improve database access.
One especially pleasant result of the Symposium is that the Workstation
Group and the two implementers of the public domain UNIX Rexxes agreed
to work together to design UNIX-specific functions and to try to keep
programs portable between the three versions.

Toward the end of the Symposium, I did a brief presentation on CMS
Pipelines, emphasizing its features that fulfill wishlist items for Rexx,
such as passing arrays to an external routine and indexing through array
tails.  Bebo White, of SLAC, had very kindly prepared the audience for
me by stating in his Perl presentation on the first day that much of what
Perl can do better than Rexx can be achieved easily in Rexx combined with
CMS Pipelines.

There were many other presentations, including one on an MVS function
package and others on using Rexx with SQL, DB2, and CICS.  Rainer
Hauser, of IBM's Zurich Lab, described his REXXSOCK, which is very
similar to Arty Ecock's RXSOCKET, which we are using heavily here.

The best question asked during the Symposium:

   Mike Cowlishaw to the speakers who described the IBM and Systems
   Center Rexx compilers:  What feature of Rexx do you as compiler
   writers like least?

   Bernie Style, from Systems Center, answered that his least favorite
   feature was having the ability to put a comment in the middle of
   an exponentiation operator (i.e., */*comment*/*).  Walter Pachl, of
   IBM's Vienna Lab, said he'd better check that one as soon as he got
   home and that they'd been caught by a comment in the middle of an
   exactly equal operator (=/*comment*/=).

A meeting of ANSII Committee X3J18, which is creating a Rexx standard,
was held in conjunction with the Symposium.  Anyone who wishes to become
an official "interested party" for the Rexx standards process should
contact Neil Milstead, nfnm@wrkgrp.com.

Two new Rexx books were on display, both from McGraw-Hill:

  "The REXX Handbook", Gabriel Goldberg and Philip H. Smith, III, eds.,
  ISBN 0-07-023682-8.

  "Programming with REXX", Charles Daney, ISBN 0-07-015305-1.

I have copies of both of these books and recommend them highly.

The papers presented at the Symposium will be published in its
Proceedings, which should be available in August.  Anyone wishing
copies of the Proceedings from the first two Symposia can order them
from:

    National Technical Information Systems Service
    U.S. Department of Commerce
    5285 Port Royal Road
    Springfield, VA  22161

The order numbers are SLAC-368 (1990) and SLAC-379 (1991).

The Computer Systems Group at the University of Waterloo has set up an
ftp host, rexx.waterloo.ca, that will contain public domain Rexx goodies,
including the two PD Unix Rexx interpreters.  A few of the papers from
this year's Symposium are already available there.

Melinda Varian
Princeton University

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Originally placed on IBM servers with the permission of the author.)