In many ways, Unix and Linux provide a very friendly development environment for programmers. There's a large suite of system utilities that accomplish all sorts of things from sorting to cutting to joining. And all these utilities can be glued together with pipes, either ad-hoc on the command line or as part of shell script. While I've done a fair amount of shell programming, I'm not a big fan of either ksh or bash as scripting languages. The shell scripting languages are quite archaic, and I'd really prefer something more modern.
Many years ago, I learned to program in the EXEC-2 language, a scripting language used by IBM's VM/CMS operating system. EXEC-2 and the Unix shell languages share many of the same virtues and vices, and if you learned one you could easily understand the other. I liked the quick edit-test development cycle, the ability to directly interface with the operating system, the ability to interface directly with the system editor, the ability to create new system commands, and the clumsy but powerful control structures. You could do a lot of clever things in EXEC-2 or the shell; but it always felt a bit clumsy.
And then IBM introduced the rest of the world to REXX, included as the System Product Interpreter in VM/SP Release 3. Wow! Everything I loved about EXEC-2 or shell in a modern language that resembled PL/I or the data step of the
SAS system.
REXX was the brainchild of IBMer Mike Colishaw. Colishaw's
aims for REXX were to create a language that was easy to learn and easy to use, a language that was powerful enough for serious program development, a language that favored the REXX programmer over the REXX implementer. And he succeeded. REXX is an easy to learn, intrepreted language with nearly all the control structures found in PL/I. And, unlike the old EXEC-2 or ksh/bash scripting languages, there's a really strong correlation between syntax and semantics.
So, let's talk about REXX. We'll install Rexx on a Linux Ubuntu system, and we'll demonstrate a little Rexx code, and we'll conclude with some pointers to more information.
Starting off, I thought I'd check the Ubuntu Software Center. I couldn't find a version of REXX in the Ubuntu Software Center. But, googling "rexx site:packages.ubuntu.com" turned up at link at
http://packages.ubuntu.com/lucid/regina-rexx. Clicking the link gives us:
Perfect! We have a build for Ubuntu 12.04. We could download and install it, but let's let apt-get do the work for us. After su'ing to root, just run apt-get install regina-rexx:
Answer Y to continue, and in a few minutes, the Regina Rexx interpreter is installed on your system. And, voila, you're ready to run the traditional Hello World test:
Yup, the traditional Hello, World works. Even better, Rexx takes 22/7 and computes pi. Neither EXEC-2 nor the shell will do that so easily.
What does a short Rexx program look like? Our first example demonstrates an easy trick to make a Rexx program execute like any bash or ksh shell program in your $PATH. The program also demonstrates the Rexx parse instruction.
#!/usr/bin/rexx
/* This is a Rexx comment. The #! is used solely to make our
program execute like any ksh or bash script.
*/
parse arg first_name '('common_name')' last_name .
say 'First name: ' first_name
say 'Common name:' common_name
say 'Last name: ' last_name
exit 0
Shell programmers will recognize the very unRexx-like first line. For ksh or bash programs, the first line is a comment (#) followed by a bang (!) that points to the interpreter. This is usually /bin/bash or /bin/ksh. Luckily, we can put the pathname to our Rexx interpreter in the #! path, and it works the same. If you're not sure where the Rexx interpreter is installed, use the whereis command. Just remember to chmod +x the Rexx script, and then execute it. Here's a sample:
Two other noteworthy points in this program: the parse instruction and the exit command.
The
parse instruction will save you more time than almost any other feature of REXX.
Parse is extremely powerful, and it splits strings into variables better than almost any other programming language I can think of.
The
exit instruction returns success codes to the operating system. In Unix or Linux, you can check these code with the $? variable in your shell. If you execute a program from a REXX program, you can check the success code with the predefined
rc variable.
One more short program. From Robert Sedgewick's book
Algorithms, we'll translate the greatest common denominator program from Pascal to REXX. Here's the REXX code:
/* Example from R. Sedgewick's _Algorithms_ */
/* Find the greatest common divsor using */
/* Euclid's algorithm. */
trace r
arg x y
say gcd(x,y)
exit 0
/* Internal function */
gcd:procedure
arg u, v
if v = 0 then
return u
else
return gcd(v, u//v)
and here's the output, run on a Windows PC:
c:\> example.rexx 12 8
5 *-* arg x y
>>> "12"
>>> "8"
7 *-* say "The greatest common denominator of" x "and" y "is" gcd(x,y)
>V> "12"
>V> "8"
12 *-* gcd:
>V> "12"
>V> "8"
*-* procedure
13 *-* arg u, v
>>> "12"
>>> "8"
15 *-* if v = 0 then
>V> "8"
19 *-* return gcd(v, u//v)
12 *-* gcd:
>V> "8"
>V> "12"
>V> "8"
*-* procedure
13 *-* arg u, v
>>> "8"
>>> "4"
15 *-* if v = 0 then
>V> "4"
19 *-* return gcd(v, u//v)
12 *-* gcd:
>V> "4"
>V> "8"
>V> "4"
*-* procedure
13 *-* arg u, v
>>> "4"
>>> "0"
15 *-* if v = 0 then
>V> "0"
16 *-* return u
>V> "4"
The greatest common denominator of 12 and 8 is 4
9 *-* exit 0
From the top, a few new instructions. First, the
trace instruction:
trace r instructs REXX to display the variable assignments as it executes the code. The
arg instruction assigns the command line arguments to variables. The
say instruction writes to the console. The
procedure instruction starts a new procedure or function. GCD is a function because it has a
return statement. Notice that gcd is recursive, and that REXX traces all the recursion for us.
So far, we've talked about Classic Rexx, the ANSI standard REXX language as originally conceived by Cowlishaw. There are two other versions that are worth exploring. NetREXX is an alternative to Java, and runs on any system with a JVM. ooREXX is the open source version of IBM's object-oriented REXX interpreter. REXX is implemented on many different systems, too. In addition to Linux, REXX was
the system interpreter for OS/2 and VM/CMS, and REXX is also available for Windows, Amiga, and the other IBM mainframe operating systems.
Frederick Brooks, in
No Silver Bullet —Essence and Accident in Software Engineering , argues that there is no silver bullet that will magically solve all the problems inherit in software development. I think he's right: in the search for the silver bullet, we've spent the past 40 years reinventing the wheel. So, I won't claim that REXX is the silver bullet, but Mike Cowlishaw has certainly created the shiniest bullet we're likely to see for a very long time.
Resources
The Rexx Language Association promotes the use of Rexx, sponsors an annual symposium, and the website includes a forum. You'll find information about NetRexx and OORexx here, too.
Mark Hessling's home page,
www.rexx.org, includes all the Rexx projects that he has developed or is maintaining, including Regina Rexx. In addition to Regina Rexx that I installed, you'll also find goodies like Rexx libraries to connect to databases, develop network programs, and write PDF files. If you were a fan of the VM/CMS Xedit editor, THE (The Hessling Editor) is Mark Hessling's implementation of the classic CMS editor.
The classic book on Rexx,
The Rexx Language: A Practical Approach to Programming, by Rexx creator Mike Cowlishaw, is a short and very readable introduction to the Rexx language.
The IBM Infocenters for
z/VM and
z/OS include a
Rexx Reference and a
Rexx User's Guide. Just go to the Infocenter of your choice, and search for "rexx reference" or "rexx users guide".
The Design of the REXX Language by M. F. Cowlishaw. This academic article appeared in
The IBM Systems Journal Vol. 23 No. 4, 1984.
The Man Behind Rexx: z/Journal Visits IBM Fellow Mike Cowlishaw
in this 2004 interview.
