Is ARexx A Dinosaur?

Software development has many advancement that our everyday society thrives and needs, yet the common man and women do not understand how useful it really can be to our everyday lives. Many these days think Facebook or Twitter represents the entire cyber world; it takes several programming formats and interpreters to just make the common function of a login or password work, debugging this myth.

When presented with the question what’s software development? Or how can cyber development really affect me? Let’s go through a brief history of where many companies get their software text-based editor to create these monopolies of tech.

All software devolvement starts with some line of code, and some interpreter that distinguishes and follows a set of parameters their after. This can become repetitive, to the point software developers create literal and argumentative data metrics that can run these programs, yet every program uses different language formats.

ARexx uses a standard language Rexx that mirrors javascript very closely, its goal is the same; to make scripting fast, easy, and reliable, a true precursor to python.

History

The software text editor that was first created in the ’80s, with a little research you’ll see that ARexx’s introduction came just before the introduction of the home computer when communication between apps and functions were still minimal and a home screen on a computer was not a thing yet. Therefore, extracting data, manipulating it, and re-processing the info, then displaying the info to a word processor document all in one script; what a big deal at the time, which is still relevant to this day.

This process is called a shell and the sole purpose of Arexx, it builds shells around the current Rexx language and allows it to pull and place crucial info. This can also be labeled as a signal;

Macros are used to make a sequence of computing instructions available to the programmer as a single program statement, making the programming task less tedious and less error-prone. (Thus, they are called “macros” because a “big” block of code can be expanded from a “small” sequence of characters.)

How is Arex’s language a macro?

Arexx (REXX) pulls data as part of a programmable request where the information is easily stored for quick reference in a directory or dictionary. Then executes these using the primary Arexx support scripts

Here are examples of the scripting language that resembles python.

/* Main program
The below program is used to add numbers
Call the add function */
add(500000000000,6000000000000000000000)
exit
add:
parse arg a,b
say a + b

The above /* Main program runs the addition of two large integers, this shows the capacity and limits the program can maintain.

We see the main variables in a list type setting representing (a,b) format in the beginning.

We exit our variables and integers, then add an argument to the program using our assigned variables.

Finally, we type “Say” much like “Print” to produce the augmented argument.

Here we see the introduction of more complex statements and operators that can be done along with addition. These resemble common mathematic terms we normally see in equations, the difference with this programing style is the introduction of literal and variable statements

The main justification for software programming is the way they can maintain controlled repetition through loops.

Loops execute several statements, tell an argument is satisfied. You’ll see this when the assigned variable sits across the constant

/* Main program */
do i = 0 to 5 by 2
say "hello"
end

The above formula shows I, a variable that must be equal to a higher number to execute the underlined operations. The value count of I is set to zero, then slowly rises in increments of 2 tell its value is not greater than 5. Executing the program 3 times before completely ending.

Once the above operation is met the bottom executes and performs the final operation ‘Say’, another form of print. The output will read:

Hello

Hello 3X executions ( Controlled repetition statement)

Hello

These allow for the compiling and testing of smaller scripts that will print to the user’s screen. This is extremely useful, being able to assign a formula to a function, having it operate a specific amount of times with recall ability.

Now we’ve seen controlled repetition and basic numeric number manipulation, we can have a better understanding of how the If-then statements function.

The first decision-making statements come from the If, a Boolean expression followed by several statements.

The next is the If-else statement that can be followed by other else statements when the current proves to be false.

/* Main program */
i = 50
if (i < 10) then
do
say "i is less than 10"
end
else
if (i < 7) then
do
say "i is less than 7"
end
else
do
say "i is greater than 10"
end

The general outline above can be simplified to a generic form for easier clarification

select
when (condition#1) then
statement#1
when (condition#2) then
statement#2
otherwise
defaultstatement
end

Each statement declares and evaluates different conditions, that subsequent statement must execute if the statement proves to be true.

The otherwise statement at the end allows the execution of a condition when all statements prove not to be true, a final default solution

After breaking down the basics of our program in REXX. We can easily see how the comparison operators are the only distinguishing factors that separate each statement, and how these values can be very minimal or very large.

Rexx defines its integers into three different categories:

The basic integer where a number can be between -2147483648 and its positive limit 2147483647 but no decimals

The big integer, a number that doesn’t contain a decimal point and is between -9223372036854775808 and its positive mirror limit.

Decimal, where the max and min are the same as the big integer but limited to the placement of the decimal and its significance of precision to the actual number.

Float, numbers that use scientific notation as an exponent identifier.

Now that we’ve seen explicitly what each argument can do, how it can be broken down to a generic form for an easier understanding of the operation. Let’s look into what a sample program would like with all these arguments combined and interacting in one Rexx program.

The above is a sample of code that inputs phrases of time to the common format after extracting the information from another program that simplifies and streamlines the input to a compatible format.

This is how Rexx is written, simple integers and literals with commented lines, statements, and arguments that offer detailed loops and if statements to process one’s information

Then we’re introduced to the first set of functions and commands that assign parts of the formatted dates to parts of the inputted integers, XX, YYYY, MM Day Year-Month

Next, the script determines what an invalid input would look like and how to react to that syntax error, this is important in specific equations where the input must be in a particular format. Int(input(‘Worded Format’)) gives more understanding to the user.

Finally, we arrange the format we’d like to present the input to now that we’ve distinguished what’s what.

Notice how they can easily be used for left, right, and forward commands for a robot with simple manipulation?

If-Then-Else Expressions; True or False operating arguments around expressions.

Entering Rewrite Rules; this operator is equivalent to the function call where assignments are undefended literals, for the formula to rewrite.

Now that we know the history and a slight understanding, let’s talk about Arexx’s main and most powerful feature.

ARexx’s principal strength is that it allows you to write scripts that can talk to “hosts”; that is, any application that has an ARexx port. This allows ARexx to control the application (within the limits of what features it exposes to ARexx). As a single script can communicate with multiple hosts, it can coordinate activity between applications. Any command doesn’t understand, it forwards to the currently selected host. By default, the host is the shell itself.

This allows us to distinguish what was calling or searching in from a function library, so if we wanted to print the single macro from a specific application, built-in function, or internal function, etc.

That is how we get to where we are now with Arexx a for of Rexx but a do for the specific version of Amiga computers. leading a crucial path to the development and everyday shortcuts that you see in all types of interrupters today. Without it, we could see larger files and larger operating time in between arguments.

Platform

ARexx is an implementation of the Rexx language for the Amiga computer, so its platform is very specific, but when you understand that it’s software built specifically for this machine. We understand it’s a series of built-in functions, support functions, search order, and finding functions, that process existing applications to one main interface.

Here you’ll see the specific capabilities of the Arexx platform and how it’s main focus is that of the Amiga Os.

A simple ARexx program could be written to print a warning message on the screen of the monitor, or play an audio alert signal if a certain Amiga program stops, faults, or has finished its scheduled job.

The following script is a minimal ARexx script that displays warnings depending on events that take place.

We use If statements to separate each literal that we won’t display, then assign each to a number we can recall to display a literal as a warning message. Not only can we use this later in the coding process but it saves operating time as printing an event is now as simple as event = 3.

Pros

The amount of different abbreviation search controls contained and their accessibility through Rexx is almost infinite and could only be compared to C++ originating around the same time. Though it does not just stop there, the creation of dynamic abbreviation expansion was also created, allowing recalled information to be located and highlighted.

Example of an implementable feature.

If the end-user is using a program that builds animations by joining various bitmap image files but which lacks image processing capabilities, he could write an ARexx script that performs these actions:

1. ARexx locates the image files in their directories

2. ARexx loads the first image

3. ARexx loads paint program

4. The image is loaded into a paint program which performs modifications to file

5. The modified image is stored in another directory

6. ARexx repeats the procedure on any image in the directory

7. The paint program is closed and the animation program is loaded

8. The animation is built

9. The animation is saved in its directory

10. The animation program is closed

Cons

Arexx is Os specific its predecessor Rexx is the more common language that carries over all its features, but being Os specific means updates or changes to the software are less common and patches become more blog-type; small community programmers.

We have also come along way in the development of shortcuts, Rexx has built-in copy and past features but its shortcuts are keyed differently meaning the same shortcut can be used on different interacting applications.

Trend

The trend of Arexx is on a major decline over the past 20 years, as all technology is expected to do; new advancements in software arithmetic are more common than not, just like the new car model of the year.

Though it could not be considered out for the count, as Rexx is known to be so versatile and combine's with robotic machine learning like ROS, Qt Creator, and GTK term.

What’s this all mean? Those who use Rexx still are some of the best developers to date, not only is their understanding deeper, but the amount of knowledge required to use it shows the amount of dedication and respect they have towards software development.