[netrexx-course] Lesson 1 - Text

[dIon Gillard/Multitask Consulting/AU]

Lesson 1 - Intro to the NetRexx Language

Welcome

Welcome to Lesson 1 of the NetRexx Course.

This lesson is an introduction to the NetRexx language - what it is, where
it comes from, what you get with it, how you can use it, and details about
its syntax. Hopefully by the end of this lesson, and by performing some of
the suggested exercises, you will understand more about NetRexx and it's
environment. Scattered throughout the lesson you'll find several 'pop quiz'
questions. If you are unsure of the answer, feel free to either email me
(mailto:[hidden email]) or the NetRexx Course mailing list
(mailto:[hidden email]).


What is it?

"NetRexx is a programming language derived from both Rexx and Java. It is a
dialect of Rexx that retains the portability and efficiency of Java, while
being as easy to learn and to use as Rexx." - Mike Cowlishaw, inventor of
NetRexx.

NetRexx is a computer programming language. It's history comes from Rexx
(see http://www2.hursley.ibm.com/rexx), a human oriented programming
language, and a far more recent language, Java (see http://java.sun.com).
Because of this, NetRexx is really a hybrid language - Rexx moulded to fit
desirable features of Java. Having said that, NetRexx is still a
programming language, and theoretically it need not be compiled to java
executable code, someone could write a NetRexx compiler to produce native
Unix binaries for example.

The 'reference implementation' of NetRexx (the original implementation
provided by Mike Cowlishaw of IBM UK Laboratories, who invented the Rexx
programming language), comes with a compiler that takes your NetRexx source
code and compiles it into executable Java binaries called byte code. So
that means that programs written in NetRexx will run just like java
programs. If you've heard of Java applets or servlets, theses are just
special sorts of executable java binaries. They, too, can be written using
NetRexx. The good side to all of this is that any NetRexx program can be
run anywhere Java is installed, making NetRexx programs VERY portable. In
fact, almost every recently developed or enhanced operating system has Java
available.

The NetRexx compiler, the tool that turns your source into executable byte
code,  is actually written in NetRexx. Mike Cowlishaw said at one point
that it took 19 years to get Rexx ported to it's current set of platforms,
but converting the NetRexx compiler to NetRexx source (from it's original
Rexx source code on OS/2) took 3 weeks and runs on more platforms! (Correct
me if I've got it wrong Mike or anyone else). Now that's productivity.

To program in NetRexx you don't have to know anything about Java. But to
write useful programs with NetRexx, you will. So part of this course will
be about explaining how Java works. Don't be worried if you currently know
nothing about Java, we'll gradually fix that problem.

Pop Quiz: Define NetRexx.

What do I get with NetRexx?

I'm assuming you've downloaded and installed NetRexx. You need Java
installed to anything useful with NetRexx, so here's hoping you've
downloaded and installed Java 1.1 or higher as well.

When NetRexx installs, it creates a directory (e.g. c:\NetRexx or
/usr/NetRexx) to hold it's files. To complete the install, you should have
taken the nrtools.zip file from this directory, and unzipped it into your
Java installation directory (e.g. \java11 or /jdk1.1.6). This step adds
important files to your computer:
    NetRexxC.zip - the executable code for the NetRexx compiler
    NetRexxR.zip - the NetRexx run time code
    netrexxc.cmd, netrexxc.bat, nrc.cmd and nrc.bat - a batch file to make
executing the compiler easier
    hello.nrx - some sample NetRexx code to test the compiler and your
installation

In the NetRexx installation directory (e.g. c:\NetRexx or /usr/NetRexx),
there are many useful files to help you with developing in NetRexx.
Starting with the HTML documentation, netrexx.htm, moving along to the many
samples that are worthwhile understanding as we continue with the course.
All the samples will have a .nrx extension, e.g. Hello.nrx, Buttons.nrx,
HelloApplet.nrx.

--
Pop Quiz: What's the simplest way of executing the NetRexx compiler for
your platform?

Writing And Compiling NetRexx Code

Ok, lets move on to some more practical matters, like writing code.

NetRexx is really an object oriented language, but don't let that scare
you, it's also a human oriented language, and that makes it far easier to
get your work done than with almost any other language. For example, if you
ask a friend the telephone to "Go buy some bread" is that any different to
asking them to "Go buy some Bread"? Did you pick the difference? To many
computer languages "Bread" and "bread" can be two completely separate
things, although us mere humans usually don't think so.

Tools

To write NetRexx code, you'll need some form of editor to type the code
into. On a Microsoft Windows platform, for example, a simple editor is
Notepad. A more full featured editor is Word Pad. There are also a few
Integrated Development Environments (IDEs) available for NetRexx, devpad
(see  http://www.mygale.org/~lafaix/devPad/ ) and Visual NetRexx (see
http://www.trongus.com/VisualNetRexx/ ) are two.

Compiling

Once you've chosen your tool for now, you'll need to know how to invoke the
compiler. For Windows and OS/2, there are pre configured batch files
(netrexxc.bat, netrexxc.cmd, nrc.bat, nrc.cmd) as a fast path for invoking
the compiler. On other platforms, you'll need to do it "the hard way" by
invoking java with the correct arguments:

    java COM.ibm.netrexx.process.NetRexxC NameOfYourNetRexxFileHere.Nrx

--
Suggested Exercise: Compile and run hello.nrx that the NetRexx installation
supplies. Read the code.

OO vs 'Scripts'

In writing NetRexx applications, you will either choose to ignore OO
concepts altogether and write 'scripts' or get completely carried away with
OO and use it almost all of the time. Writing a script involves only a
subset of the NetRexx syntax, and almost no knowledge of OO concepts.

About Objects

There is a lot of mystique and confusion around Object Oriented Technology.
Mostly, it's because the ideas aren't that well communicated in the first
place. You may skip this section if you feel comfortable with OO technology
and concepts already.

What's an object, and why is OO all the rage?

The first real phase of application development that explained things
simply was Structural (or Procedural) Application Development. This way of
doing development focused on the functionality that the application was to
provide, progressively dividing the task into more manageable 'procedures'
until finally code could be written. This was called top down development.

This had two problems:


   * The functions were completely dependent on the data passed to them by
     other functions. If the format ('type') of this data changed, there
     were changes needed everywhere the data was passed.
   * The functions were an integral part of the application they were
     written for, and on the whole, were not very 'reusable'.

So how did OO solve this problem? It changed the focus of development from
a functional process to an 'object' process, where an object is a logical
collection of functions and the data those functions share. This meant that
the data that was shared by the functions could be hidden from other
objects (called encapsulation), and hence if changes were needed the impact
was far less. Since the functions were now grouped together in some logical
way, they usually provided some sort of service or business process, which
was more likely to be reusable.

Objects have properties (data), and methods (functions) that use those
properties. The objects properties are available for as long as the object
is available, and can change value over time.

An object can be something simple like a button in a GUI:


   *  It has some properties associated with it, things like the text of
     the button, the size of the button, background/foreground colours,
     font used etc.

   * It also has some functionality associated with it, e.g. it can handle
     being clicked, and notifies interested parties when it happens.

Objects can also be very complex. Consider the NetRexx compiler for
example. It knows how to do something extremely complex: read our code and
translate it into java code and then compile it.

Why use OO

Applications developed using OO techniques are different from procedural
applications, in that they are really a group of objects co-ordinated to
get the job done. Think of a car. The car has some properties: an engine,
wheels, doors, a frame etc. It also has some methods: turn on, accelerate,
slow down, turn off. To accelerate the car 'object' co-ordinates with the
engine 'object', which in turn co-ordinates with the wheel objects.
Procedural applications are usually a model a single way of doing things,
where OO applications are are a model of the ways things can interact,
making OO apps far more flexible from the developers perspective at least.

The Class

When coding OO applications, the developer writes a definition for all
objects of the same type, called a class. A class is a template for the
objects to be created, it defines the properties and methods that all
objects of that type will have. For example, if we have our car object, we
can write a class definition for it, like this:
--------------8<----------------------- Cut Here -------
class Car
Properties Inheritable
    anEngine
    wheels
    doors
    frame
method turnOn
    /* put code to turn on the car here */
    Say "The car is on!"
method accelerate(toSpeed)
    /* accelerate the car to the speed passed in the parameter 'toSpeed' */

    Say "Taking it to warp: "toSpeed

/** This method is called when java runs an object from the command prompt*/
method main(args=String[]) static
    car1 = Car()    -- our first car
    car1.anEngine = "Fast"
    car2 = Car()    -- our second
    car2.anEngine = "Slow"
    -- do something with the new cars
    car1.turnOn()
    car2.accelerate(12)
--------------8<----------------------- Cut Here -------