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

Jenny Szawlewicz's Report

Following are summaries of the presentations from the 8th International Rexx  Symposium, which was held in Heidelberg, Germany from April 22 - 24, 1997. The  summaries were written by Jenny Szawlewicz of IBM in Raleigh, NC.


Dave Martin -- IBM Raleigh, NC

Dave Martin of IBM Global Services spoke briefly about the the POP (Post Office Protocol) Server program that he wrote. Post Office Protocol defines a series of commands that a POP client may use to interact with a POP server. A POP server interacts with a mail client to deliver mail that has been received via TCP/IP (specifically via SMTP).

There are a number of POP mail clients available for just about every operating system that is available today. If you have an account with an ISP (Internet Service Provider) chances are very good that your mail is delivered to you from a POP server.

Dave's POP server program, OS2POPS V2, was written in OS/2 Rexx with VX-Rexx. Dave talked about the issues involved when writing an interrupt-driven, multithreaded application such as his server program.

Dave also stated that his program running on a 60MHz Pentium machine can handle 900 clients at the rate of 2 or 3 clients a second.

For information on the OS2POPS V2 program, see the OS2POPS web page.


Ingo Holder -- IBM Boeblingen, Germany

Ingo Holder of the IBM REXX Development group presented an Introduction to Object REXX Programming. This presentation first defined some basic Object Oriented terminology and concepts, including:

  • objects
  • classes
  • methods
  • encapsulation
  • polymorphism
  • inheritance.

Ingo then presented several Object REXX coding examples which illustrated the above concepts:

  • instantiate an object
  • create a class and create a method for objects of that class
  • override a built-in method provided by Object Rexx
  • inherit properties of a class by subclassing that class.

The presentation then briefly described a few of the collection classes provided by Object REXX: the Array, Bag, and List classes.

For more information on Object REXX, see the Object Rexx homepage

The sample programs and a Postscript version of the presentation are available from the above homepage.


Kurt Maerker -- IBM Boeblingen, Germany

Kurt Maerker of the IBM REXX Development group followed the Introduction to Object REXX Programming presentation with a discussion of Advanced Object REXX programming. This tutorial covered the following topics:

  • the Class method (useful in debugging large inheritance trees)
  • the Unknown method (useful in capturing undefined messages)
  • Attributes (used to give access to instance variables)
  • Class methods (methods executed for an entire class)
  • The use of Metaclasses (Class classes)
  • Multiple inheritance (inheriting from two or more classes)
  • Concurrency programming

Kurt then executed a few programs that demonstrated the concurrency features of Object REXX.

For more information on Object REXX, see the Object Rexx homepage

The sample programs and a Postscript version of the tutorial are available from the above homepage.


Mike Cowlishaw -- IBM Hursley, England

Mike Cowlishaw, IBM Fellow and author of Rexx, presented a NetRexx Update. This presentation was a follow-on to Mike's presentations on NetRexx at last year's Symposium.

NetRexx is a new version of Rexx that Mike has written for the Internet. It allows programmers to create applications and applets for the Java environment faster and more easily than by coding in Java. At this time, more than 15,000 people have downloaded the reference implementation of NetRexx.

At a glance, NetRexx is a blend of Rexx and Java for the Java Virtual Machine. NetRexx:

  • takes the syntax of Rexx
  • takes the object model of Java
  • takes Rexx decimal arithmetic
  • allows binary arithmetic when needed
  • automates type selection and declaration
  • removes historical quirks of Rexx.

The current implementation of NetRexx translates NetRexx to Java source code, which is then run through a Java compiler. NetRexx, like Java, produces a .class file which can then be run on a Java Virtual Machine. Any class written in Java can be used from NetRexx. Any class written in NetRexx can be used from Java.

Mike discussed some of the activities that are occurring with NetRexx:

  • VM Java will include NetRexx (other operating systems under discussion)
  • ITSO Redbook largely completed
  • BeanMachine expects to support NetRexx
  • working with VisualAge team to investigate the integration of NetRexx into the VisualAge family.

Finally, Mike mentioned that it took 12 years to get (classic) Rexx on 8 platforms. It took 3 weeks to get NetRexx on 8 platforms!

For more information on NetRexx, see Mike's NetRexx homepage


Chip Davis -- Aresti Systems Raleigh, NC

Chip Davis gave a talk entitled NetRexx for Dinosaurs (Rexx to NetRexx). His message was that NetRexx provides an easy entry to the hot new world of Java, especially for those who have yet to make the transition to object-oriented programming.

NetRexx leverages your Rexx experience to the extent that the thrust of Chip's talk was "What's the least I have to know to use it?"

After establishing his credentials as a mainframe dinosaur himself, Chip showed an example of a Java program and its NetRexx equivalent; the NetRexx code was smaller and clearer. This example was then used to indicate those areas where NetRexx differed from Classic Rexx.

In many cases, the differences were improvements to the language that had been requested by Rexx programmers for years. Where a change was required by Java or the O-O paradigm, it was implemented in a Rexx-like manner, that is, programmer-friendly and Rexx-consistent.

Chip concluded by encouraging Classic Rexx programmers to try NetRexx and explore the exciting new world of Java.


Simon Nash -- IBM Hursley, England

Simon Nash, of the IBM Centre for Java Technology Development and the author of Object REXX, spoke about CORBA, SOM, and where Java and NetRexx fit in a discussion of these standards.

SOM, IBM's System Object Model, is a language-neutral object model which complies with CORBA. CORBA (Common Object Request Broker Architecture) is a language-neutral standard which allows different vendors to develop objects to one standard. The go CORBA is to distribute objects on different platforms.

The current list of supported languages for SOM follows:

  • C and C++ (bindings)
  • Direct-to-SOM (DTS) C++
  • Smalltalk
  • Object Rexx

Simon talked about directions for SOM, such as the move towards complying with the CORBA 2.0 standard and cross-language object interoperability. The next version of SOM, which will run in parallel with the current version, will support the following:

  • ability of Java to use C++ objects
  • ability of C++ to use Java objects

Since NetRexx creates Java classes, NetRexx will also be supported by the next release of SOM.

After he spoke, Simon gave a "world premiere" demo of the new version of SOM.


Ingo Holder -- IBM Boeblingen, Germany

Ingo Holder of the IBM REXX Development group presented Software Development with Object REXX on Windows Platforms. Ingo introduced a new product, the Object REXX Development Edition, which will be available in late May. This product will allow developers to create Windows dialogs with Object REXX.

The Object REXX Development Edition will run on Windows 95 and Windows NT. It will include:

  • Object REXX
  • Interpreter
  • Online Documentation
  • Samples
  • IBM Object REXX Workbench
  • Tokenizer
  • REXX API Files
  • OODialog
  • Online Documentation
  • Samples and Tutorial
  • IBM Linker
  • IBM Resource Workshop

Some detail on a few of the above items:

  • The IBM Object REXX Workbench includes an environment for program editing, execution, and management, visual debugging, tools and help access, and template creation.
  • The Tokenizer translates a source program into an internal format and stores it in a file. This hides the source file and provides a performance gain in the startup process.
  • The REXX API files are necessary to interface with external C or C++ functions from within Object REXX and will allow the Object REXX interpreter to be called from another application (e.g. C or COBOL).
  • The IBM Resource Workshop provides a graphical interface to design dialog layouts. This interface provides visual components such as check box, radio button, entry line, list box, etc.

Ingo demonstrated the creation and execution of an OODialog application. The Object REXX Dialog Class Library is used in the creation of an OODialog application.

For more information, see the Object Rexx homepage


Mark Hessling -- QCOM Pty Ltd. Brisbane, Australia

Mark Hessling, author of THE, PDCurses, and Rexx/SQL, discussed and demonstrated a freeware package that he wrote, Rexx/SQL. This is a package of external functions for most Rexx implementations on Unix, OS/2 and Windows 95/NT. Rexx/SQL permits access to SQL databases. It permits multiple connections to multiple databases from multiple vendors in one program.

Rexx/SQL provides:

  • DML capability (e.g. select, insert, update, delete)
  • DDL capability (e.g. create table, drop table)

Supported databases include:

  • DB2/2 (OS/2)
  • Oracle (Unix, OS/2, Win95/NT)
  • mSQL (Unix, OS/2, Win 95/NT)
  • Sybase SQL AnyWhere (OS/2, Win95/NT)
  • Sybase System 11 (Unix, OS/2, Win95/NT)
  • Generic ODBC (Unix, Win95/NT)

For more information on Rexx/SQL, see Mark's homepage


Kurt Maerker -- IBM Boeblingen, Germany

Kurt Maerker of the IBM REXX Development group presented Netcentric Programming with Object REXX Using TCP/IP Sockets for Heterogeneous Systems Platforms.

This presentation discussed various capabilities of REXX to create TCP/IP client/server connections (through the use of stream sockets).


TCP/IP socket capabilities are provided in "procedural" REXX through the RxSocket interface, an external function package available as a dynamically loadable library RXSOCK which can be activated with:

  • Call RxFuncAdd "SockLoadFuncs","RXSOCK","SockLoadFuncs"
  • Call SockLoadFuncs

These TCP/IP socket capabilities are provided in Object REXX through an Object Oriented Sockets Framework which defines the tcpSocket Class for stream sockets being based on the RxSocket function API above.

Based on the tcpSocket class of the Sockets framework two frameworks are built, a Servers and a Clients framework, providing the base for the tcpServer and the tcpClient class. These were used to build sample client/server applications with increasing complexity.

Different types of client-to-server connections were discussed and demonstrated:

  • a simple mirror server, where the client sends a string to the server and receives the string back
  • a chat server, where multiple clients communicate to each other by means of a connection server.

For more information on TCP/IP socket programming with REXX, see theObject Rexx homepage

The frameworks, the sample programs, and a brief description are available from the above homepage.


Anders Christensen -- Norwegian University of Science and Technology Trondheim, Norway

Anders Christensen, the author of Regina (a Unix version of Rexx), spoke about The Problems of Automatic Translation between Rexx and Perl. This talk was based on Anders' experiences with a prototype for translation from Rexx to Perl.

Perl is more complex than Rexx, which means that translating from Perl to Rexx is far more difficult than vice versa. In fact, Anders contended that a true Perl-to-Rexx translation that handles all cases and programs is virtually impossible. A few features found in Perl that are difficult to translate to Rexx:

  • Use of special variables
  • Program which is split into multiple source files
  • Default numeric value of unset variables
  • Autoincrement and autodecrement

Since Perl is more complex than Rexx, it might be easier to automatically translate from Rexx to Perl. However, Anders spoke about several features of Rexx which are difficult to automatically translate to Perl:

  • Variables (including a discussion of unassigned and compound variables)
  • Handling of comparisons
  • Subroutine structure
  • Use of INTERPRET instruction
  • Evaluation of logic expressions

Anders spoke about several approaches that might be used to accomplish a translation from Rexx to Perl, but concluded that because of some of the above obstacles, none of the approaches would produce a realistic solution. Anders concluded that if you want to translate between Rexx and Perl, you should dig into the logic and semantics of the given program and rewrite it in the other language.


Peter Kunkel -- IBM Boeblingen, Germany

Peter Kunkel of the IBM REXX Development group presented News From the REXX Compiler and Run Time Library.

The REXX Compiler (which is available on MVS and VM) produces executable compiler output consisting of REXX Run Time Library calls. The REXX Run Time Library is the processor of the compiled REXX program, and the REXX Alternate Run Time Library is the interface to the REXX System Interpreter.

The REXX Compiler and Run Time Library provide:

  • significantly improved performance
  • protection of source code
  • improved productivity and quality

Enhancements and fixes available for the REXX Compiler and Run Time Library:

  • the RANDOM built-in function is corrected according to the SAA definition of REXX
  • a new compiler option, LIBLEVEL(n) is added, which determines which minimum Run Time Library level is needed to run the compiled code successfully
  • for MVS, the complete SYSIN concatenation is added to the compiler listing

The APARS which describe these enhancements are:

  • VM: PN83402
  • MVS: PN79373

There will also be a new format of the date built-in function to handle Y2000. It will soon be available and is addressed by the following APARs:

  • REXX Compiler VM: PQ01522
  • REXX Run Time Library VM: PQ03176
  • REXX Compiler MVS: PQ00082
  • REXX Run Time Library MVS: PQ00080

Enhancements planned in 1997:

  • enhance compiler performance when compiling nested levels within compound variables
  • improve error messages if the DCB parameters for the IEXEC are not accepted
  • issue a warning or informational message if an internal label name is identical to a REXX built-in function name
  • support sequence numbers for CMS

To contact the REXX Compiler and Run Time Library Change Team:

  • email: rexxcomp@vnet.ibm.com
  • ibmmail: degadu4d at ibmmail
  • retain: wtrexx,245
  • forum: rexxcomp


Rony Flatscher -- Vienna University of Business Administration and Economics Vienna, Austria

Rony Flatscher of the MIS Department, Vienna University of Business Administration and Economics, spoke about Utility Routines and Utility Classes for Object Rexx.

Rony spoke about several routines, classes, and methods that he has written for Object Rexx. A listing of some of Rony's examples follows:

 - get_answ.cmd                        get an auto-CR answer from CLI

 - routine_find_file.cmd               find a file along a path

 - routine_ok.cmd                      returns "*** not o.k. ! ***" if .false,
         ok()                           "o.k." else

 - routine_pp.cmd                      "cheap pretty print" (encloses strings
         pp()                             with brackets)

 - routine_pp_number.cmd               simple pp_number formatting

 - routine_strip_quote.cmd             simple strip/add quotes

 - routine_USify.cmd                   turn a character string into US
         USify()                        chars and underlines only

 - Is_Util.cmd                         Object Rexx test support         get_methods_FROM_is_util(),

 - nls_util.cmd                        NLS support (e.g. for sorting)
         ::CLASS NLS

 - sort_util.cmd              ÿÿ       sort utilities
         sort(), sortStem(),
         sortArray(), binFindArray(),

 - class_rel.cmd                ÿ      some subclasses of .Relation
         ::CLASS RelTable,
         ::CLASS RelBijective,
         ::CLASS RelBijectiveSet,
         ::CLASS RelDir

 - class_ref.cmd                     ÿ anchor/reference classes (allows
         ::CLASS anchor                 for forward referencing too)
         ::CLASS ref

 - sgmlEntity_util.cmd                 SGML-entity support; allows
         CPFile2SGMLEntity(),           definitions for CP-char  SGML-entity
         ::CLASS SGMLEntity

 - html_util.cmd                       utilities for HTML
         ::CLASS HTML_DOC,
         ::CLASS HTML_table,
         ::CLASS HTML_list,
         ::CLASS html.reference

Rony provided more detail on these routines and classes and spoke about some of the implementation issues.

Rony's code should be available on hobbes (OS/2 section), ftp.cdrom.com, and leo in Germany.


Jocelyn Paine -- Oxford University, Institute for Fiscal Studies, and KB7 London, England

Jocelyn Paine of Oxford University, Institute for Fiscal Studies, London, and KB7, spoke about Web-O-Matic/Rexx.

Web-O-Matic/Rexx (WOM), a tool that Jocelyn wrote, is a language, compiler, and run-time system which builds interactive Web applications without CGI programming. An author using WOM writes interactive pages in HTML extended with special tags. The WOM compiler translates the pages into Object Rexx class definitions, and the tags into references to other classes and their attributes. Each class knows how to display itself as HTML, and the class definitions can be instantiated and run by a server which will send the HTML back to a client. The WOM-created pages can interact with each other and update themselves -- these functions are controlled by Object Rexx code inserts.

At the Institute for Fiscal Studies, Web-O-Matic/Rexx is being used to create a Web application for teaching economics, called "Taxes and Benefits on the Web". Jocelyn demonstrated this during his talk, showing how the pages could perform functions such as dynamically updating frames and menus, connecting to DB2, and error-checking the user's input.

The motivation for Web-O-Matic/Rexx arose from two earlier interactive Web applications called "Be Your Own Chancellor" and "Budget 96". These were built using conventional CGI programming, and though very successful, showed how difficult it can become to use CGI in large applications. Web-O-Matic/Rexx is based on System Limit Programming, a new programming formalism for building systems of interacting objects -- here, these are Web pages and their components.

For information on Web-O-Matic/Rexx, see Jocelyn's Web homepage


Brian Marks -- Chair Rexx ANSI Working Group Hursley, England

Brian Marks spoke about the status of the ANSI standard for Rexx.

The process that leads to ANSI standards is effectively funded by the institutions, and sometimes individuals, that send people to meetings. The committee for Rexx standardization met several times a year from 1991 to 1994 to produce a draft. The period of public review and the period taken by the ANSI publications department has meant that the standard for Rexx formally appeared in 1996.

No implementations of the standard have been announced. However, innovative parts of the standard such as error messages with subcodes and date conversions have been implemented in products.

The committee continues to work, with a view to a second standard that would be object oriented. Currently, this entails examination of the components of Object REXX and NetRexx to classify parts which have no overlap, parts which can complement one another, and parts which can only be alternatives.

For more information on the ANSI standard for Rexx, see the Rexx ANSI homepage


Chip Davis -- Aresti Systems Raleigh, NC

Chip Davis spoke about new developments in the Rexx Language Association (RexxLA). He made several announcements and turned the floor over to a discussion of what members wanted from such an organization.

The following announcements were made:

  • RexxLA has moved to the Research Triangle Park in North Carolina. The new address is:

    POBox 14472
    RTP, NC 27709-4472
  • RexxLA now has its own domain name (rexxla.org) and website (www.rexxla.org).
  • There are three userids associated with the RexxLA domain:
    • info@rexxla.org - general information about Rexx and RexxLA
    • admin@rexxla.org members' comments, questions, and problems
    • webmaster@rexxla.org - webpage comments, questions, and submissions. Tom Brawn  (a former editor of the ANSI Standard for Rexx) has agreed to assume the duties of WebEditor.
  • RexxLA is in the process of filing for status as a non-profit corporation.
  • Once incorporated, RexxLA will be able to accept credit cards for membership dues, easing significantly the difficulty our international members face.
  • Thanks to the generosity of Aviar, Inc. (publishers of Object_Rexx_by_Example) RexxLA is able to accept credit cards in the interim. (Application forms were distributed, and a number of attendees took advantage of the opportunity.)
  • The dues have been reduced to $24, with applications received after Jan. 1 being half-price. Student memberships are half-price also. The membership year is from May 1, generally coinciding with the Symposium.

An informal discussion ensued, ranging over the following major topics:

  • the need for volunteers and members interested in holding an office
  • the structure of the website: open vs. members-only pages
  • the content of the webpages and how to elicit submissions from members
  • the importance of RexxLA remaining independent of any specific vendor, and continuing to sponsor the Rexx Symposium
  • the need for a way for members to order Rexx publications and articles not readily available in their locale

Chip closed with a request that everyone check out the webpage and contact him if interested in helping out.


Dave Renshaw -- IBM Hursley, England

Dave Renshaw of the IBM Centre for Java Technology Development gave an Overview of Java and JavaBeans.

Java, developed at Sun Microsystems, is:

  • a portable Virtual Machine (JVM) that executes Java byte-codes
  • a standard set of class libraries for every platform
  • an OO programming language, based on C++
  • a toolkit for Java programmers.

Java was designed to be small, portable, fast, and safe:

  • a simpler, safer dialect of C++
  • compiler does extensive checking and produces class files
  • the JVM interprets byte-codes safely (doesn't trust compiler)
  • class files can be dynamically loaded
  • programs are composed of small, distributable pieces.

With a Java-enabled Web browser, you can run Java applets in Web pages:

  • applets run anywhere, since Java is portable
  • simple uses include adding animation, sound
  • more complex examples allow user to interact
  • compiled code, not source, is transmitted over the net.

A JavaBean is a reusable software component that can be manipulated visually in a builder tool.

For more information, see the following Web homepages:


Dave Renshaw -- IBM Hursley, England

Dave Renshaw of the IBM Centre for Java Technology Development followed the Overview of Java and JavaBeans with Creating JavaBeans in Java and NetRexx.

A JavaBean is simply a Java class which conforms to particular design patterns. Dave presented code snippets in both Java and NetRexx to illustrate:

  • Bean constructors
    • a Bean must have a null constructor.
  • Event handling with Beans
    • event types are defined as groups in classes
    • events are raised by event sources
    • event notification is received by event Listeners
    • Listeners register with sources.
  • Properties
    • use a PropertyChangeSupport object to help notify others when properties change
    • define methods to allow others to register to receive property change events.

The "BeanInfo" class is an optional addition to any bean which:

  • defines the public interface of the JavaBean
  • properties
  • event sets
  • methods
  • can provide access to icons etc.

For more information, see the following Web homepages:


Max Marsiglietti -- PC Magazine Modena, Italy

Max Marsiglietti, who is a contributing writer for PC Magazine in Italy, talked about two extensions that he has written for NetRexx: RXFile and RXDbase.

RXFile is a bridge between classic Rexx/Object Rexx and NetRexx. It is file I/O freeware that can be used to do TCP/IP networking and IPC (Inter Process Communication).  A few examples of things that can be done with RXFile:

  • write a MacIntosh file on OS/2
  • write a Unix style file on OS/2
  • maintain separate read/write cursors
  • maintain multiple cursors.

RXDbase is a simple database class that allows you to work with ASCII-based, ISAM-indexed databases. It also comes with MaxBase, a graphical (AWT-based) application that manages databases and database contents. It is coded in NetRexx, so it doesn't have machine-specific code, and should run on every Java enabled platform (but tests have been done only on OS/2 and Win32).  RXDbase is available from Max's homepage (listed below).

MaxBase comes with applications which allow people to

  • publish their databases on an HTML page
  • give other people access to their data.

MaxBase/RXDbase is a product which is currently shipping and supported for two platforms; due to the productivity provided by NetRexx, Max was able to create these packages in a short period of time.

Max also briefly demo'd another tool that he is working on: Visual NetRexx for Java, which will be an IDE with a debugger and a class browser for the NetRexx language. Since Max is working with others on this tool, he didn't comment on the visual browser portion or on the projected availability.

For more information on RXFile, see the following Web homepage: