Open Source REXX Blog

Stop SOPA / PIPA

2012-01-17T20:03:00.001-08:00

For some time, the copyright abuse industries (primarily music and movies, but also newspaper and book publishers), have been plying politicians with campaign cash. Their objective has been to force everyone to continue paying them large sums of money. I haven't the time to find and link some of the stories of takedown notices against videos of toddlers dancing because of the music that was in the background or attempting to collect fees against auto repair shops if the music in the repair bays is audible in customer areas.

Recently, many in the technology fields noticed that PIPA (Protect IP Act) and its twin SOPA (Stop Online Piracy Act) included some requirements that would completely break the Internet as we know it.

I ask you, if you are a US citizen who is old enough to vote, to register and to contact your elected officials (your two senators and one representative, as well as the President) and urge them to prevent this from passing. Please remember to vote against anyone who supports these bills.

Thank you.

Starting Over: Rexx As Enhanced Shell Scripting

2010-03-13T00:48:00.001-08:00

I can hardly believe that it has been over a year since my last posting. I spent 8 months in Missouri, working six days a week, ten to twelve-plus hours per day. Since Rexx is not allowed in my employer's work environment, that meant little or no time to even look at the language. On top of that, I'm very much a beginner with this language. This blog is sort of a way of recording my journey and showing others how to get somewhere with it. And, of course, the resources to pick up the language are sparse and getting sparser.

Even so, I haven't done all that I could to learn the language. My earlier attempts used Regina Rexx--in part, because it is available in the Ubuntu repositories--which actually follows the standard well enough so that most of the examples you'll find in books will work. The problem I found there is that the language itself is rather thin in some areas. This is understandable, because the language was designed from the beginning as glue, to take the available tools that already exist and to chain them together into something that provides desired functionality.

As a cross-platform language, I really wanted something that was more WORA ("write once, run anywhere"). But I found that calling out to the environment necessarily involves platform-specific functionality that has to be rewritten whenever the platform changes. So this isn't the language I wanted, but I think it can still be useful, so let's try and find some uses for it, shall we?

Assumptions

In order for this to work, I have to make some assumptions. So I'm going to assume that you're using a similar environment to mine:

Operating system: Gnu+Linux, in particular, I'm running Xubuntu 9.10 64-bit. I'll probably be converting over to ArchLinux in a month or two. Whether you're on a Ubuntu-family OS, Mint, gNewSense, Arch, Debian, Mepis, Fedora, Mandriva, PCLinuxOS, or Suse, it should be pretty much the same.

The NetPBM image toolkit package. This is available for various Unix-like operating systems, and also for Windows. It should be available through your distribution's packaging system or from SourceForge. The documentation is online.

ooRexx, the IBM-derived, object-oriented, open source version of the Rexx language. The current version is 4.0, available from your distribution's packaging system or from SourceForge The oorexx and oorexx-docs downloads are on this page. This could potentially work with Regina Rexx or another version, but this is what I'm using.

Your $PATH variable is set properly, so that the above software list is available on your path.

Task 1: E-Mail Protection

As we all know, there are software "bots" that scan the Web, looking for e-mail addresses to add to the spam targeting lists. Unless you like the flood of "male enhancement" and other spam and scam messages, your best bet is to find another way to put your e-mail address online.

Using NetPBM at the command line, we could do something like this:
pbmtext "yourname@example.com" | pnmtopng >emailimage.png. But unless you use this often, you'll spend more time on NetPBM's doc site than you wish.


#!/usr/bin/rexx
/* emailimage.rex - protect someone's e-mail from some spambots */
/* copyright - none */
/* sends pbmtext "yourname@example.com" | pnmtopng >emailimage.png to shell */

say "Please enter your e-mail address."
parse pull addr
say "Please enter a name for the file."
parse pull flnm

outstring = "pbmtext " addr " | pnmtopng >" flnm ||".png"
outstring

You should have a PNG file in the directory where you ran this script. You can upload it to a web site or find another place to use it. There are some other options which could be set. If you'd like to know more, read the docs for NetPBM.

I am hoping that this is the first of many little things that can help make your life a little easier. I don't currently own any Windows machines, so these examples might not work for Windows users. In particular, on non-Unix platforms, the first line (#!/usr/bin/rexx) should be removed.

Like Rexx? Consider Following Cosmogrammaticus

2010-03-11T11:00:00.000-08:00

If you're interested in the Rexx language, I would encourage you to follow Cosmogrammaticus: http://cosmosgrammaticus.blogspot.com/ . He seems to be the person who is working on the Mac version of ooRexx. (NOTE: The site seems to be down right now--issues with their name server.)

I'm still interested in the language, but I'm very much a beginner with it, and finding that learning resources are slim. In addition, there are many times when I want to do something both on Linux and Windows, but most of the time (since Rexx does a lot of sending commands to the external environment), I wind up having to use platform-specific tools.

So I would encourage you to add Cosmogrammaticus to Google Reader, RSS Owl, or RSS Bandit. He doesn't publish often, but when he does, it is deeper stuff than I write.

NetREXX Going Open Source

2009-02-01T18:48:00.000-08:00

I guess I hadn't been to the Rexx Language Ass'n's front page in a while. IBM announced in April 2008 that they wanted to open source NetRexx. RexxLA has been negotiating it with IBM. I'm looking forward to the announcement. Maybe NetRexx will begin to move closer to OORexx, toward a more or less unified object oriented version of the language.

That is great news!

New Awakening, Thanks To OORexx

2008-08-09T18:23:00.001-07:00

Objects!

In the past several months, I stopped posting much here. In part, it is because of my employment schedule. And in part, it is because many of the things I wanted to do with REXX required platform-specific calls to the system shell. If you are interested in doing things more or less cross-platform, this is a major killer. Additionally, there is no variety of Rexx on the acceptable software list for my employer, so I have little opportunity to do anything practical with it.

On my main "road dog" laptop, which now runs Ubuntu Linux, Regina Rexx was installed from the Ubuntu repositories. I have since removed it and installed Open Object Rexx. My intention is to utilize only OORexx (and possibly NetRexx, even though it appears to be abandoned) from here on out, because of additional functionality built into the language that is not found in Regina or other standard Rexx interpreters. I want to emphasize that it is not an indictment of Regina or other standard Rexx interpreters, but merely a reflection of my desire for WORA cross-platform scripts.

One place where some version of Rexx might be useful is as a drop-in replacement for the somewhat ambiguously named KiXtart, a scripting language for Windows. However, most of my use of KiX is in automating software installation & configuration. KiX has support for editing the Windows registry, and is also a small, movable executable. For example, I might use KiX on a CD of software updates, as a kind of batch script on steroids. I am not yet seeing a case for building such a CD with Rexx instead, even if it was allowable in my workplace.

One area where I have some amount of interest is file format transformations. In the workplace, it is common for one person to send data in MSOffice 2007 formats, while most others use MSOffice 2003 formats, and some use OpenDocument Format(ODF) or WordPerfect Office format. Occasionally, I even run into data in MSWorks format. There are also JPEG, GIF, PNG, SVG, and other image/graphics formats that one might want to transform between. There is little likelihood of my writing a full-featured transformation engine, whether in Rexx or in <insert shiny new language here>, but I do hope to do some minor transformations and to demonstrate them for others who are (like me) just starting on their Rexx journey.

This change has been a long time coming, but it was inspired by a situation I faced two years ago and again last year. A number of people that I dealt with had a common situation: they had a fairly large number of photographs taken over a period of several days that were dumped into their "My Pictures" folder. Inside that folder, they needed to find photos for particular dates or locations in order to associate those photos with content (reports, articles) they were writing. I found it particularly difficult even to find out how to obtain that information in Rexx, while I found it within the same day once I started researching how to accomplish the task in KiX. The biggest issue with KiX was that the solution as implemented was Windows-specific, and some of the need came from Linux users.

Actually, I installed and configured DigiKam for my Linux users, so that photo uploads are automatically placed in date-coded directories. Every couple of months, I manually move these into a ~/year/month hierarchy. (I am planning to write a script to do it and use cron to run it monthly.)

Anyway, consider this a rebirth of interest in this blog and its subject matter. One of my interests is finding ways to use Rexx to automate repetitive tasks in a small business environment, alongside Python, Ruby, REBOL, and so on. The docs are becoming my friends. Also recommended: The Rexx Language (TRL).

Blogged with the Flock Browser

Love The One You're With

2008-03-15T18:38:00.001-07:00

There is an old song by that name, with the message that you cannot always have your own way, so make do with what is available.

In a lot of Windows environments, there is no way to use Regina REXX or OOREXX, because they are not installed. Instead, you may have to use KiXtart or VBScript. If your environment does use Java, try NetRexx as a way to use the REXX-like syntax you like in a package that is approved by the organization.

Too often, we beat our heads against the wall, trying to convince our upline supervisors that they should allow us to us something that we are already familiar with instead of the organization's approved toolset. I want you to know that you are very rarely going to convince management to listen to the employees.

Instead, try to find ways to leverage your existing knowledge and skills with the approved toolset. Perhaps someone should re-implement NetRexx in .Net (C#) as a way to bring it into that environment also.

This is a continuation of the ideas in "Use What You Can".

Use What You Can

2008-01-30T19:37:00.000-08:00

Many times, we will have a preferred toolset, but be unable to utilize some or all of those tools in our employment environments. You may be thinking, "What can I use in that situation?"

The answer is clear: use what you can. You may have to use NetRexx, if other REXX versions are not on your company's approved list (but Java is). Unfortunately, it looks like it has not been maintained for a while. Hopefully, its Java 1.2 ("Java 2") compatible output will still work correctly under Java 1.5/Java 1.6/Java 1.7 ("Java 5"/"Java 6"/"Java 7"), which is likely to be what you have in your environment.

Still Doing It

2007-11-18T20:13:00.000-08:00

Well, I never did get the REXX version of that script done. The KiXtart version does over 95% of what I needed to accomplish, so it is good enough. Where I may try to find more time for a REXX version is at home, where I have a non-Windows computer that is also the photo machine.

I have been mostly running around in circles--work was crazy for a while and home always is--but what little bit of energy I have had has been directed toward Ruby and Python (specifically Jython and JRuby) and a little bit of Smalltalk (Squeak, GNU, and VisualWorks), with an occasional effort on a KiX script or two.

If you follow many blogs, you know that this is the normal occurrence--the blog's author has his or her own life outside of the Web, so there are some long periods with little or no activity. Some even quit blogging entirely for a while.

Get Creation Or Modification Date Of A File

2007-07-04T19:49:00.001-07:00

After quite a long search, I finally found some standard Rexx functionality I've been looking for.

Cosmogrammaticus mentioned before the lack of marketing for Rexx, and I've been thinking that it really shows in the lack of documentation and tutorials that are out there in easily-found places.

Anyway, in my main and alternate workplaces, there has been a continuing cry for a quick tool to sort JPEGs by date. In both places, there are photos uploaded from HP cameras that need to be easily found by the date they were taken. In some cases, a selection of these photos is inserted into a word processor or spreadsheet file (Word, Excel, OpenOffice Writer, OpenOffice Calc). In other cases, a selection of these photos is sent alongside the word processor or spreadsheet file as e-mail attachments. The common case is that there are a fairly large number of photos (but only a subset is actually used) with specific dates being tied to specific events or locations that are the subject of the accompanying documents.

In an all-Windows environment, I finally implemented a KiXtart version of this functionality. This article is the basis for doing something similar with Rexx.


#!/usr/bin/env rexx
/* If not using Linux or Unix, delete these first two lines. */
/* filedate.rex: displays the file creation or modification date */

parse arg targetfile
if targetfile = "" then do
   call usage
end
else do
   filedate = stream(targetfile, 'c', 'QUERY TIMESTAMP')
   say "The file" targetfile " was last modified " filedate
   /* See http://www.rexxla.org/About_Rexx/mfc/datec.html */
end

/* trap execution so error message does not show */
exit

usage:
say "Usage: rexx filedate.rex filename"
return

I was quite surprised to find this, because I've searched through my books and searched online tutorials for a few months looking for this. Then, suddenly, here it is right in front of my eyes. To use this, open a terminal and type rexx filedate.rex <filename> and it will display the date for that file. Replace the filename in angle brackets with the file you are interested in (skip the angle brackets, too).

This is the kind of thing that we want to be able to whip up fairly quickly in response to the needs of our users.

Depending on the schedule and events, I should get a usable version of the sort-JPEGs-by-date script up shortly.

Blogged with Flock

I'm Working On It ...

2007-04-28T12:59:00.000-07:00

Just to let you know, I have not completely abandoned this blog. Although there is a good chance that I might move its contents to my own domain soon, I have not yet made that decision.

There are a couple of postings that are in the composition stage, but which might take a while to complete. Get the feed from Feedburner if you want to catch them when they are up. This way, you'll still catch them if I move the blog off of Blogger.

Finally, Files

2007-03-10T18:14:00.001-08:00

I know. It has been a long time.

Let's move quickly on to files. This information is available in Down To Earth REXX, by Bill Schindler.

Some new keywords:

DIRECTORY() -- used for retrieving the current directory and for changing to another directory. Will return a value, which will litter the screen if you do not have a variable to hold it.
LINEIN() -- used to read one line from a file or from the standard input stream if a filename is not specified. Returns the data (contents) of that line.
LINEOUT() -- used to write one line to a file or to the standard output stream if a filename is not specified. Returns a code indicating success or failure of the write, which will litter the screen if you do not have a variable to hold it.
CHARIN() -- used to read one character from a file or from the standard input stream if a filename is not specified. Returns the data (content) of that character. I am not certain that REXX implementations are Unicode-aware. This means that it may be possible that CHARIN() gets only a portion of a multi-byte character.
CHAROUT() -- used to write one character to a file or to the standard output stream if a filename is not specified. Returns a code indicating the success or failure of the write, which will litter the screen if you do not have a variable to hold it. As with CHARIN(), I am not certain whether CHAROUT() is able to handle multi-byte characters.

Like most computer languages, REXX views input and output as sequences of bytes or characters flowing in or out of the system. These are what are called streams. The standard output stream is usually directed to the screen or console. The standard input stream is usually derived from the keyboard. Either stream can be redirected to or from another location, such as a file.

These are your basic functions for dealing with files. A simple example:

#!/usr/bin/rexx /* If not using Unix or Linux, remove these first two lines. */ /* filetest1a.rex: Just a simple demonstration of using files. */ /* We take a user-entered name and save it to a file. */ cur_dir = DIRECTORY() new_dir = DIRECTORY('./data/') SAY 'Enter a name: ' PULL aname /* NOTE: Will capitalize the name. */ rc = LINEOUT('afile.txt', aname) /* Notice: we did not have to "declare" a file or a filetype. * Nor did we have to worry about "file handles". * With REXX, you usually can write to the file and it will be created if * it does not exist. */ SAY 'We stored the name' aname 'in file afile.txt.' newdir = DIRECTORY(cur_dir) EXIT

This example accepts some information from the user and stores it in a file. If you use this, be aware that it expects there to be a subdirectory named 'data'. This example could easily be made better: the line rc = LINEOUT('afile.txt', aname) appends the information to the file if it already exists. In this case, the companion script only reads the first line of the file, so we should change it to rc = LINEOUT('afile.txt', aname, 1)

Like the *OUT() functions above, DIRECTORY() returns either the current directory or a return code, depending on how you use it. It is advisable to place that value in a variable, so that the screen does not fill with error or diagnostic messages.

#!/usr/bin/rexx /* If not using Unix or Linux, remove these first two lines. */ /* filetest1b.rex: Just a simple demonstration of using files. */ cur_dir = DIRECTORY() new_dir = DIRECTORY('./data/') aname = LINEIN('afile.txt') SAY 'Name stored in file afile.txt:' aname new_dir = DIRECTORY(cur_dir) EXIT

This is the companion to the first script. We change into the data subdirectory, read the first line of a file, and display that line on the screen. I want to mention that both of these were written on Linux. The line that says new_dir = DIRECTORY('./data/') might need to have the slashes changed into the system path separator for your operating system, such as backslashes on Windows.

These are trivial and useless examples, but they exist so that you can follow along at home, building your own working and useful projects out of these pieces.

technorati tags:REXX, file-handling

Blogged with Flock

Linux Zone Features REXX Text Processing

2007-03-08T23:05:00.001-08:00

This article is not new, but I wanted to mention it anyway. http://gnosis.cx/publish/programming/rexx.html discusses using REXX's built-in string processing functions to help perform text processing. This could be used, for example, to pull information from one or more text files to create summary reports.

The example that comes to mind is of a VOIP switch (which routes telephone calls across the Internet in order to give the company more control over its costs and reliability and quality of service). Many of them have a serial cable that enables them to give logging information to a computer. Using some software to receive this data stream and produce a daily log file, one could have a REXX script that goes through that file each day to produce a report of incoming versus outgoing, long versus short, call totals, and call average.

One could probably do something like this using standard Unix utilities like sed and awk, or probably even easier in REXX or Perl or Python or Ruby.

We are about to cover some file-handling, and then we'll want to try and develop a simple text-file processing script in REXX.

Tags: REXX

Keyboard Input

2007-02-13T18:13:00.001-08:00

Like most programming and scripting languages, REXX looks at input and output as streams, or sequences of characters coming in or going out of the script. Input can be things like typing at a keyboard, reading a file, or downloading from a remote server. Output can be things like displaying on the screen, or saving to a file, or even uploading to a remote server or client.

The traditional model for a simple program is INPUT, PROCESS, OUTPUT. We talked about screen output already. Today we are discussing keyboard input.

In REXX, we can use:

PULL - takes user-entered data up to the first ENTER character. This input is converted to all upper case. Remember that REXX started on mainframes back when most data was upper case. It is then assigned to a variable.
PARSE PULL - same as PULL, except it leaves things in the original case.

#!/usr/bin/rexx
/* If not using Linux or Unix, remove these top two lines. */
/* pull-example.rex : simply shows how pull works. */
SAY "What is your name?"
PULL username
SAY "What is your address?"
PARSE PULL whereulive
SAY "Your name is" username
SAY "Your address is" whereulive
EXIT

If you type this in and save it as "pull-example.rex", you can test these things out. You will see that your name will always be fully-capitalized, while your address will keep the same upper and lower case that you enter.

In this case, we did no processing, merely spit the data back out at the user. We did not even make sure our data was clean (no unexpected input that could have negative effects on what our scripts do).

I encourage you to experiment with keyboard input and screen output in your REXX scripts. Be aware that you will soon tire of having to enter the same data repeatedly. This means that it is time for us to cover files soon.

Until next time, remember to practice REXX daily and you will soon find yourself figuring out how to do things you never thought possible.

technorati tags:REXX

Blogged with Flock

Time Off

2007-02-11T20:04:00.000-08:00

I am posting a little less frequently right now. There are a few reasons. I have a total of four blogs, two on Blogger, two on WordPress. Since the dashboard on WordPress is several orders of magnitude better than what is available with Blogger, I tend to spend more time and energy over there, even to the point of considering moving these two over there.

Also, I am running into some tasks with REXX that I haven't yet learned to perform. For example, I wanted to take a directory of JPEGs and sort them by date, creating a new subdirectory for each date and putting the photos in the appropriate directory. However, I have not yet found how to get the date with REXX. Creating the directories would generally take a call to the operating system.

On the other hand, with REBOL, it appears to be much simpler. I have not yet found out how to get the date information in REBOL either, but if I do, there will be another project around the house that goes to another language (Perl, Java, Python, REBOL, Squeak SmallTalk, Pascal, ...) because I didn't have time to figure out how to do it with REXX.

I am not giving up on REXX. I have already committed myself to finish some things that I have started. However, I may be less active for a month or two. I'll still post as I learn more, but I'm busy trying to learn REXX, REBOL, Squeak, and Italian at the same time. I also want to move on to learning more about Open Object REXX. I feel that it is likely to have more built-in functionality that I'm having trouble finding in standard REXX.

REXX & System Commands

2007-01-29T22:02:00.001-08:00

Chapter 6 of Down To Earth REXX, by Bill Schindler, discusses executing system (OS/2 in this case) commands from your REXX scripts. Essentially, REXX passes anything it does not understand to the operating system's command interpreter. However, it is possible to confuse the REXX interpreter or to have it send the command in a manner that confuses the shell (command.exe, cmd.exe, bash, sh, csh, or whatever). In order to prevent this, he recommends that all commands be enclosed in quotation marks, either "double quotes" or 'single quotes'.

This is a good book, even if it is focused on OS/2. I would recommend its purchase. I do not have an Amazon store, so I don't get any money off of it, but the book is solid.

In chapter 6, there are a few ways to access system information:

DIRECTORY(): returns the current working directory; to change directories, use DIRECTORY('dirname'), where dirname is the name of the desired directory.
SETLOCAL: saves the current directory and some environment settings. I thought it was an OS/2-only thing, but it works (sometimes) in Linux also.
ENDLOCAL: returns to the latest values saved by SETLOCAL.

I was struggling with one REXX script, where I kept trying to get it to use a data file in a separate directory. 'cd ./data' would not work reliably. Now I know why: there is a way built into REXX to do this.

One thing that you probably do not want to do (in real life, as opposed to teaching yourself how to use REXX) is use REXX to convert existing batch files & shell scripts, unless you are adding some functionality to them. Unix / Linux shell scripts, for example, have a great number of tools that they can access directly, where REXX would be likely to call the shell to execute the same tool and possibly require a work-around to get the results back into your script. Batch files (DOS, OS/2, or Windows), on the other hand, are much less powerful. REXX may indeed be a viable tool to replace some batch files, although it might be better to use KiXtart for this. KiXtart documentation is available from ScriptLogic.

Stay tuned. There is more to come... :-)

technorati tags:REXX, books, scripting, system+commands

Blogged with Flock

REXX Plux XML and ODF

2007-01-29T21:22:00.000-08:00

Using REXX With The Free OpenOffice.org Office Applications Suite And With XML Files

We are going to do a lot of basic stuff before this actually gets posted, but I'm starting on this now, in December of 2006, so that I have a clear objective in hand.

Essentially, whether you are using Regina REXX or Open Object REXX, you will want to get the following (this assumes that you are using Windows, but we will also do this with Linux):

* REXX interpreter
* RexxXML, from http://home.interlog.com/~ptjm/rexxxml100.zip
* RexxTrans from http://sourceforge.net/project/showfiles.php?group_id=30841
* The following packages:
http://www.zlatkovic.com/pub/libxml/libxml2-2.6.26.win32.zip
http://www.zlatkovic.com/pub/libxml/libxslt-1.1.17.win32.zip
http://www.zlatkovic.com/pub/libxml/iconv-1.9.2.win32.zip
http://www.zlatkovic.com/pub/libxml/zlib-1.2.3.win32.zip

All of the DLLs from these packages need to be in a directory in your PATH. What I did was log in with administrator rights and create a directory C:\lib\ and put them there, then right-click on My Computer on your desktop, select Properties and find the page where it has a button labelled "Environment Variables". Add that directory to the end of the PATH variable, separating it with a semi-colon (;) from the preceding PATH segment.

For some of the other things we will attempt, I would suggest that you download this PDF: http://wi.wu-wien.ac.at/rgf/diplomarbeiten/Seminararbeiten/2006s_wu/20060628_BSF4RexxSnippets_version_4.pdf and the code examples for the PDF: http://wi.wu-wien.ac.at/rgf/diplomarbeiten/Seminararbeiten/2006s_wu/20060628_BSF4RexxSnippets_code.zip

By the way, I got this information from a post by Salvador Parra Camacho, http://groups.google.co.uk/group/comp.lang.rexx/browse_thread/thread/515489f2e835fe70/563f17db4f438fe5 . There is a wealth of information available on the Web, with some additional information sometimes available on other parts of the Internet (e.g., Usenet Newsgroups and the occasional gopher site).

If you are using Linux (or another Unix-like operating system), you should be able to get zlib, libxml2, and libxslt from your distribution repositories, if they are not already present.

REXX Expressions & Operators

2007-01-27T16:54:00.001-08:00

We need to do something with our REXX scripts. The way we do this is with expressions and operators. For example, we frequently need the script to remember a value for later reuse. In algebra, we might say a = 7. In REXX, we do almost the same thing: dishesWashed = 7.

These examples were both variable assignment. We took a value and said we wanted to store it in a variable. A variable is named that because its value can vary. In each case above, the variable holds a value of 7. One difference between variables in algebra and variables in REXX is REXX variables work out to being code-names for particular spots in the computer's memory. We never have to know that the variable banana is found at the corner of Main Street and I Avenue--the computer takes care of all that for us.

The Kilowatt Software REXX tutorial's page on expressions has some examples and discussion that is helpful. When you are learning REXX, I suggest that you start out by having the tutorial site open while you work. This is what I have been doing.

In algebra, operator precedence is frequently described by using "My Dear Aunt Sally". This is a memory aid to teach you that multiplication goes before division (actually, they are of equal precedence), followed by addition and subtraction (again, addition and subtraction are actually of equal precedence). In REXX, the algebraic precedence is only part of the full precedence chain.

Kilowatt's tutorial tells us that "prefix operators" (such as + [positive], - [negative] and the two ways of entering the NOT operator ¬ and \), are followed by the power (exponent) operator, followed by multiplication and division, followed by addition and subtraction, followed by concatenation (taking two pieces of data and forming one long text string out of them), followed by comparison, followed by the AND operator, followed by the OR operators. All this means is that if an expression contains more than one of these operators, the work will be performed by doing the highest precedence operations first (from left to right), then dropping to the next level of precedence. Parentheses [( and )] can be used to change the order, since whatever is inside of parentheses goes before any of the operators.

I do not know if I made it clear. Just remember, when you took algebra, there was a certain order that you did operations in, so that consistent results could be obtained. REXX's operations follow a similar order, for the same reason. If they didn't do this, we could have different results to an expression, depending on whether we were using Open Object REXX, Regina, or ROO.

I encourage you to walk through this tutorial, trying out different ways to use expressions and operators. Use the SAY instruction to see what your results are.

Screen Output In REXX

2007-01-24T20:32:00.000-08:00

Screen Output

The SAY Instruction

Your REXX script will usually display some sort of output on the screen. For that purpose, REXX provides the SAY instruction. Like other REXX instructions, SAY can be written in either upper or lower case or any mixture of the two. Both because of the mainframe heritage of this language and because of readability (it makes it easier to see the instructions).

An example:


/* REXX Example: say-example.rex*/
/* Display values */
SAY "I love purple dinosaurs."
SAY 99
arthur = "Banana flavored yoghurt with chocolate sprinkes is my favorite food."
SAY arthur
EXIT

Save that as say-example.rex. Then open a command window and navigate to the directory where you saved it. Enter rexx say-example.rex to see the output.


I love purple dinosaurs.
99
Banana flavored yoghurt with chocolate sprinkes is my favorite food.

REXX treats all data as strings of characters, which makes it very simple to display something on the screen with REXX. On the third line, we have a literal string (meaning that we literally told it what to use). The next line is a literal string as well, even though it is really a number. The next two lines have a variable that is assigned a string, and then we use SAY to display the contents of the variable.

For more information about the SAY instruction, take a look at the Kilowatt tutorial's page on the SAY instruction.

Simple Example

2007-01-23T23:11:00.000-08:00


#!/usr/bin/rexx
/* If you are not using Unix or Linux, delete these first two lines */
/* rot-13.rex : kid-strength obfuscation */
/* based on a book example */

SAY "Enter a word or phrase to transform:"
PULL unencr

preTrans =  'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
postTrans = 'NOPQRSTUVWXYZABCDEFGHIJKLM'

SAY 'Here it is in ROT-13:' TRANSLATE( unencr, preTrans, postTrans)

EXIT

This simple example does kid-strength obfuscation. Don't use it for anything serious. Enjoy it!

The SAY instruction displays a message on the screen. PULL takes input from the keyboard and changes it to uppercase. unencr, preTrans, and postTrans are variables, which are used to hold information or values in the computer's memory, pretty much like in Algebra class. Finally, TRANSLATE() is a text string transformation function. It takes a text string (one or more text characters), and substitutes anything in it that is found in preTrans with the corresponding character in postTrans. These names are not magical, so you can use different names.

Some of my earlier posts tell where you can obtain REXX for your platform, in case you do not have it installed already.

Variables In REXX

2007-01-08T22:54:00.000-08:00

Variables In REXX

Variable Names

Since REXX allows the use of multiple-character names for variables, all variables should have names that describe their use and purpose. In Down To Earth REXX, Bill Schindler writes, "Variable names like x1 and cc are easy to type, but hard to understand."

Characters Allowed In Variable Names

Letters A to Z, upper or lower case, can be used in any position within a variable name.

Numerals 0 to 9 can be used in any position except for the first character within a variable name.

Special characters _ (underscore), ! (exclamation mark), and ? (question mark) can be used in any position within a variable name, but should not be used as the first character of a variable name.

REXX Keywords

REXX keywords may be used as variable names. The interpreter is usually able to tell whether you mean the keyword or the variable by the way you use it. However, this is confusing and likely to cause programming errors, so it should be avoided.

Datatypes

REXX variables really have one main datatype, the character string. However, based on the content of the variable, REXX can use the value differently. The datatype() function allows us to see whether a value can be used the way we wish. One way to use datatype is this:

PARSE ARG myVariable .

IF DATATYPE(myVariable) = 'NUM' THEN DO

/* whatever we are going to do here */

END

One good thing about this single type is that we can do things like this:

var1 = "1"

var2 = "2"

var3 = var1 || var2

var4 = var1 + var2

SAY var3

SAY var4

Compound Variables

Classic REXX does not have traditional arrays, hashes, dictionaries, lists, or associative arrays. Instead, REXX compound variables are a totally different concept, that is often hard to wrap your mind around. A REXX compound consists of a stem (which is a variable name with a period at the end) and a leaf or tail (a variable name that is appended to the stem). It allows REXX to combine much of the functionality of the above structures into one single type.

The book mentioned above, together with Howard Fosdick's book and Michael Cowlishaw's book are a good way to start out on the REXX road.

REXX Experience and Advocacy

2007-01-06T21:57:00.000-08:00

Cosmogrammticus.rexx discusses how REXX is unappreciated, but at least the OO and Net variants actually have superceded some things, such as stem variables and requiring the use of 'expose' to enable variables to pass to procedures. I am still new to the whole REXX language, but I am already starting to see where some might get the idea that REXX is obsolete.

Is REXX obsolete? I wouldn't say that. Instead, I would say that it offers unique capabilities that can come in handy in certain situations. Having said this, I also recognize that I am still new to the whole REXX thing, while GR most likely has decades of experience with it. I will definitely keep my eyes on his blog.

Unlimited Numeric Precision, Correct handling of decimal numbers, Trace, Parse. Macro support for applications. Metaprogramming, meta classes, builtin Concurrency.

Did you see all the features that REXX has that many of the other dynamic "scripting" languages lack? I'll be adding him to my Blogroll.

Begin At The Beginning

2007-01-04T10:11:00.000-08:00

The traditional beginner's program in any programming language is the "hello, world!" program. We will start with that one:


#!/usr/bin/rexx
/* If you are not using Linux or Unix, delete the first line */
/* hello.rex:  A traditional "hello, world" program for REXX */

SAY "Hello, world!"

Let me point out that many of these will be done in a Linux environment, where the first line above will use features that are not present in DOS, OS/2, Windows, or other environments. Therefore, if you are not using Linux or Unix, remove the line that begins with '#!/usr/bin/rexx'. If your REXX interpreter is in a different location, change the line to reflect its location on your system. (I believe Regina installs to /bin/rexx and /bin/regina.) You can launch the above script like this: rexx hello.rex, using a command window and changing into the directory where your script is stored, assuming that your system can find REXX.

This can be pretty boring, so let's add a little something to it:


#!/usr/bin/rexx
/* If you are not using Linux or Unix, delete the first line */
/* hello2.rex:  A traditional "hello, world" program for REXX */
arg username .

IF username = "" THEN
DO
   username = "O Mysterious One Who Did Not Tell Me Your Name"
END

SAY "Hello, world!"
SAY "Hello," username"."

You can launch this one the same way as the first one: rexx hello2.rex. Your second try, do it this way: rexx hello2.rex Eduardo. Try it out!

Now, it turns out that this one used a variable, which it filled with something you typed on the command line. We will cover command line arguments in a future installment, but here is an example of how variables work:


#!/usr/bin/rexx
/* Be sure to remove the first line if you are not using Linux or Unix. */
/* varexample.rex: Some examples of what a variable is like in REXX. */

/* Undeclared variables have a default value: the variable name in 
   UPPERCASE                                                        */
SAY "Uninitialized variable 'uninitialized' has the value:" uninitialized

numeric = 1
SAY "Numeric variable initialized with 'numeric = 1' has the value:" numeric
SAY

textstring = "Do you see this?"
SAY "Text string variable initialized with ""textstring = 'Do you see this?'"""
SAY

SAY "Uninitialized compound variable 'stem1.tail' has the value:" stem1.tail
SAY

stem2. = "Eduardo"
SAY "Initializing 'stem2.' to 'Eduardo' gives a default value, so stem2.tail =" stem2.tail
stem2.tail = 4
SAY "Unless we give a value to stem2.tail: 'stem2.tail = 4', so stem2.tail =" stem2.tail
SAY

With this start and the Kilowatt Software tutorial mentioned in the Resources article, plus the SHARE tutorial, you can begin to try out different things in REXX. On OS/2, REXX scripts generally use the *.cmd name. You can associate that extension in Windows, or you can just name your scripts with *.rex. If you use *.cmd with any other language, leave it alone.
Until next time, arrividerla.

REXX in Virtual Machines

2007-01-03T17:24:00.000-08:00

As I stated in this article in Free and Open, I am building a couple of virtual machines for some of our upcoming learning activities. It might be a good thing for you to follow along, as you may want to do something similar. It makes you more able to try things out if you know that you won't ruin what you have by trying it.

My Gentoo Linux machine has Regina REXX installed from their repositories. The Fedora Core 6 VMs (once they are completed) will have Open Object REXX 3.1 installed, as that is available from Fedora's repositories.

REXX Tools on SourceForge

2006-12-31T10:42:00.000-08:00

Over the past few months, as I have looked into the REXX language, I have looked over the REXX tools on SourceForge. I intend to go through the list this year, trying each one out, and showing how we can use them to help smaller businesses do their work better, faster, and easier.

For those who use Ubuntu Linux, I believe the Regina REXX interpreter is available from your repositories. For Gentoo users, Regina REXX is available, but the latest version is 3.1, instead of the 3.3 that you can get if you go directly to the site. For Fedora users, Open Object REXX (which is not a SourceForge project) is available from your Extras repositories. Thus, you can start out with REXX without having to do anything unfamiliar like type in./configure && make && make install in a command window.

For users of some operating systems (BeOS comes to mind, which means that all of the BeOS clones such as Haiku should also be like this, and also OS/2), there is a REXX interpreter built in, as an integral part of the system. I was going to check and see if NetBSD has it, but I run it inside a virtual machine, and I decided that I am going to create a new one from scratch for an article on Free and Open, my tech blog.

Regina REXX cross-platform interpreter

REXX/SQL

The Hessling Editor - a text editor that supports REXX macros

REXX/CURL - access to URL-addressable resources

REXX/gd - a wrapper that allows creation of images in REXX

REXX/Trans - which I do not think I will be covering for a while

REXX/DW - a GUI library for REXX (Win32, OS/2, GTK+)

REXX/tk - another GUI library for REXX

REXX/curses - curses (commandline GUI) interface

Rxsock - TCP/IP sockets library

REXX/Wrapper - wraps REXX source code into an executable

That is not to say that we will get to all of these or become proficient in all of them over the course of the next year, but we will try to become acquainted with some of them enough to use them intelligently.

Since we are really targeting beginners at using REXX, I would love to hear some tips and pointers that will help a new user get up to speed quickly with REXX. So go ahead and leave comments.

Why REXX?

2006-12-27T20:34:00.000-08:00

There are plenty of other languages out there. General and special purpose programming languages, markup languages, and the lighter-weight programming languages that we call scripting languages. Why not choose one of those languages?

To some degree, any programming or scripting language might meet our goals. I firmly believe in the plumber principle: If a plumber comes to fix your toilet and he has only one tool, no matter how wonderful that tool may be, send him away and call a different plumber. A good plumber will have a wide variety of different kinds and sizes of tools, so that he is equipped to perform most of the tasks he may be called upon to perform. Can you imagine a plumber fixing your toilet with a hammer? Well neither should a programmer solve your problems with only one tool, no matter how wonderful it is.

I tend to choose tools that will work on multiple platforms, such as REXX, REBOL, Python, Ruby, Perl, C, C++, and Pascal. I have even looked into XBasic from time to time. REXX is a fairly easy language to learn and use, having only a few keywords to learn, and resembling BASIC in its syntax. REXX is descended, I've read, from PL/1.

REXX is still actively developed and growing, with several zero-price and commercial interpreters available. As a "glue" language, it is designed to work well as a macro language for applications.

But I guess when you come down to it, a language is a personal choice, and must be made based on personal criteria. I would love to learn all computer languages, just as I would love to learn all human languages. Since I cannot do either, I must learn the ones that are easiest for me first, so that I can then go on to tackle the more difficult ones. Besides, if you read this far, you really should go and get Regina REXX or Open Object REXX and a couple of books and give it a go.