| Open Object REXX (ooRexx) | |
| Paradigm: | Multi-paradigm object-oriented (class-based), procedural (imperative), structured |
| Latest Release Version: | 5.1.0 |
| Latest Preview Version: | 5.2.0 |
| Typing: | dynamic |
| License: | CPL 1.0, GPLv2 |
| Designer: | Simon C. Nash (IBM), Rick McGuire (IBM) |
| Memory Management: | Garbage collection |
| Implementations: | Object REXX (until 2004) ooRexx (since 2005) |
| Influenced By: | Rexx, Smalltalk |
| Influenced: | NetRexx |
| Programming Language: | C++ |
| Platform: | IA-32, x86-64, ARM, s390x |
| Operating System: | Cross-platform Linux, Microsoft Windows, macOS, Solaris, OpenIndiana, AIX, FreeBSD, OS/2 |
| File Ext: | .rxs, .rex, .rexx, .cls, .orx, .rexg, .rexp |
Object REXX is a high-level, general-purpose, interpreted, object-oriented (class-based) programming language. Today it is generally referred to as ooRexx (short for "Open Object Rexx"), which is the maintained and direct open-source successor to Object REXX.
It is a follow-on and a significant extension of the Rexx programming language (called here "classic Rexx"), retaining all the features and syntax while adding full object-oriented programming (OOP) capabilities and other new enhancements. Following its classic Rexx influence, ooRexx is designed to be easy to learn, use, and maintain. It is essentially compliant with the "Information Technology – Programming Language REXX" ANSI X3.274-1996[1] standard and therefore ensures cross-platform interoperability with other compliant Rexx implementations. Therefore, classic Rexx programs typically run under ooRexx without any changes.
There is also Rexx Object Oriented ("roo!"), which was originally developed by Kilowatt Software and is an unmaintained object-oriented implementation of classic Rexx.
In 1988, the "Oryx" project at IBM, under the technical direction of Simon C. Nash, experimented with merging classic Rexx with the object model of Smalltalk.[2] [3] The motivation behind the project was to transfer the advantages of OOP to classic Rexx while remaining compatible and thus transferring the usability of classic Rexx to OOP.[4] Early on, the projects focused on OOP aspect such as treating everything as an object, object-based encapsulation and message passing, object-based concurrency, classes and inheritance.[5] This initial work later led under the direction of Rick McGuire to the first prototype of Object REXX, which was presented in 1992. In 1994, IBM announced that Object REXX would replace classic Rexx as the standard REXX interpreter in the next version of OS/2. In 1996, Object REXX was released as part of the OS/2 Warp 4 operating system.[6] In 1997, versions for Windows 95, Windows NT and Linux followed.[7] [8] In 1999 an Object REXX version for AIX V4.1.5 or higher was released.[9] In 2000, versions for zLinux and Sun/Solaris followed. For Windows 2000, Windows Me, Windows 98 and Windows NT 4.0, the last major update for Object REXX was released in 2001.[10] On 12 October 2004, IBM announced the discontinuation of Object REXX and transferred the source code and licensing rights to the non-profit Special Interest Group (SIG), the Rexx Language Association (RexxLA). The code that IBM released to open source did not include the classes for IBM System Object Model (SOM), which is known as the object framework for OS/2's Workplace Shell (WPS).[11] Although IBM discontinued the development of SOM in 1997, it is still a fundamental framework for OS/2.[12] The OS/2 version of Object REXX includes classes to support SOM and WPS.[13] [14] These are included in OS/2's initial follow-on product, eComStation, and also in its current descendant, ArcaOS, for which IBM's original Object REXX interpreter continues to be available.[15]
In 2005, the RexxLA released ooRexx as a new incarnation of Object REXX as free and open-source software under the Common Public License.[16] This first version of ooRexx 3.0.0 has been heavily refactored compared to the original IBM source code in order to increase readability. Later, the ooRexx kernel was rewritten in pure C++, and a new architecture and native interface were designed and implemented under the technical direction of Rick McGuire. This work enabled the RexxLA to release ooRexx 4.0.0 with support for 64-bit in 2009. To this day, the RexxLA continues to develop, support and maintain ooRexx as well as classic Rexx and NetRexx. Furthermore, the RexxLA organizes international annual symposia.[17]
The following table contains noteworthy features and changes of major Object REXX and ooRexx interpreter versions. All ooRexx releases and the necessary documentation are available freely on SourceForge.[18] [19] For Arch Linux based distributions the current and the development version are available as Arch User Repository. Since version 5.0.0 there are portable versions of the interpreter that can be used without installation, and an unofficial port to OS/2 also exists. The "net-oo-rexx" bundle contains the latest portable version of ooRexx, Netrexx, a Netrexx shell, the Java bridge and associated packages, a shell for ooRexx and various other packages and programs.[20]
For Intellij IDEA, the ooRexxPlugin adds support for syntax highlighting, syntax checking, code completion and documentation support modeled after Javadoc using annotations.[21] As of September 2012 there is support for syntax highlighting of ooRexx 4.0 features in Vim.[22] RexxCPS is a benchmark that measures the number of Rexx clauses (independent syntax units in a line) per second that an interpreter processes.
| Major Releases | Release date | Notable Features and Changes | |
|---|---|---|---|
| 1996-09-25 |
| ||
| 1997-02-28 |
| ||
| 1999-04-09 |
| ||
| 2001-04-21 |
| ||
| 2005-03-30 |
| ||
| 2006-08-21 |
| ||
| 2006-11-23 | |||
| 2007-09-17 |
| ||
| 2008-01-22 |
| ||
| 2009-09-30 |
| ||
| 2011-09-28 |
| ||
| 2014-02-23 |
| ||
| 2022-12-22 |
| ||
| 2025-05-02 |
| ||
| 2025-05-05 |
ooRexx follows the design philosophy of classic Rexx to create a "human-centered" programming language that is easy to learn, code, remember and maintain. This is achieved, in part, by keeping the language small and following the principle of least astonishment.[24] [25] A readable syntax is enabled by being case-insensitive, free-form, requiring as little punctuation as possible, and using instructions that are straightforward English. In addition, it is a dynamic programming language that offers flexibility and allows to focus on development rather than language constraints.
Following the "documentation before implementation" design principle of classic Rexx, ooRexx offers comprehensive documentation in accordance with the IBM Style Guide that includes syntax diagrams and examples.[26]
As in classic Rexx, there are assignment instructions, keyword instructions and command instructions. In line with the desire to keep the language small, ooRexx has only thirty keyword instructions. Unlike many other languages, no keywords are reserved, so keyword instructions such as DO, SAY, END and IF for example can be used as variable names during an assignment. This avoids having to memorize a long list of reserved words. An assignment is used to set or change the value of a variable. The equal sign (=) is used to create an assignment instruction which can be used in combination with eleven operators for extended assignment sequences such as +=, -=, *= and others. Keyword instructions such as ARG, PARSE, PULL or USE have the same effect as assignments.
In cases where an instruction is neither an assignment nor a keyword instruction, it must be a valid expression, e.g., a symbol, a string literal, which is considered a command instruction, whose value the interpreter passes to the current command environment, e.g., editor, operating system, for execution; the interpreter sets a variable RC for the return code. In addition, the ADDRESS instruction allows commands to be redirected to specific command environments such as Bourne Shell, Bash, Z-Shell, Command Prompt and others, some editors including ISPF, TSO EDIT, XEDIT and its adaptations, as well as intercepting errors.::).
To facilitate the reusability of code, the ::REQUIRES directive allows the integration of another Rexx program (also known as a package) or an external (native) library. This directive causes the interpreter to make every routine and class that specifies the PUBLIC option of the denoted Rexx program (package) to become directly accessible. External packages usually use the file extension .cls, for example ::requires "csvstream.cls" or ::requires "json.cls". Some external packages and libraries are delivered with the ooRexx interpreter.
ooRexx has a free-form syntax where the positioning of the program code is irrelevant, which allows a high degree of flexibility. Before execution, the interpreter merges multiple unquoted blanks into one, while a character string enclosed in quotation marks (single or double) is not changed. Concatenation can be requested explicitly with two vertical bars (||), or implicitly by separating terms with spaces or by abutting terms. Optionally, clauses can be spread over several lines by using the comma (,) or the minus sign (-) as a continuation character, or several clauses can be used in a single line, separated by a semicolon (;). Since a free-form language provides flexibility and requires fewer syntactic rules to be considered, it is assumed that it eases the learning effort by reducing the intrinsic cognitive load.[27]
As classic Rexx, ooRexx is a case-insensitive programming language. Accordingly, the ooRexx interpreter capitalizes all characters outside quotation marks (single or double) and ignores case for instructions, variable names and all other aspects of the language. Only sequences within quotation marks are treated as literal strings and are not changed during processing. Because the cases do not need to be differentiated, fewer additional details need to be learned and frustrating syntax errors are avoided.
While classic Rexx follows the "Everything is a String" philosophy and has string as its only data type, ooRexx considers everything as objects, including non-string objects such as arrays, streams and many more. Objects are manipulated using methods instead of traditional functions.
In ooRexx, a string variable is a reference to a string object and does not need to be declared, which reduces the effort for programmers compared to strictly typed languages.[28] A string object can be of any length and contain any characters, including numerical values. It is therefore possible to change numerical values with string manipulations and methods of the String class. In addition, a string variable can contain any type of expression, including executable instructions, which can be evaluated or executed with the INTERPRET keyword instruction.
str = "do i = 1 to "a"; say i; end" /* string contains loop instruction */interpret str /* interpret string: counts to 20 */
Similar to the messaging paradigm implemented by Alan Kay in Smalltalk, everything in ooRexx is an object that can be communicated with. The notion of sending messages to objects as if they were living beings helps beginners to learn OOP concepts.[29] In contrast to Smalltalk, there is an explicit message operator, the tilde (~), where the receiving object is placed to the left of it and the result of the operation is returned. Sending a message leads to the activation of a method with the corresponding method name and to the manipulation of the receiving object. Like Smalltallk, ooRexx messages can be cascaded if two tildes (~~) are used instead of one, returning the object that received the method rather than the result produced.[30]
The default behavior of most methods can be changed by specifying an option, which can be either spelled out or abbreviated and is not case-sensitive. When reading code, this enables a literal understanding and reduces the learning effort for beginners, as there is no need to learn the meaning of abbreviations. For example, the method with the name strip removes leading and trailing blanks by default. This behavior can be changed, for example, by specifying "leading" or "l" as an option. While functions are nested in classic Rexx, messages can be chained in ooRexx, which improves the readability of a statement.
ooRexx is designed to retain all the features of classic Rexx and essentially complies with the ANSI standard for the Rexx language (X3.274-1996, "Programming Language REXX"). In contrast to an optional specification in the ANSI standard, ooRexx does not allow characters such as @, #, $ and ¢ in symbols. While in classic Rexx the expression b. = a. results in b. being assigned the default value of a., the interpreter makes b. an alias for a.. In addition, ooRexx allows -- as a comment mark and - as a line continuum, which are not specified in the standard.
Classic Rexx scripts typically run without changes under ooRexx, making it easy to migrate to OOP features at the desired rate while preserving the time invested in the original code. There are incompatibilities with some platform-specific implementations such as Rexx for z/VM (e.g. PARSE EXTERNAL is not supported by ooRexx). While classic Rexx allows empty assignments such as x = ;, quotation marks x = ""; are necessary in ooRexx.[31]
ooRexx offers various customization mechanisms, such as extending built-in functions and classes, using unspecified methods, adding command environments and invocation switches or creating own builds.[32]
The default behavior of built-in functions can be changed by adding a label with the same name as the function to be overridden (e.g. date) at the end of the program scope or by adding a ::routine directive. The code can either calculate results itself or modify the results of the original built-in function.
Date: return newDate /* label pointing to "newDate" routine */
Routine newDate newDate = date~upper /* use of date BIF, but with capital letters */ return newDateSince ooRexx 5.0.0 namespaces have been added that allow the subclassing of built-in classes. This makes it possible to extend built-in classes, e.g. by adding a method such as ArrayInClose to the stream class, which opens the stream, reads the content and closes the stream instead of doing this in the program scope.
Class stream subclass rexx:stream /* create a subclass of stream */ ::Method ArrayInClose /* add new method to stream class */ self~open /* open the stream */ FileContent = self~ArrayIn /* read content */ self~close /* close the stream */ return FileContent /* return content */The definition of an UNKNOWN method enables objects to receive unspecified messages. Two arguments are passed, firstly the name of the unspecified method and secondly an array of arguments from the original message. This is a basic mechanism of the Java Bridge, which enables among other things the use of all available Java methods.
Class Package ::Method Init ::Method Unknown Use arg MethodName, ArgArr say "Method was:" MethodName /* output: Method was: SOMEMETHOD */ say ArgArr /* output: First, Second, Third */
Above all, ooRexx offers OOP features such as subclassing, polymorphism, data encapsulation and multiple inheritance via mixin classes. The interpreter includes the rexxc utility, which makes it possible to compile ooRexx programs and optionally encode the result as base64, a source-less file that starts faster since the initial parsing and compiling has already been done.
The PARSE keyword instruction makes it possible to quickly and flexibly parse a string and assign parts of it to variables in a single step. Subsequent instruction is used to specify the source of the string, for example ARG for arguments that are listed when the program or function is called, VAR for variables, PULL for data queues or standard input (typically the keyboard), VALUE for any expression. When using VALUE, the WITH keyword is required to specify the end of an expression, followed by a parsing pattern. This pattern can be a list of variables, a position number or literal delimiters; it is possible to use these patterns in combination. Optionally, the upper and lower case of the string can be converted before parsing.
ooRexx provides a new way to define procedures and functions that are not specific to a particular class by using the ::ROUTINE directive; unlike the older PROCEDURE, code defined with ::ROUTINE has an implicit RETURN at the end. The CALL instruction can be used to invoke a routine as a procedure. In addition, routines that return values via the RETURN keyword instructions can be called using function calls by specifying the name of the routine followed by parentheses. The content within the parentheses is passed as arguments to the routine. While the PARSE ARG instruction can be used to parse received string arguments and assign them to variables, the newer USE ARG must be used for objects of other types. In addition, the STRICT option can be used to limit the number of arguments that must match the number of specified names.
