This file contains all these Columns

              from www.RexxInfo.org --

 

Why Attend the REXX Symposium?………………… Mar 2008

How to Write Portable Rexx……………………………Feb 2008

How to Run Rexx on your MAC……………………….Jan 2008

What is RexxUtil … and Why Use It?…………………Sept 2007

Regular Expressions…………………………………….June 2007

Open Object Rexx 3.1.2 Released!……………………April  2007

Open Object Rexx 3.1.1 Released!……………………March 200

VBScript Versus Rexx…………………………………..Jan   2007

Time to Open-Source NetRexx?……………………….Nov  2006

ARexx Lives!  All About ARexx………………………..Sept 2006

Does Rexx have Critical Mass?……………………….Aug  2006

Whatever Happened to OS/2… and OS/2 REXX?….  July  2006

Open Object Rexx:  The 3.1 Beta Arrives……………June 2006

 

====================================================

Why Attend the REXX Symposium?

                                                      by Howard Fosdick ©

 

Wow, I sure wish I could go… (we consultants aren’t usually lucky enough to arrange our time off).

 

Here are top five reasons I’d go --

 

5  Hear presentations from the recognized leaders of the Rexx community

            4  Interact informally with peers

3  Ask all the questions you want

2  Pick up new and current techniques 

 

and the number one reason is…

 

            1  Have fun geeking out while learning and eating! 

 

You can register over at the Rexx Language Association web site at –

 

            www.RexxLA.org

 

====================================================

How to Write Portable Rexx

                                                      by Howard Fosdick ©

 

Rexx offers a number of advantages as a cross-platform language.   It has a strong standard that every interpreter upholds, called TRL-2.*   It runs on nearly every operating system and platform.   And it is an easy language to maintain, so that if you do have to make changes when porting Rexx code, this takes less time and effort than it does in many other programming languages.

 

To write portable Rexx code -- or to port existing Rexx code from one platform to another -- your first task is to identify what parts of Rexx programs may not be portable.

 

Parts of Rexx programs that may not be portable across platforms include--

 

 

This diagram summarizes what Rexx components are portable versus those that may or may not be, depending on the situation --

 

 

There are a number of ways around portability issues—

 

(example—  if you code to a database interface, make sure that database or

its interface runs on all the platforms that concern you)

 

 

Writing a Routine to Discover the Environment

 

A cross-platform Rexx script needs a subroutine or function to determine the platform it runs on.   This routine can then be invoked in the program when it needs this information to execute correct code for the platform.

 

The subroutine will (minimally) use the parse source system and parse version instructions.  It may also issue address to determine the default command environment.

 

You can download example code that does this from the book Rexx Programmer’s Reference in our Downloads Section.   In the download file, look for the routine called where_am_i.rexx.  

 

Our Standards and Portability Section contains several documents on portability.   These also include sample code for determining the execution platform from Steve Ferg, and more discussion on how to write portable Rexx code.

 

 

Running Different Code on Different Platforms

 

Once you have a routine to determine which platform your script is running on, select the platform dependent code to run like this—

 

  my_platform = determine_platform_routine()

           

  select

     when  my_platform = ‘WIN32’  then

     /* insert Windows code or a routine here */

           

     when my_platform = ‘UNIX’  |  ‘LINUX’  then

     /* insert UNIX/LINUX code or routine here */

              

     otherwise

     say ‘Unexpected, unrecognized system—error’

              

  end   /* Code from Rexx Programmers Reference */

 

Use IF statements or a SELECT statement to run code appropriate to the platform the script runs on.   The platform-specific code could either be written in-line, or invoked through a subroutine or function.   I recommend a subroutine if there’s much code involved.   I  also recommend OS-specific error handling within each subroutine.

 

 

Conclusion

 

Rexx is a great language for portability across systems.  It is highly standardized, runs on many different systems, and is easy to change if you do have to write platform-specific code.  

 

I’ve really enjoyed situations where I’ve gotten to write portable code.   For example, for one site I wrote code that ran on Sun’s Solaris, HP’s HP/UX, and IBM’s AIX.  These are all Unix variants, so the cross-platform code was easier to write than if it had to run across more dissimilar systems.

 

Contrast this to another project, where my code had to run under both Windows and Linux.   This was a bit more difficult.  Adding to the challenge is that Windows systems have slightly different OS command sets depending on the OS version.  For example, Windows 98 commands differ somewhat from those of Windows XP.

 

Writing cross-platform code is not hard to do if you follow the basic principles in this article.  I hope you enjoy the challenge!

 

 

----------------

*

   Every Rexx interpreter (except NetRexx) meets the TRL-2 standard; some also meet  

   the ANSI-1996 standard.   See our Standards and Portability Section for a recap of the

   minor differences between these two standards.

 

 

HOME

 

 

====================================================

Run Rexx on your Mac

 

                                                                                             by Howard Fosdick ©

 

 

Hey, the Mac’s got a lot of cachet.   The lack of viruses… the excellent user interface… the unique apps.   It’s the original anti-monopoly platform.

 

Whatever the reasons you love your Mac, you can use Rexx too.

 

There are several free Rexx interpreters for the Mac.  Among them are Regina, Rexx/imc, and BRexx.   All three are standard Rexx interpreters that offer a lot of value.  Which you should use depends on your project and your needs.  Get product information or download the products through www.RexxInfo.org.

 

My own Mac knowledge of Rexx is limited to Regina, so here are instructions for two different ways to install Regina on your MacIntosh.   These instructions are for Mac OS X.   (You can run Rexx on older Mac OS Classic 7.9 – 9.0, but that’s a subject for another column).

 

1.   Install Approach #1 – use a StuffIt file

 

Download the Regina Rexx StuffIt file from here.    The StuffIt file is the one with the .sit extension containing a dmg file.   Mount the Regina folder on your desktop, then do a standard Mac application install.

 

2.      Install Approach #2 – build from source code

 

Download the Regina Rexx source from here.   This is a file with the extension of  .tar.gz.  Uncompress the file into a new Regina folder, and go to that directory in the terminal.   Enter these two commands to build a binary executable from the source—

 

            ./configure

            make

 

Put the resulting binary in a proper location in your search path, for example, /usr/local/bin.

 

 

Testing Your Install

 

Regina comes with a number of test programs in its demo folder you can use to test your install.   A perennial favorite is the rexxcps program.  This script measures how many Rexx clauses per second your machine executes.   Just for fun, compare your results to those posted here.

 

You can also enter a simple test program—

 

            #!/usr/local/bin

            say “Rexx says Hello!”

 

The first line tells the operating system the location of the Rexx binary.

 

 

Calling External Functions

 

To enable Regina to load external function packages, you need to download and install the "dlcompat" package.   Read those instructions here, or find them in the Regina documentation. 

 

 

I’ll take my Mac with Rexx, please

 

Having Rexx on the Mac is pretty handy.   If you know Rexx from the mainframe, the IBM iSeries or some other platform, now you can have the same language on your MacIntosh.   I run into a lot of people who remember Rexx from when they used OS/2 or the AmigaOS, and they’re always glad to hear it’s available on their current system.  

 

Why spend time learning yet another platform-specific or specialized language when a standard one like Rexx provides what you need?

 

 

HOME

 

====================================================

What is RexxUtil…

    And Why Use It ?

 

                                                                                                by H. Fosdick ©

 

 

What is RexxUtil?   It’s an interface package designed to give your Rexx programs portability across operating systems.   This diagram describes it best--

 

(from Rexx Programmer’s Reference pg. 206 © 2005/6)

 

 

As you can see, your Rexx script invokes the generic RexxUtil routines.   These then interface with the underlying operating system facilities, thereby giving your program independence of the operating system.  This makes for more platform-neutral, universal programs.

 

RexxUtil is available for most Rexx platforms, including Windows, Linux, Unix, BSD, OS/2, MS-DOS, and mainframes.   It is a key tool if you need to write code that works portably across these systems.

 

The exact functions contained in RexxUtil vary slightly by operating system and RexxUtil package.   The functions generally classify into these groups—

 

 

Our Free Tools List lists at least three independent sources for RexxUtil—

 

 

If you intend to write portable Rexx code, you should become familiar with the RexxUtil package.  It’s your ace in the hole for writing portable Rexx.

 

 

HOME

 

====================================

Regular Expressions

 

                                                                                                    by H Fosdick ©

 

 

Regular expressions are a way to match strings.  They allow you to describe a string or pattern matching algorithm in a single phrase.  For this reason, they are extremely powerful.   One regular expression can often replace a whole series of complicated string manipulation statements.

 

Once you form the regular expression, the programming language takes on all the work of applying the pattern to the text you search.

 

Here’s an example.   To list all files in a Unix or Linux directory, you might issue this operating system command--

 

            ls  *

 

(The equivalent Windows command for the Windows command line is--   dir *  )

 

The asterisk (*) is a regular expression.  It matches all results in the command’s output.  So the command succinctly lists all files in the directory.

 

The power of regular expressions comes in when you match more complicated patterns.  Here we change the example to match only files ending in the characters .exe

 

            ls  *.exe                         ---or---                        dir  *.exe

 

This expression lists Linux files beginning with any one the three lower-case letters a, b, or c, followed by any two other characters –

 

            ls  [a-c]??

 

We’ve  only just started here with the complexity you can build into a regular expression.

 

Regular expressions are a very economical way of expressing pattern matching algorithms.   The beauty of this is that so many programming problems can be viewed as exercises in string and pattern matching.   Regular expressions make for terse, powerful programs.

 

Is there a downside?   Sure.   Regular expressions can look very complex to someone who has to maintain your code (or even to you, if you haven’t looked at your code for awhile!).    Some programmers have a tendency to pack everything into a few very powerful regular expressions.  These can be difficult to decipher.

 

Therefore you should always very fully comment any complex regular expressions you embed in your code.   Nothing is worse than having to figure out – and debug – a very complex regular expression in someone else’s un-documented code!

 

Perl is perhaps the best-known scripting language featuring built-in regular expressions.   This is one reason why programmers consider it such a powerful language.  Perl excels at string manipulation and pattern matching problems.

 

Regular expressions are not built-in as part of the ANSI-1996 or TRL-2 language standards for classic, procedural Rexx.   But this does not matter much.  There are several free function packages that enable you to code regular expressions in Rexx that work with almost any Rexx interpreter.   (See our Download Tools section for a list of free Regular Expression packages).

 

From the coding standpoint, it makes no difference whether regular expressions are built into the language or whether they come as part of an add-in function library.   You just  establish access to the external Rexx function library by a line or two of code in your script.  Then you can code like regular expressions are just another part of the Rexx language.

 

Regular expressions come built-in as part of Open Object Rexx.   They are provided through the RegularExpressions Class, with its methods init, match, parse, pos, and position.   (View a list of all Open Object Rexx classes and methods here.)

 

You’ll want to use regular expressions in your Rexx code to succinctly express complicated pattern matching.   Just make sure you write readable code and document what the regular expressions do!

 

HOME

 

====================================================

 

Open Object Rexx 3.1.2 Released !

 

                                                                         

April 2007,  Rexx Language Association --

 

Today the Rexx Language Association announces the release of version 3.1.2 of the Open Object Rexx open source programming language.

 

"ooRexx" 3.1.2 includes a wide variety of enhancements and bug fixes including new methods and classes.  This reference card indicates all the new features by color-coding:

http://wi.wu-wien.ac.at/rgf/rexx/misc/refCard/ooRexx-3-1-2-Class-reference-RC1-20070409.pdf.

 

Open Object Rexx is used world-wide to address a wide variety of programming and scripting problems.It is a true super-set of the classic procedural scripting language, Rexx, which was invented by IBM Fellow Michael Cowlishaw.  Open Object Rexx ranks in the top few percent of  the many thousands of SourceForge project downloads. 

 

Open Object Rexx runs on Linux, Windows, Unix, and MacOS X.  The product and all documentation can be freely downloaded from http://www.ooRexx.org/.  The Rexx Language Association is a not-for-profit organization that enhances and maintains Open Object Rexx.  Complete information is available from the Rexx LA at http://www.RexxLA.org/.

 

Here is a list of what 3.1.2 adds to ooRexx… it’s quite a list for a “point release” —

 

RFEs

 

[ 1683291 ] Add an "instanceof" capability to the .object class.

[ 1661587 ] Add lOgical option to Datatype BIF and String Method

[ 1659877 ] Add a "user" subcode for each of the Rexx error categories

[ 1659861 ] Add a class like the Java Peroperties class.

[ 1659225 ] Add a better mechanism for retrieving started message errors

[ 1644003 ] Add docs and files to make .deb packages

[ 1626612 ] OODialog YesNoMessage function allow default button selectio

[ 1565805 ] Add DATATYPE() test for logical values

[ 1479837 ] Add POS Method to Mutablebuffer Class (and LASTPOS)

[ 1323007 ] RxWinExec

[ 1682637 ] MESSAGE: access to target and arguments

 

 

Bug fixes

 

[ 1693689 ] ConditionObject raises 93.903 on 'supplier' message

[ 1685711 ] Large OODialog application causes access violation

[ 1683068 ] DLGAREA.cls not getting included with distribution.

[ 1668663 ] OODialog parses style attributes in RC file incorrectly

[ 1668003 ] OODialog doc confuses ListControl with ListBox

[ 1660942 ] running method causes rexx crash

[ 1659332 ] Can't subclass .method class

[ 1647330 ] object creation issue

[ 1646738 ] DO loop not executing...

[ 1644984 ] Doc for FileNameDialog / GetFileName unclear to users

[ 1644977 ] FileNameDialog doesn't accept path name only

[ 1639773 ] Debian Linux package fails to run ooRexxUnit

[ 1634162 ] Copy method buffer error

[ 1623592 ] Segmentation fault on complex program

[ 1607510 ] .OLEObject getKnownMethods returns wrong information

[ 1607010 ] Provide a way to direct object coercion

[ 1605177 ] Error text for 25.906 incomplete

[ 1323259 ] OleOject Does Not Return Array For Out Parameters

[ 1214589 ] "return .True" returns false in DHTML

[ 1166659 ] Incorrect value vrom Parse Source

[ 1098405 ] OLE-interface to OpenOffice

 

HOME

 

 

===========================================================

Open Object Rexx 3.1.1 Released !

 

                                                                               by the Rexx LA   01/2007

 

 

January 2007,  Rexx Language Association --

 

The Rexx Language Association is proud to inform the public that version 3.1.1 of Open Object Rexx (ooRexx) has been released and may be freely downloaded from ooRexx.org.   For the first time, binary versions are available for Mac OSX and AIX.  New binaries for Windows, Linux and Solaris have been created as well with versions for Solaris pending.  In addition users can download the source code of Open Object Rexx and may freely and readily build the programming language themselves.

 

IBM donated the source code of its Object REXX product to the Rexx Language Association in December 2004 for publication and support as an open source project.  With ooRexx 3.1.1 both the Rexx and open source communities can enjoy the numerous enhancements and fixes that have been incorporated into ooRexx under RexxLA stewardship.  ooRexx ranks in the top few percent of all active project downloads on SourceForge.

 

 

*   The Linux version of ooRexx 3.1.1--  The Linux version of ooRexx has been ported to many Linux distributions.  At present an rpm-package is supplied that can be used for installing/updating ooRexx on the Linux x86 platform.  As of October 2006 Open Object Rexx (ooRexx) was incorporated into Fedora Core Extras Repository, reflecting the increased support the open source version of Object Rexx has gained in the past 18 months.

 

*   The Windows version of ooRexx 3.1.1--  The version 3.1.1 of ooRexx supersedes version 3.1 of August 2006 and fixes a few bugs on the Windows platform.  Windows users of ooRexx 3.1 are urged to upgrade to version 3.1.1 as soon as possible.  The Windows implementation of ooRexx makes it a WSE (Windows Script Engine) and can be used for interacting with Windows and Windows COM objects using OLE/ActiveX.  ooRexx can be deployed on Windows wherever VBScript or JScript can be used e.g.  as a DHTML scripting language or for ASP serving.  In addition one can use Microsoft's WSH (Windows Script Host)to create COM classes (WSC, Windows Script COMponent) in ooRexx which then can be instantiated like any other COM class from C++, ooRexx, Visual Basic, even via DCOM (distributed COM)!  Just look up the numerous small ("nutshell") samples that get installed with ooRexx on the Windows platform in the downloaded product's folders "%REXX_HOME%\samples\ole" and "%REXX_HOME%\samples\oodialog".

 

*   The Mac OSX version of ooRexx 3.1.1--  The introduction of a binary package for MacOSX (PPC, Intel) marks another milestone for the Rexx/ooRexx community, bringing a powerful and easy to use programming language to this innovative platform.  Furthermore, ooRexx programs on MacOSX can directly access Java, automatically making them open-platform applications.

 

*  The Solaris version of ooRexx 3.1.1--  The Solaris version of ooRexx has been ported to the i386 versions 2.9, 2.10 and SPARC 2.9.  There are pkg and tar versions supplied that can be used for installing/updating ooRexx on the i386 and SPARC platforms.

 

*  The AIX version of ooRexx 3.1.1--  The introduction of a binary package for IBM's AIX operating system marks a milestone.  It is the first open source version of Open Object Rexx for that platform.  IBM has discontinued its commercial Object REXX for AIX, making ooRexx very important to professional AIX programmers.

 

*  Documentation on Open Object Rexx (ooRexx)--  ooRexx is accompanied by probably the best documentation of any open source project.  The documentation is freely available via the Internet either in the form of nicely formatted PDF books or rendered as HTML here.  Also, a few interesting nutshell ooRexx examples are always installed with ooRexx , located in the "samples" directory and its optional subdirectories (depending on the platform).  The internet newsgroup  and the ooRexx SourceForge site are two of several sources for help.

 

 

About Open Object Rexx (ooRexx).  Open Object Rexx (ooRexx) is an object-oriented scripting language.  The original Rexx language was designed as a procedural tool for non-programmers, so it is easy to learn and easy to use.  Open Object Rexx extends procedural Rexx with object-oriented features and provides an excellent vehicle to enter the world of object-oriented programming.  ooRexx allows you to gradually change your approach to programming problems as you learn more about objects.  ooRexx is backwards-compatible with Rexx and will run procedural and mixed procedural/object-oriented programs as well!  See the homepage of ooRexx, which also points to the core developer team.

 

 

About Rexx Language Association (RexxLA).   RexxLA is an international, not-for-profit organization based in North Carolina, U.S.A.  with voluntary officers that span the world (America, Australia, Europe).  RexxLA organizes the "International Rexx Symposium" every spring for Rexx enthusiasts.  The upcoming 18th International Rexx Symposium is a five-day conference, 29 April - 3 May 2007 (Sunday - Thursday) in Tampa, Florida, USA.  The homepage of the RexxLA points to the officers and the International Rexx symposia.

 

HOME

 

 

===========================================================

VBScript Versus Rexx

 

                                                                               by Howard Fosdick ©

 

 

I hesitate to write anything that even approaches a “language comparison.”   Doing so stirs up deep emotions in many programmers and few look at such comparisons objectively.   My view is that there are many programming languages in part because all offer their own benefits and advantages.

 

Nevertheless, one can learn so much by comparing programming languages.  So, I’d like to say a few words about VBScript and Rexx in this article.  This is not a formal comparison.  The goal here is simply to note a few aspects of both languages developers should consider if using one or the other.

 

I’ve used dozens of programming languages over the years, including all of the popular “scripting” languages.   But I only recently plunged into VBScript for the first time.  I wrote a 2,400-line program that generates scripts that run Oracle database backups and monitors their execution.

 

VBScript is a true subset of Microsoft’s Visual Basic.  It is closely related to Visual Basic (VB), VB .Net and Visual Basic for Applications (VBA).   Learn VBScript and you access a family of languages that Microsoft promotes as fundamental to Windows.  VBScript and its kissin’ cousins run in browsers, as server-side web scripts, and inside Office tools like Word and Excel.  They access the Windows object model and do just about anything you can do under Windows.

 

VBScript is the default “batch” language for Windows.   It replaces the ancient DOS-derived language that executes from the command line, which still ships with Windows.   VBScript is often used as the scripting “engine” for Windows Script Host (WSH), the programmable Windows administration tool.

 

Big VBScript advantages include:

 

·        Access to all Windows features in all Microsoft Windows products

o       Through the Windows ActiveX or COM object model

·        Tons of free code “snippets” on the web

o       Anything you want to do, you can find free code examples to help you. You can even plug much of it straight into your application.

·        A huge user community, with all the support forums and tools that implies.

 

How does Rexx compare?   You can do just about anything with Rexx (in one version or another) as you can with VBScript, because Rexx also runs as a WSH ActiveX scripting engine, and it too accesses the Windows object model.  But VB offers the advantages of numbers.  It has way more Windows developers, tools, available code snippets, tutorials, web sites, books, and resources.   It also enjoys official Microsoft support.  Microsoft has anointed the VB family of languages its vehicle, and independent languages like Rexx (and Perl and Python and PHP), remain hungrily looking in from outside of Redmond’s charmed circle.

 

The VB family of languages are exclusive to Microsoft.  They are proprietary and the company controls their development and where they run – which Windows only.   Although forms of BASIC, they don’t even remotely adhere to any BASIC language standards.

 

The Rexx family of languages contrasts to this in their portability and compatibility across a very wide of range of platforms.  Rexx runs everywhere from handhelds to mainframes, and on everything in between.   Rexx has strong procedural language standards, and the informal but widely accepted object-oriented programming standard embodied in Open Object Rexx.  

 

Learn VB to become a Windows Wizard.  Learn Rexx to learn a skill that applies to all platforms. 

 

Let’s explore a few technical aspects of the two languages.

 

I found VBScript and Rexx to be very similar in their string processing power.  Both languages contain an extensive set of functions that allow you to specify and resolve programming problems through the string processing paradigm.   Rexx gains the edge with one really nice statement to which VBScript has no equivalent – parse.   Using parse you can analyze or decompose strings with a single statement.  With VBScript you manually parse by coding its many individual string functions.

 

Both languages offer huge advantages in their ease of use.  Write VBScript or Rexx and your code has a good chance of becoming a living, breathing entity that others can easily read, change and maintain.  Contrast this scripts written in languages like Perl and the Unix/Linux shell languages.  These are excellent languages, but they are not particularly good vehicles for writing easy-to-read, easy-to-maintain code.

 

VBScript lacks a few important features that Rexx offers.  Associative arrays are an example.  In Rexx you can access an array using arbitrary subscripts; in VBScript, you access arrays only by numeric subscripts.   In my Oracle backup program, I needed to parse a text file containing input parameters specified in free-format.  With Rexx I could have used parse and added keyword values to an associative array as I read them.  With VBScript there was no alternative to a plodding routine to read, parse, and gather all the input parameters.  I could gain some efficiencies by using a two-dimensional array, but ultimately an associative array is what I needed.

 

VBScript arrays are dynamic, but it’s up to the developer to resize them.  Rexx dynamically expands and contracts arrays.

 

Both languages support regular expressions.  VBScript added them to the base language in Version 5, while with Rexx, you use your favorite one of several regular expression function libraries.

 

I found VBScript to be a bit less flexible than Rexx in terms of free-formatting the code.  For example, you can only code one statement per line.  At times VBScript was a little verbose for my liking.

 

One subtle but maddening thing about VBScript is that it does not always function as you might expect.  For example, I encountered a couple cases where I was tripped up by VBScript’s goofy idea of the Variant – its only data type – which comes in 14 subtypes.  Yikes!  Is that one data type or many?   The answer is that it depends on which source material you read and what you’re doing in your program.

 

For example, I had a parsing routine that analyzed the contents of a string.  My initial results were way different than I expected.  Then I used a Replace function to change all tab characters in the string to spaces before starting the routine, and I got the expected results.  VBScript’s string functions treat a tab character as different from just another byte in a string!

 

Here’s another example.  I passed a variable that I had used for numeric computation in to a subroutine.  But I found that the subroutine considered it a string.  I had to use the Cint function to cast the value as an integer in the subroutine and get correct results.  This is not what I expected since I had already used the variable in a numeric expression in the calling routine.

 

The inventor of Rexx, Michael Cowlishaw, says he based Rexx, in part, on BASIC.  He likes BASIC’s ease of use and maintainability.  But he was interested in making a more powerful language that consistently acted in the ways users would assume or expect.   After using VBScript I can better appreciate his philosophy and the degree to which he succeeded.

 

In the end, I look at VBScript and Rexx in the same way I do most programming languages.   Each has its own advantages and disadvantages.  Depending on the situation, either (or both) could be great choices to meet your programming needs.

 

If you’re interested in learning VBScript, there are many books out there and you may find it hard to pick the best one for your needs.  I recommend VBScript Programmer’s Reference (2nd Edition).   It includes a tutorial and a complete language reference, and it covers VBScript in all its many roles (WSH, client- and server- side scripting, etc).   For full disclosure, I should mention that the book is in the same publisher series as my own Rexx Programmer’s Reference.  It similarly tries to give you everything you need to know in one book.

 

HOME

 

 

=====================================================

Time to Open-Source NetRexx ?                

 

H. Fosdick ©

 

 

I’ve been calling scripting the “silent revolution” for some time now.   Scripting languages have exploded in use, yet in the computer industry trade press, they get little publicity.  The reason is that while they are extensively used, they present little revenue opportunity for vendors and others with an interest in driving publicity.

 

Lately, though, this publicity vacuum has been filling.  Both EWeek and Infoworld recently published articles on what they now call “dynamic languages” (an old rule of the tech biz is that mature technologies can only be publicized if they change their names to cover their history first). 

 

The Infoworld article is especially interesting in that it takes a good hard look at NetRexx.  It directly compares NetRexx to Ruby, two dynamic languages that were introduced at roughly the same time.  

 

The article lists many of the technical advantages to NetRexx:

 

“It runs interactively or can be compiled into Java bytecodes….NetRexx is highly productive and easy to learn, with numerous elegant constructs… all Java libraries can be accessed from NetRexx,

plus it enjoys the performance benefits of the Java Virtual Machine.”

 

The article then asks:  

 

“So which of these two languages are more successful: the fast, elegant NetRexx, or the far less intuitive and slower Ruby?   Contrary to what one would expect, Ruby is flying high today – NetRexx is nearly dead.”

 

The article concludes that the reason Ruby has succeeded in gaining popularity while NetRexx has not is that:

 

“Ruby is open source and NetRexx is not.  The result is that Ruby was able to build an active developer community… Meanwhile, NetRexx limps along, unattended and friendless, despite its great merit.  Had IBM open sourced it, scripting today might be wholly different.”

 

This article has a lot of merit.  It certainly is objective – the author is sincere and not a promoter of some sort.  He points out many of the technical benefits of NetRexx, which truly is a remarkable language.  And then he explores why such a great language has its fans, but has never gained the widespread popularity it merits. 

 

Would open sourcing popularize NetRexx?     There are two ways to look at this question.  First, historically—  what would have happened had IBM open-sourced NetRexx back when the language was introduced a decade ago?   We can never know the answer to this question.  The author of the Infoworld article argues that NetRexx would have become a widely popular scripting language.  It’s got so many great technical features, plus that unusually cool integration with Java and its JVM.

 

The second question is current--  could open sourcing NetRexx today lead to greater popularity for the language?   For one possible result, we look to Open Object Rexx.  Under the moniker “Object Rexx,” IBM sold and promoted this language for a decade—  to little effect.   Yet within a year of being handed over to the Rexx Language Association and open-sourced, its use is exploding.  SourceForge statistics show that Open Object Rexx has been in the top one percent of downloads for months now.

 

With virtually no outside publicity, Open Object Rexx is taking off.  It’s open source and developers love it.   It’s also got a top-notch technical team behind it (featuring superstars like David Ashley, Mark Hessling, Rony Flatscher, Rick McGuire, and Mark Miesfeld, among others) 

 

The developer community the Infoworld author attests to as critical has formed around Open Object Rexx.

 

Would open sourcing NetRexx do the same for it?   Maybe.  It depends on whether its fans would gather ‘round to support and develop it the way the outstanding Open Object Rexx community and its developer team have done. 

 

Ultimately, there’s only one way to find out.   If the enough users are willing to take it on, IBM should open source NetRexx.  Let NetRexx find its own way.

 

HOME

 

=========================================================

ARexx Lives!   All About ARexx…

  

 

                                                                                    by H. Fosdick  ©

 

 

The Amiga is among the most famous personal computers.  Unveiled by Commodore International in 1985, the machine was instantly recognized as far ahead of its time.  It was the first PC to feature a pre-emptive multitasking operating system.   To its users it was best known as a fabulous machine for graphics and for its early graphical user interface (GUI).   It came with a popular Rexx implementation called ARexx.

 

Commodore went bankrupt in 1994 and stopped manufacturing the original or “classic” Amiga machines.  But the Amiga had had such an impact that an enthusiastic community still supports the machine today (along with various Amiga clones and newer versions that have since come out from other companies).

 

As Wikipedia’s July 2006 entry on the Amiga says, “… the Amiga still has a very strong user community, particularly outside the United States”… “The Amiga is considered by some to have an extraordinarily loyal fan base.” 

 

Amiga users steadfastly continue to employ the machines in such industries as television and radio broadcasting, video production, and fashion design.   The user base is, by far, strongest in Europe.  It even supports a number of small vendors of expansion hardware.

 

To get an idea of the size of the Amiga community, this graph shows monthly uploads to the ARexx script repository at Aminet --

 

 

Aminet was established in 1992 in Switzerland and is one of the oldest software repositories on the web.  It has a 30 gigabyte repository with over 75,000 packages for free downloading.   A quick site search turns up at least 700 free Rexx scripts.

 

This next chart from August 2006 tracks uploads to Aminet over the past twenty years.   It proves that the Amiga community is alive and well.   Of course, it’s not as big as in its heyday, back in the mid-1990s.   Yet you’ll notice there has been an increase in uploads over the past three years (data from 2006 is incomplete but fits this trend so far)–

 

 

Many enthusiastic users continue with the Amiga, though today it’s most accurate to characterize this system as an important “niche” platform.

 

 

The Amiga and Rexx

 

The operating system that came with the Amiga is called AmigaOS.   It eventually produced two close descendants, MorphOS and the open-source AROS (Amiga Research Operating System).  All three are in use today.  AROS is installable on IBM PC compatibles.

All three systems bundle Rexx as the operating system’s scripting language.   William Hawes developed the Amiga Rexx or ARexx language in 1987.  He based it on Michael Cowlishaw’s 1985 Rexx language definition in the book The Rexx Language (or TRL-1).

 

ARexx became wildly popular with Amiga programmers.   This demonstrates how Rexx’s unique combination of power and ease of use appeals to many developers.   Wikipedia’s entry on ARexx states, “Programmers and users evaluated it positively and responded to the enormous success of this script language in the Amiga scene.”

 

ARexx offered a number of additional built-in functions beyond the TRL-1 standard.   These are:  b2c, bitchg, bitclr, bitcomp, bitset, bittst, c2b, close, compress, eof, exists, export, freespace, getspace, hash, import, open, randu, readch, readln, seek, show, storage, trim, upper, writech, and writeln.

 

A quick look at this list shows that the extra functions fall into these categories—

 

writech, writeln)

 

While ARexx is bundled with AmigaOS and MorphOS, the Regina interpreter was chosen for the open-source AROS.   Regina was extended with the extra ARexx functions above, so as to match ARexx’s function set.  

 

Regina also offers these “ARexx functions” for other platforms.   To enable them, you must issue the options instruction with the AREXX_BIFS operand, like this—

 

            options   AREXX_BIFS

 

The default is AREXX_BIFS for AmigaOS and AROS, and NOAREXX_BIFS on all other systems.

 

Since Regina already had open, close, and eof extended functions built into the language, if you want these Regina functions to follow the ARexx semantic rules, you must issue—

 

            options  AREXX_SEMANTICS

 

The default is to use Regina semantics for these three functions.

 

ARexx’s set of extended built-in functions for file I/O are modeled on those of C language (close, eof, exists, open, readch, readln, seek, writech, writeln).

 

Dr.Vasilis Vlachoudis developed the BRexx interpreter that includes similar functions.   BRexx runs on the AmigaOS, as well as a very wide variety of other systems -- Unix, Linux, BSD, Windows, Windows CE, 16- and 32- bit DOS, BeOS, MacOS, and others.  BRexx is an outstanding Rexx implementation: fast, light, and portable across many systems.

 

 

ARexx Today

 

The Amiga community continues using their computers, and Rexx continues serving them.  ARexx, Regina, and BRexx are the primary Rexx interpreters for Amiga fans.

 

AmigaOS, MorphOS, and AROS represent several of the hundreds of “niche operating systems” out there – systems that rarely make the news.  Yet these systems are of tremendous value to their users.   That’s why they stick with them.  

 

Rexx has an important role in supporting these systems and their users.

 

RexxInfo.org links to the key Amiga community web sites.  The ARexx sites include Amiga University, with its many tutorials and code samples and reference materials.  Aminet offers a huge repository that includes at least 700 free ARexx scripts.   We also link to Regina information and downloads, and BRexx information and downloads.  

 

We wish all the best to Amiga fans and hope they find our RexxInfo web site useful.

 

 

HOME

 

===========================================================

Does Rexx Have Critical Mass ?

  

 

                                                                   by Howard Fosdick  ©

 

 

I’ve been fortunate to program in many different languages over the years.   In that time I’ve come to learn that all programming languages have their strengths and weaknesses.   There is no perfect programming language.   Instead, languages sort out as more suitable or less suitable for particular projects based on the requirements of those projects.

 

Your needs determine the language that is best for your project or organization.

 

One need that is common to most situations is the requirement for “critical mass.”   When a programming language attains critical mass, it has sufficient users to ensure—

 

 

 

Does Rexx have this critical mass?

 

No one really knows how many users there are for any of the free, open source scripting languages.   Various web sites measure downloads, but these are rarely aggregated across sites.  More importantly -- “downloads” does not necessarily equate to “users.”  One million downloads could mean one million users.  It could also mean 100,000 users with 900,000 dilettantes who moved on to other products.

 

Nonetheless, Gartner Group, IDC, and other industry intelligence organizations try to determine how many users there are for different programming languages.  Among scripting languages, I believe the usage hierarchy for the major languages looks something like this—

This chart only includes cross-platform or universal scripting languages.  It excludes proprietary ones (such as Microsoft’s Visual Basic, VBScript, VBA, and Apple’s AppleScript).  It also excludes languages that are not widely considered general-purpose.   An example is PHP, a widely-popular scripting language that can be used for a wide range of activities, but is still nearly always associated in the public mind with scripting web applications.

 

The chart excludes compiled or “system” languages like COBOL and Java.  We’re only talking true interpreters here.  (And even then, the definition of what is a scripting language is not universally agreed upon.).  

 

Perl tops the list, of course.  It is definitely the most widely-used scripting language in the world, and possibly one of the most widely-used programming languages of any kind.  

 

Python is way less popular than Perl, but is still a tremendously popular cross-platform scripting language.   My guess is that it is in second place among the “universal scripting languages.”

 

Rexx, Tcl/Tk, and Ruby are the other three cross-platform scripting languages that have critical mass.  While less widely-used than Perl or Python, these languages have users world-wide, run on nearly all platforms, feature broad support, and have all the necessary tools.   Most objective observers would say that they fulfill the criteria I listed above-- they have “critical mass.”

 

The languages listed in red are great programming languages, all with their own strengths and advantages.  But they tend to be less than universal in their breadth of their support, their reach across platforms, and the sizes and geographic distribution of their user communities.   Their sets of free add-in tools are much less than any of “the big five” (Perl, Python, Rexx , Tcl/Tk, and Ruby) with the result you could find yourself in situations where you can not find the tools or add-in code you need.

 

Take an example from my own area of expertise, databases.  The big five directly connect to any important database, commercial or open source.   They all offer special interfaces to enable this.

 

The languages in red?  Well, it depends.  The Korn Shell and C-shell, for example, do not directly connect to all databases.  Instead, one typically embeds the database interface (like Oracle’s SQL*PLUS or DB2’s Command Line Processor) inside the shell script.  Then you drive the database through that interface.   With the “big five,” you can take this approach, but you also have the option of direct interpreter-to-database connections.

 

The red languages are great products that find many uses.  But I don’t think objective analysts would say that they’ve attained critical mass by the definition above.

 

If you use Rexx, you enjoy the benefits of  a world-wide language that has attained critical mass.   This brings you the benefits of universality… sufficient tools, community, support, forums, and training and reference materials.  In short, everything you need to ensure success.

 

HOME

 

 =====================================================

What Ever Happened to OS/2

                …and OS/2 REXX ?

  

 

                                                                              by Howard Fosdick  ©

 

 

Remember OS/2?   It was the joint IBM-Microsoft operating system that was presented as the follow-on to DOS.  As DOS aged in the late 1980s, OS/2 was anointed its heir.   All PCs would eventually be sold with OS/2.

 

But we all know it turned out differently.   IBM and Microsoft had a major falling out and became competitors.   Microsoft triumphed as its Windows family of operating systems gained a near-monopoly on personal computers.    

 

This had big implications for Rexx.  Rexx was distributed with OS/2 as the official, built-in scripting language for the operating system.  This was because DOS did not have any bundled scripting or command language beyond its very primitive “batch” language.   Designers realized that modern desktop operating systems required a powerful but easy to use language.  <