[netrexx-course] Lesson 1 repost

[dIon Gillard/Multitask Consulting/AU]

Even though this is in the archives, I'll repost it here....as requested.





dIon


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 -------