subject:"Rexx numeric digits and scientific notation question"

I was referring to 'I once found CMS ISPF to reauire "address isredit 'isredit 
'".
Otherwise the command went to ISPEXEC.', which clearly is b0rk3n. My apologies 
for not making that clear.

As for "LEAVE = 'date'; LEAVE", it's perfectly valid but don't ever hand that 
in for a class I'm grading ;-)

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Paul Gilmartin <042bfe9c879d-dmarc-requ...@listserv.ua.edu>
Sent: Sunday, April 21, 2024 8:48 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

On Sun, 21 Apr 2024 23:02:56 +, Seymour J Metz wrote:

>Unclean! Did you report it as a bug?
>
I suspect it's WAD (BAD!)
o LEAVE as the target of an assignment is a variable name.
o Otherwise, LEAVE as the first token of an instruction
  is a keywod (LEAVE NAME)
o Otherwise, LEAVE is a symbol which may be a variable name.

For performance, Rexx gives high priority to detecting assignments.

Alas, them's the rules.  What would you report as a bug?
>
>
>From: Paul Gilmartin
>Sent: Sunday, April 21, 2024 11:50 AM
>
>Astonishment factor with such as "LEAVE = 'date'; LEAVE".  No
>Rexx syntax error, but unexpected result.

--
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-21 Thread Paul Gilmartin

On Sun, 21 Apr 2024 23:02:56 +, Seymour J Metz wrote:

>Unclean! Did you report it as a bug?
> 
I suspect it's WAD (BAD!)
o LEAVE as the target of an assignment is a variable name.
o Otherwise, LEAVE as the first token of an instruction
  is a keywod (LEAVE NAME)
o Otherwise, LEAVE is a symbol which may be a variable name.

For performance, Rexx gives high priority to detecting assignments.

Alas, them's the rules.  What would you report as a bug?
>
>
>From: Paul Gilmartin 
>Sent: Sunday, April 21, 2024 11:50 AM
>
>Astonishment factor with such as "LEAVE = 'date'; LEAVE".  No
>Rexx syntax error, but unexpected result.

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

It shortens expressions, upper cases automatically and, IMHO, is more readable.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Andrew Rowley 
Sent: Sunday, April 21, 2024 7:03 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

On 22/04/2024 1:19 am, Seymour J Metz wrote:

>   2. There is a decades-long argument about NOVALUE. I am in the camp that
>  believes the default behavior to be too useful to give up; others believe
>  that it is dangerous.

Genuine curiosity: what is the use of the default behaviour? I have
never been able to see anything particularly useful.

--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-21 Thread Andrew Rowley


On 22/04/2024 1:19 am, Seymour J Metz wrote:


  2. There is a decades-long argument about NOVALUE. I am in the camp that
 believes the default behavior to be too useful to give up; others believe
 that it is dangerous.


Genuine curiosity: what is the use of the default behaviour? I have 
never been able to see anything particularly useful.


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

Unclean! Did you report it as a bug?

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Paul Gilmartin <042bfe9c879d-dmarc-requ...@listserv.ua.edu>
Sent: Sunday, April 21, 2024 11:50 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

On Sun, 21 Apr 2024 15:19:40 +, Seymour J Metz  wrote:

>A few comments.
>
> 1. It's best to avoid names that a,e, or are similar to, keywords.
>
Astonishment factor with such as "LEAVE = 'date'; LEAVE".  No
Rexx syntax error, but unexpected result.

> 2. There is a decades-long argument about NOVALUE. I am in the camp that
>believes the default behavior to be too useful to give up; others believe
>that it is dangerous.
>
I'm inconsistent.  I routinely use SIGNAL ON NOVALUE.  It reports most of
my typos.  I very rarely use "set -o no''unset".  The difference may be due
sh marking variables with '$'.

> 3. T e default environment for statements that are expressions is often an
>application rater than the operating system, e.g., ISPEXEC, IISREDIT, 
> XEDIT.
>That behavior is incredibly useful.
>
Water is wet.  I once found CMS ISPF to reauire "address isredit 'isredit 
'".
Otherwise the command went to ISPEXEC.

--
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

There are languages with a covention that method names end in ain a question 
mark iff they are Boolean.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Robert Prins <05be6ef5bfea-dmarc-requ...@listserv.ua.edu>
Sent: Saturday, April 20, 2024 4:17 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

Try the two characters that are pretty much unique to REXX, "!" and "?"
especially for small local loops.

Robert
--
Robert AH Prins
robert(a)prino(d)org
The hitchhiking grandfather 
<https://secure-web.cisco.com/1CjWWkCtcvllbYna0NsyMECv9i2KfIg00WW6Yy8zbPZbuqNVURWRkkaaDHPSxAZ_golJntB-q0HoHRO4xmjIcVfwgac8gvI2_6SvyVqMCVc8nBCtdx_vO5Q2Mb6qOHdTX83kueLEi2cvem-lpM8UaV0aAwBH0qnnPQiIkLMR7hQBTuXwhq3exW8ZbVHC0J7TTM99lPcVIHdaWP9pe4TrcXgvNwTNKYlBw0xERBl7b02W4mpZgIYGDK1U7nP3xwxQNr4_VOb62DMRnlwtO0arxMzQ7XmC0AUr_AdKYr9LOeWK-o1dHvssi8xa4dh2otNrGqpC7gYoPAmd4FYY9xmEKQFW9YA-PIT0WISlYisIhflCX8DxZSs0aSDaDZwahHyyHa2jShnC3TeZ843rDrfBSLR_W_28JfExRqzKVhvAuiO8/https%3A%2F%2Fprino.neocities.org%2Findex.html>
Some REXX code for use on z/OS
<https://secure-web.cisco.com/1I1tK-MrLJnt0WdLDboV4BPnAvrT6HOway_WfbqRc71O4DYwX2QLPhUWED3iBZa81UrJADr36HbN5u1g3jyqKmBv0piCOFmOc6V913K9OYEEK7V14Ajgt8KD2Jjp6Sg8cJeoCxWESkHKhhZPPwXA_SYdz6-rjucRjHv05hVgJcg41KJ4FbrnfmldqC9DiL0hLKy01Y7dnnLs2CfTHonsMyZna7cWIRmxTApIiNJWZHBWip2YcFhtM5igK5THcJdAebFyfX9CUhqaIF9YN3JkKHPWk2BlDfh8MRTi-MqTu1Q7QLx4yTLpBUNviYRakAswA5ODayfQgbq825wQLtOSw4-WO_rPdAKh5dYUGEnTEn4ihKiQTpDHCUQAc5k_xOEi-uMDQMqcUjPGceoDfu1yzCxtY0Orj__tLTGLTi0koDJE/https%3A%2F%2Fprino.neocities.org%2FzOS%2FzOS-Tools.html>

On Sat, 20 Apr 2024 at 15:08, Bob Bridges <
0587168ababf-dmarc-requ...@listserv.ua.edu> wrote:

> It was while I was coding in REXX that I tried abutting a variable named
> 'x' with another string, and couldn't figure out why the program behaved as
> it did.  Eventually figured out I had inadvertently created a hex
> constant.  Maybe as an overreaction, I have never since used one-character
> variable names, always two or more.  (What do I use for loop counters?, you
> ask.  I use 'j' plus another letter; 'jr' for records, for example, 'jd'
> for days whatever.  More obvious would have been 'i', but there are too
> many two-letter reserved words even in REXX that start with 'i'.)
>
> -Original Message-
> From: IBM Mainframe Discussion List  On Behalf
> Of Andrew Rowley
> Sent: Friday, April 19, 2024 22:41
>
> It doesn't cause a problem except when it does. One danger is a typo in
> a variable name. When I wrote some complex Rexx I did use SIGNAL ON
> NOVALUE, but I wasn't totally appeased!
>
> --- On 20/04/2024 12:41 am, Rony G. Flatscher wrote:
> > Rexx defines the value of variables that have no explicit value
> > assigned to them to be the name of the variable in uppercase, so it
> > does not cause a problem. (It does cause problems for programmers who
> > got trained to always make sure that a value is assigned to variables.
> > This is the reason why ooRexx has an option to activate checking for
> > the use of uninitialized variables in Rexx programs to appease those
> > who are not accustomed to it or feel that it should not be allowed. ;) )
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN



--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-21 Thread Paul Gilmartin

On Sun, 21 Apr 2024 15:19:40 +, Seymour J Metz  wrote:

>A few comments.
>
> 1. It's best to avoid names that a,e, or are similar to, keywords.
>
Astonishment factor with such as "LEAVE = 'date'; LEAVE".  No
Rexx syntax error, but unexpected result.

> 2. There is a decades-long argument about NOVALUE. I am in the camp that
>believes the default behavior to be too useful to give up; others believe
>that it is dangerous.
> 
I'm inconsistent.  I routinely use SIGNAL ON NOVALUE.  It reports most of
my typos.  I very rarely use "set -o no''unset".  The difference may be due
sh marking variables with '$'.

> 3. T e default environment for statements that are expressions is often an
>application rater than the operating system, e.g., ISPEXEC, IISREDIT, 
> XEDIT.
>That behavior is incredibly useful.
>
Water is wet.  I once found CMS ISPF to reauire "address isredit 'isredit 
'".
Otherwise the command went to ISPEXEC.

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

A few comments.

 1. It's best to avoid names that are, or are similar to, keywords.

 2. There is a decades-long argument about NOVALUE. I am in the camp that
believes the default behavior to be too useful to give up; others believe
that it is dangerous.

 3. The default environment for statements that are expressions is often an
application rater than the operating system, e.g., ISPEXEC, IISREDIT, XEDIT.
That behavior is incredibly useful.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר

From: IBM Mainframe Discussion List  on behalf of 
Rony G. Flatscher 
Sent: Saturday, April 20, 2024 1:50 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

On 20.04.2024 17:40, Paul Gilmartin wrote:
> On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges wrote:
>> It was while I was coding in REXX that I tried abutting a variable named 'x' 
>> with another string, and couldn't figure out why the program behaved as it 
>> did.  Eventually figured out I had inadvertently created a hex constant.  
>> Maybe as an overreaction, I have never since used one-character variable 
>> names, always two or more.  (What do I use for loop counters?, you ask.  I 
>> use 'j' plus another letter; 'jr' for records, for example, 'jd' for days 
>> whatever.  More obvious would have been 'i', but there are too many 
>> two-letter reserved words even in REXX that start with 'i'.)

There are *no* reserved words in Rexx like in many other languages. (This 
alleviates one to have to
learn them by heart. But more importantly, should the language get additional 
keywords over time
they would not break existing Rexx programs that happen to use them already, 
unlike other
programming languages.)

> I like to use longer names with mnemonic value as control variables and,
> if the body of the loop is more than a couple lines, cite the control
> variable at the END so the interpreter verifies nesting.
>
> Rexx is chaotic in context sensitivity of reserved words and in symbols'
> being evaluated almost everywhere with exceptions for e.g. ADDRESS.

There are no reserved keywords therefore it is interesting that you see 
something chaotic there. But
maybe some of the fundamental Rexx rules are not really known or possibly 
forgotten over time.

The Rexx rules are quite simple:

  * everything outside of quotes gets uppercased,

  o the content of quoted strings can be anything and never gets changed 
(truly immutable),

  * blanks around operators get removed,

  * a blank between literals and symbols is the blank concatenation operator

  * a symbol that was not assigned a value evaluates to the symbol itself (its 
name which is the
uppercased string), otherwise it evaluates to its currently assigned value

The next step is to determine what kind of an instruction the resulting string 
represents in order
to carry it out:

  * if the second token is an equal sign then it is an assignment instruction 
that gets carried out:
the expression right of the equal sign (RHS) gets evaluated and assigned to 
the symbol (e.g.
ABC=3+4) to the left of the equal sign (LHS),

  * if it is not an assignment instruction and the first symbol is a keyword 
then it is a keyword
instruction that gets carried out,

  * if it is neither then the resulting string is a command instruction which 
gets handed over to
the operating system for execution, the command's return code can be 
inspected immediately upon
return by using the Rexx variable RC (set by Rexx to make the return code 
of the command
immediately available to the Rexx program).

The ADDRESS keyword instruction is just one of the keyword instructions of Rexx 
which will allow to
control to which Rexx command handler the command instruction gets sent to 
(among other things the
ADDRESS instruction allows to switch among different Rexx command handlers).

> Variable precision arithmetic is a boon.  But there is no convenient
> library of elementary functions, probably the reason for the lack of
> elementary functions in Rexx.

This depends what functionalities you are missing/seeking. There are quite a 
few Rexx function
libraries, many implemented in Assembler or C++.

If using ooRexx there is a free, open-source ooRexx-Java bridge available which 
will make
immediately *all* Java class libraries there are and all their functionality 
available to ooRexx,
really, all of them! The external function and class libraries in this case are 
not implemented in
C++ or Assembler, but in Java. And Java has become *fast*, one of the fastest 
languages there is.

If you look at Java and its standard runtime environment (JRE) you hardly miss

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

I frequently use single letter control variables in short DO loops. But my 
primary criterion is legibility.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Bruce Hewson <0499d3d5e892-dmarc-requ...@listserv.ua.edu>
Sent: Sunday, April 21, 2024 12:58 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

Hello Bob,

I use "cnt" for my loop counters. I stopped using FORTRAN style single 
character variable names when I started coding in REXX.

Except I do use them on occasion for building large stem variable lists.

example:-

i=i+1;jcl.i="//BRUCESMP JOB (1234546),'Bruce SMP jobn',"
i=i+1;jcl.i="// CLASS=A,   "
i=i+1;jcl.i="// MSGCLASS=X,"
i=i+1;jcl.i="// MSGLEVEL=(1,1),"
i=i+1;jcl.i="// NOTIFY=&SYSUID "
i=i+1;jcl.i="//*   "

So many ways to use REXX.

Regards
Bruce


On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges  wrote:

>It was while I was coding in REXX that I tried abutting a variable named 'x' 
>with another string, and couldn't figure out why the program behaved as it 
>did.  Eventually figured out I had inadvertently created a hex constant.  
>Maybe as an overreaction, I have never since used one-character variable 
>names, always two or more.  (What do I use for loop counters?, you ask.  I use 
>'j' plus another letter; 'jr' for records, for example, 'jd' for days 
>whatever.  More obvious would have been 'i', but there are too many two-letter 
>reserved words even in REXX that start with 'i'.)
>
>---
>Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-21 Thread Robin Vowels


On 2024-04-21 15:38, Paul Gilmartin wrote:

On Sat, 20 Apr 2024 23:58:18 -0500, Bruce Hewson wrote:


I use "cnt" for my loop counters. I stopped using FORTRAN style single 
character variable names when I started coding in REXX.



I thought FORTRAN allowed six.


It did.  Now it allows many more.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

On Sat, 20 Apr 2024 23:58:18 -0500, Bruce Hewson wrote:
>
>I use "cnt" for my loop counters. I stopped using FORTRAN style single 
>character variable names when I started coding in REXX. 
>
I thought FORTRAN allowed six.

(Be careful how you pronounce that!)

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-20 Thread Bruce Hewson

Hello Bob,

I use "cnt" for my loop counters. I stopped using FORTRAN style single 
character variable names when I started coding in REXX. 

Except I do use them on occasion for building large stem variable lists.

example:-

i=i+1;jcl.i="//BRUCESMP JOB (1234546),'Bruce SMP jobn',"
i=i+1;jcl.i="// CLASS=A,   "
i=i+1;jcl.i="// MSGCLASS=X,"
i=i+1;jcl.i="// MSGLEVEL=(1,1),"
i=i+1;jcl.i="// NOTIFY=&SYSUID "
i=i+1;jcl.i="//*   "

So many ways to use REXX.   

Regards
Bruce


On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges  wrote:

>It was while I was coding in REXX that I tried abutting a variable named 'x' 
>with another string, and couldn't figure out why the program behaved as it 
>did.  Eventually figured out I had inadvertently created a hex constant.  
>Maybe as an overreaction, I have never since used one-character variable 
>names, always two or more.  (What do I use for loop counters?, you ask.  I use 
>'j' plus another letter; 'jr' for records, for example, 'jd' for days 
>whatever.  More obvious would have been 'i', but there are too many two-letter 
>reserved words even in REXX that start with 'i'.)
>
>---
>Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

Well, they may not be reserved, if you say so.  But I think I'd be a fool to 
try using "is", "if" or "in" as a loop counter, certainly for the sake of the 
programmer who inherits my work but I'm sure it would confuse me too.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* When a man is getting better he understands more and more clearly the evil 
that is still left in him.  When a man is getting worse, he understands his own 
badness less and less.  A moderately bad man knows he is not very good; a 
thoroughly bad man thinks he is all right.  This is common sense, really.  You 
understand sleep when you are awake, not while you are sleeping.  You can see 
mistakes in arithmetic when your mind is working properly; while you are making 
them you cannot see them.  You can understand the nature of drunkenness when 
you are sober, not when you are drunk.  Good people know about both good and 
evil; bad people do not know about either.  -C S Lewis, _Christian Behavior_ */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Rony G. Flatscher
Sent: Saturday, April 20, 2024 13:51

There are *no* reserved words in Rexx like in many other languages. (This 
alleviates one to have to learn them by heart. But more importantly, should the 
language get additional keywords over time they would not break existing Rexx 
programs that happen to use them already, unlike other programming languages.)

> --- On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges wrote:
>> It was while I was coding in REXX that I tried abutting a variable 
>> named 'x' with another string, and couldn't figure out why the 
>> program behaved as it did.  Eventually figured out I had 
>> inadvertently created a hex constant.  Maybe as an overreaction, I 
>> have never since used one-character variable names, always two or 
>> more.  (What do I use for loop counters?, you ask.  I use 'j' plus 
>> another letter; 'jr' for records, for example, 'jd' for days 
>> whatever.  More obvious would have been 'i', but there are too many 
>> two-letter reserved words even in REXX that start with 'i'.)
> I like to use longer names with mnemonic value as control variables 
> and, if the body of the loop is more than a couple lines, cite the 
> control variable at the END so the interpreter verifies nesting.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

I've inherited a REXX app from a departed coworker who uses (for example) 
'complete?' as a Boolean variable name, where in REXX I would use 'fcomplete' 
for the same purpose ('f' for "flag").  I see the sense of the question mark, 
but I've been coding too many decades; I can't FEEL it.  I probably won't adopt 
it.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* Crossbows don't kill people; quarrels do.  -from a conversation at a 
Patrick-O'Brian listserv */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Robert Prins
Sent: Saturday, April 20, 2024 16:18

Try the two characters that are pretty much unique to REXX, "!" and "?"
especially for small local loops.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

Ooh, I'm sure I've read that I can do that but I forgot.  I like that - think 
I'll start doing it myself.  Normally I'm rabid about indentation, but 
occasionally in a longer program I lose track of something and have to spend a 
of time searching for where I left out an End.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* Do you know what constitutes a "hate crime"?  Put your thinking caps on.  
What tools do we need to determine whether a crime was motivated by hate or 
prejudice?  Answer: We need thought police.  -from "See, I Told You So" by Rush 
Limbaugh */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Paul Gilmartin
Sent: Saturday, April 20, 2024 11:41
>
I like to use longer names with mnemonic value as control variables and, if the 
body of the loop is more than a couple lines, cite the control variable at the 
END so the interpreter verifies nesting.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

On Sat, 20 Apr 2024 19:50:56 +0200, Rony G. Flatscher wrote:
>...
>There are *no* reserved words in Rexx like in many other languages. (This 
>alleviates one to have to 
>learn them by heart. But more importantly, should the language get additional 
>keywords over time 
>
I disagree.  Although it's context-sensitive.  But ITERATE and LEAVE are
keywords within DO loops, which may not be intuitively obvious.  Otherwise
they would be commands.  RETURN is generally a keyword.  And THEN
is a keyword in an IF.

>they would not break existing Rexx programs that happen to use them already, 
>unlike other 
>programming languages.)
>
Not true.  When I first learned Rexx, A='XYZ'B was legal.  Later, it became
a syntax error.

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-20 Thread Rony G. Flatscher


On 20.04.2024 19:52, Paul Gilmartin wrote:

On Sat, 20 Apr 2024 20:17:36 +, Robert Prins wrote:


Try the two characters that are pretty much unique to REXX, "!" and "?"
especially for small local loops.


Ugh!  But I confess I've done likewise at times.

I tried to refresh my memory and observed that the Rexx Ref.,
SA32-0972-60, is woefully inconsistent in its use f "symbol":

In Chapter 2. REXX general concepts 9
 Symbols:
 Symbols are groups of characters, selected from the: ...

But in Appendix E. REXX symbol and hexadecimal code cross-reference
 "Symbol" apparently means a single character.

Pubs oughta straighten that out.


Or .

---rony

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

On Sat, 20 Apr 2024 20:17:36 +, Robert Prins wrote:

>Try the two characters that are pretty much unique to REXX, "!" and "?"
>especially for small local loops.
> 
Ugh!  But I confess I've done likewise at times.

I tried to refresh my memory and observed that the Rexx Ref.,
SA32-0972-60, is woefully inconsistent in its use f "symbol":

In Chapter 2. REXX general concepts 9
Symbols:
Symbols are groups of characters, selected from the: ...

But in Appendix E. REXX symbol and hexadecimal code cross-reference
"Symbol" apparently means a single character.

Pubs oughta straighten that out.

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-20 Thread Rony G. Flatscher


On 20.04.2024 17:40, Paul Gilmartin wrote:

On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges wrote:

It was while I was coding in REXX that I tried abutting a variable named 'x' 
with another string, and couldn't figure out why the program behaved as it did. 
 Eventually figured out I had inadvertently created a hex constant.  Maybe as 
an overreaction, I have never since used one-character variable names, always 
two or more.  (What do I use for loop counters?, you ask.  I use 'j' plus 
another letter; 'jr' for records, for example, 'jd' for days whatever.  More 
obvious would have been 'i', but there are too many two-letter reserved words 
even in REXX that start with 'i'.)


There are *no* reserved words in Rexx like in many other languages. (This alleviates one to have to 
learn them by heart. But more importantly, should the language get additional keywords over time 
they would not break existing Rexx programs that happen to use them already, unlike other 
programming languages.)



I like to use longer names with mnemonic value as control variables and,
if the body of the loop is more than a couple lines, cite the control
variable at the END so the interpreter verifies nesting.

Rexx is chaotic in context sensitivity of reserved words and in symbols'
being evaluated almost everywhere with exceptions for e.g. ADDRESS.


There are no reserved keywords therefore it is interesting that you see something chaotic there. But 
maybe some of the fundamental Rexx rules are not really known or possibly forgotten over time.


The Rexx rules are quite simple:

 * everything outside of quotes gets uppercased,

 o the content of quoted strings can be anything and never gets changed 
(truly immutable),

 * blanks around operators get removed,

 * a blank between literals and symbols is the blank concatenation operator

 * a symbol that was not assigned a value evaluates to the symbol itself (its 
name which is the
   uppercased string), otherwise it evaluates to its currently assigned value

The next step is to determine what kind of an instruction the resulting string represents in order 
to carry it out:


 * if the second token is an equal sign then it is an assignment instruction 
that gets carried out:
   the expression right of the equal sign (RHS) gets evaluated and assigned to 
the symbol (e.g.
   ABC=3+4) to the left of the equal sign (LHS),

 * if it is not an assignment instruction and the first symbol is a keyword 
then it is a keyword
   instruction that gets carried out,

 * if it is neither then the resulting string is a command instruction which 
gets handed over to
   the operating system for execution, the command's return code can be 
inspected immediately upon
   return by using the Rexx variable RC (set by Rexx to make the return code of 
the command
   immediately available to the Rexx program).

The ADDRESS keyword instruction is just one of the keyword instructions of Rexx which will allow to 
control to which Rexx command handler the command instruction gets sent to (among other things the 
ADDRESS instruction allows to switch among different Rexx command handlers).



Variable precision arithmetic is a boon.  But there is no convenient
library of elementary functions, probably the reason for the lack of
elementary functions in Rexx.


This depends what functionalities you are missing/seeking. There are quite a few Rexx function 
libraries, many implemented in Assembler or C++.


If using ooRexx there is a free, open-source ooRexx-Java bridge available which will make 
immediately *all* Java class libraries there are and all their functionality available to ooRexx, 
really, all of them! The external function and class libraries in this case are not implemented in 
C++ or Assembler, but in Java. And Java has become *fast*, one of the fastest languages there is.


If you look at Java and its standard runtime environment (JRE) you hardly miss any functionality 
there, from GUIs, to XML processing to secure Internet programming etc. E.g. if you have a need to 
transport data via SSL/TLS you get that infrastructure from the JRE for free at your fingertips (on 
all platforms) and can exploit it from Java, and with the ooRexx-Java bridge installed also directly 
from ooRexx.


Anyway, it is hard to conceive functionality that could not be made available to Rexx/ooRexx one way 
or the other.


---rony

--
--
__

Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020  Wien/Vienna, Austria/Europe

http://www.wu.ac.at
__




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: I

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-20 Thread Robert Prins

Try the two characters that are pretty much unique to REXX, "!" and "?"
especially for small local loops.

Robert
-- 
Robert AH Prins
robert(a)prino(d)org
The hitchhiking grandfather 
Some REXX code for use on z/OS


On Sat, 20 Apr 2024 at 15:08, Bob Bridges <
0587168ababf-dmarc-requ...@listserv.ua.edu> wrote:

> It was while I was coding in REXX that I tried abutting a variable named
> 'x' with another string, and couldn't figure out why the program behaved as
> it did.  Eventually figured out I had inadvertently created a hex
> constant.  Maybe as an overreaction, I have never since used one-character
> variable names, always two or more.  (What do I use for loop counters?, you
> ask.  I use 'j' plus another letter; 'jr' for records, for example, 'jd'
> for days whatever.  More obvious would have been 'i', but there are too
> many two-letter reserved words even in REXX that start with 'i'.)
>
> -Original Message-
> From: IBM Mainframe Discussion List  On Behalf
> Of Andrew Rowley
> Sent: Friday, April 19, 2024 22:41
>
> It doesn't cause a problem except when it does. One danger is a typo in
> a variable name. When I wrote some complex Rexx I did use SIGNAL ON
> NOVALUE, but I wasn't totally appeased!
>
> --- On 20/04/2024 12:41 am, Rony G. Flatscher wrote:
> > Rexx defines the value of variables that have no explicit value
> > assigned to them to be the name of the variable in uppercase, so it
> > does not cause a problem. (It does cause problems for programmers who
> > got trained to always make sure that a value is assigned to variables.
> > This is the reason why ooRexx has an option to activate checking for
> > the use of uninitialized variables in Rexx programs to appease those
> > who are not accustomed to it or feel that it should not be allowed. ;) )
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

On Sat, 20 Apr 2024 11:08:03 -0400, Bob Bridges wrote:

>It was while I was coding in REXX that I tried abutting a variable named 'x' 
>with another string, and couldn't figure out why the program behaved as it 
>did.  Eventually figured out I had inadvertently created a hex constant.  
>Maybe as an overreaction, I have never since used one-character variable 
>names, always two or more.  (What do I use for loop counters?, you ask.  I use 
>'j' plus another letter; 'jr' for records, for example, 'jd' for days 
>whatever.  More obvious would have been 'i', but there are too many two-letter 
>reserved words even in REXX that start with 'i'.)
>
I like to use longer names with mnemonic value as control variables and,
if the body of the loop is more than a couple lines, cite the control
variable at the END so the interpreter verifies nesting.

Rexx is chaotic in context sensitivity of reserved words and in symbols'
being evaluated almost everywhere with exceptions for e.g. ADDRESS.

Variable precision arithmetic is a boon.  But there is no convenient
library of elementary functions, probably the reason for the lack of
elementary functions in Rexx.

-- 
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

It was while I was coding in REXX that I tried abutting a variable named 'x' 
with another string, and couldn't figure out why the program behaved as it did. 
 Eventually figured out I had inadvertently created a hex constant.  Maybe as 
an overreaction, I have never since used one-character variable names, always 
two or more.  (What do I use for loop counters?, you ask.  I use 'j' plus 
another letter; 'jr' for records, for example, 'jd' for days whatever.  More 
obvious would have been 'i', but there are too many two-letter reserved words 
even in REXX that start with 'i'.)

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* When I was ten, I read fairy tales in secret and would have been ashamed if 
I had been found doing so. Now that I am fifty I read them openly. When I 
became a man I put away childish things, including the fear of childishness and 
the desire to be very grown up.  -C.S. Lewis */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Andrew Rowley
Sent: Friday, April 19, 2024 22:41

It doesn't cause a problem except when it does. One danger is a typo in 
a variable name. When I wrote some complex Rexx I did use SIGNAL ON 
NOVALUE, but I wasn't totally appeased!

--- On 20/04/2024 12:41 am, Rony G. Flatscher wrote:
> Rexx defines the value of variables that have no explicit value 
> assigned to them to be the name of the variable in uppercase, so it 
> does not cause a problem. (It does cause problems for programmers who 
> got trained to always make sure that a value is assigned to variables. 
> This is the reason why ooRexx has an option to activate checking for 
> the use of uninitialized variables in Rexx programs to appease those 
> who are not accustomed to it or feel that it should not be allowed. ;) ) 

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Andrew Rowley


On 20/04/2024 12:41 am, Rony G. Flatscher wrote:

It is an attempt to apply dynamic typing to reduce the need to write 
the explicit type. This service gets carried out by the compiler. In 
true dynamically typed languages you can reuse variables like "start" 
or "tmp" to refer to values of different types.


It's very specifically not an attempt to apply dynamic typing. It's type 
inference, and can only be used when the compiler can determine the 
type. The resulting type is still static. There's no practical 
difference between


var start = ZonedDateTime.now();

and

ZonedDateTime start = ZonedDateTime.now();

except for the amount of code that needs to be written.


A dynamic language when executing code needs nevertheless to check 
whether interaction with the dynamically typed values is correct or not.


This is one of the reasons I prefer static languages. Run time errors 
can go unnoticed until they are discovered on a customer system. Compile 
time errors are almost certain to be discovered in the development 
environment. (Or for in-house programming, compile time errors are 
discovered in development during business hours, runtime errors might be 
discovered in production at 3am...)


Any error that can be found at compile time instead of runtime is a win.


No the Java syntax is all in all much more complex. You note that when 
teaching novices Java and compare that to teaching novices Rexx or 
ooRexx (I have experiences in both).


There might be a distinction between the difficulty of writing a program 
that runs, and writing a program that is correct.



Well in Rexx concatenation rules are quite intuitive, surprisingly 
there is a blank concatenation operator (a blank between concatenated 
strings), an abuttal concatenation operator (no blank between 
concatenated strings) and using the explicit concatenation operator || 
(no blank between concatenated strings). Novices have no problems to 
understand:


   a=1
   say a "- hello!"    -- concatenation with a blank ...: 1 - 
hello!
   say a"- hello!"    -- abuttal, concatenation without a blank: 
1- hello!
   say a || "- hello!"    -- concatenation with || operator ...: 
1- hello!


I had no problem back in the day when I first learnt it, but having 
learnt other languages since I don't think this is intuitive. 
Particularly the added blank between strings (I agree it is surprising). 
There are other variations here, e.g. I'm not sure how abuttal works 
with 2 variables rather than a variable and a literal.



Rexx defines the value of variables that have no explicit value 
assigned to them to be the name of the variable in uppercase, so it 
does not cause a problem. (It does cause problems for programmers who 
got trained to always make sure that a value is assigned to variables. 
This is the reason why ooRexx has an option to activate checking for 
the use of uninitialized variables in Rexx programs to appease those 
who are not accustomed to it or feel that it should not be allowed. ;) ) 


It doesn't cause a problem except when it does. One danger is a typo in 
a variable name. When I wrote some complex Rexx I did use SIGNAL ON 
NOVALUE, but I wasn't totally appeased!


I'm not trying to be negative about Rexx. I still use it when 
appropriate. But I think z/OS people make a mistake ignoring Java. It's 
fast (e.g. 1GB/s for my CICS SMF processing), makes powerful features 
available (e.g. the Twilio example to send SMS messages from z/OS) and 
it's available on pretty much every z/OS system now.



--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Andrew Rowley


On 20/04/2024 1:42 am, Jay Maynard wrote:

Agreed Java is simply far too complex a language and ecosystem to hold in
the mind. Python is as ubiquitous and much easier to deal with.


Really? What do you NEED to learn for Java that you don't need to learn 
for other languages? public static void main(String[] args)?


Loops, if statements, data types, string processing are things you need 
to learn for all languages. I/O is useful (Rexx EXECIO isn't exactly 
intuitive).


There are lots of add-ons, but you learn them (or just reference the 
details) if you need them. You still need to install add-ons and learn 
extra functionality for Python. Packages providing additional 
functionality are a good thing generally.


The Twilio Python sample looks very similar to the Java version:

https://www.twilio.com/docs/messaging/quickstart/python#send-an-sms-using-twilio

I ran the Java version on z/OS by uploading the Twilio 
jar-with-dependencies and running the sample under BPXBATCH. Is Python 
easier???


//BPXBATCH EXEC PGM=BPXBATCH,REGION=512M
//STDPARM  DD *
sh /usr/lpp/java/J11.0_64/bin/java
 /home/andrewr/java/src/TwilioTest.java
 "Hello from z/OS"
//STDENV   DD *
CLASSPATH=/home/andrewr/java/lib/twilio-10.1.3-jar-with-dependencies.jar
TWILIO_ACCOUNT_SID=xx
TWILIO_AUTH_TOKEN=
//SYSOUT   DD SYSOUT=*
//STDOUT   DD SYSOUT=*
//STDERR   DD SYSOUT=*


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Bob Bridges

Oh, I dunno.  Generalizations aren't invalid as long as you don't mistake them 
for blanket stereotypes, and generalizations are the only possible way to 
describe general groups.  I see no cause for offense here.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* Be kind whenever possible.  It is always possible.  -Dalai Lama */

(I swear this was just the next tagline in the queue; I didn't pick it out for 
this occasion.  Really, I promise.)

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Seymour J Metz
Sent: Friday, April 19, 2024 12:54

Why don't you speak for yourself instead of inventing urban legends?

Both old timers and youngsters are individuals, with vast panoplies of 
different attitudes and opinions. It is presumptuous and rude to make such 
arrogant blanket characterizations.

There are plenty of old timers who like the bleeding edge, and plenty of 
youngsters("young fogies") who are resistant to change.


From: IBM Mainframe Discussion List  on behalf of 
David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
Sent: Friday, April 19, 2024 11:25 AM

I’m not sure I would use Java as a REXX alternative now we have Python. REXX is 
very much legacy now. The old timers love it because it’s all they know but 
push come to shove Python is much easier to learn then Java with all the OO 
cruft.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Seymour J Metz

Why don't you speak for yourself instead of inventing urban legends?

Both old timers and youngsters are individuals, with vast panoplies of 
different attitudes and opinions. It is presumptuous and rude to make such 
arrogant blanket characterizations.

There are plenty of old timers who like the bleeding edge, and plenty of 
youngsters("young fogies") who are resistant to change.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
Sent: Friday, April 19, 2024 11:25 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

I’m not sure I would use Java as a REXX alternative now we have Python. REXX is 
very much legacy now. The old timers love it because it’s all they know but 
push come to shove Python is much easier to learn then Java with all the OO 
cruft.

> On 19 Apr 2024, at 7:50 AM, Andrew Rowley  
> wrote:
>
> On 18/04/2024 8:29 pm, Rony G. Flatscher wrote:
>> The mileage of people here vary including the Java people themselves who 
>> have started to reduce the need of explicit declarations like the new "var" 
>> (imitating JavaScript) instead of strict types or foregoing the static main 
>> method such that one can at least code the main method without the explicit 
>> declarations. The motivation about these changes is to make Java easier, 
>> reduce typing needs and the like.
>
> The Java var keyword is more like C# than Javascript. The variable still has 
> a strict type - you can only use var if the compiler can figure out the type 
> from other information e.g.
>
> var start = ZonedDateTime.now();
>
> start is a ZonedDateTime. You can't use it before it is defined, you can't 
> assign anything other than a ZoneDateTime to it, you can't create a new 
> variable called start in the same scope, whether or not it is a ZoneDateTime. 
> You can't e.g compare it to a LocalDateTime without specifying a timezone for 
> the LocalDateTime - that is one of those things that helps avoid errors.
>
> var just reduces redundant code, e.g. specifying the type twice in the same 
> statement.
>
>
>> Of course a static and statically typed languages with a compiler must 
>> define as much rules as possible, such that the compiler can check for them 
>> all. The more rules the more time consuming and the more difficult to learn 
>> a language.
>
> I think the syntax rules for Rexx are actually more complex than Java, 
> because it is less likely to flag an error if you do something that's not 
> actually what you want. E.g. string concatenation where variables are 
> expected to be strings but maybe not, might not be initialized, sometimes you 
> need vertical bars but not always etc. If you're used to the language you 
> write it without thinking and avoid the traps, but the rules are there 
> nonetheless.
>
> Java is relatively straightforward, and shares many rules with other 
> languages - C++, C# etc. I'm not saying Java is perfect - it has its own 
> traps (int vs Integer etc) but I find it a much easier language to work with.
>
> --
> Andrew Rowley
> Black Hill Software
>
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Jay Maynard

Agreed Java is simply far too complex a language and ecosystem to hold in
the mind. Python is as ubiquitous and much easier to deal with.

On Fri, Apr 19, 2024 at 10:25 AM David Crayford <
0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:

> I’m not sure I would use Java as a REXX alternative now we have Python.
> REXX is very much legacy now. The old timers love it because it’s all they
> know but push come to shove Python is much easier to learn then Java with
> all the OO cruft.
>
> > On 19 Apr 2024, at 7:50 AM, Andrew Rowley 
> wrote:
> >
> > On 18/04/2024 8:29 pm, Rony G. Flatscher wrote:
> >> The mileage of people here vary including the Java people themselves
> who have started to reduce the need of explicit declarations like the new
> "var" (imitating JavaScript) instead of strict types or foregoing the
> static main method such that one can at least code the main method without
> the explicit declarations. The motivation about these changes is to make
> Java easier, reduce typing needs and the like.
> >
> > The Java var keyword is more like C# than Javascript. The variable still
> has a strict type - you can only use var if the compiler can figure out the
> type from other information e.g.
> >
> > var start = ZonedDateTime.now();
> >
> > start is a ZonedDateTime. You can't use it before it is defined, you
> can't assign anything other than a ZoneDateTime to it, you can't create a
> new variable called start in the same scope, whether or not it is a
> ZoneDateTime. You can't e.g compare it to a LocalDateTime without
> specifying a timezone for the LocalDateTime - that is one of those things
> that helps avoid errors.
> >
> > var just reduces redundant code, e.g. specifying the type twice in the
> same statement.
> >
> >
> >> Of course a static and statically typed languages with a compiler must
> define as much rules as possible, such that the compiler can check for them
> all. The more rules the more time consuming and the more difficult to learn
> a language.
> >
> > I think the syntax rules for Rexx are actually more complex than Java,
> because it is less likely to flag an error if you do something that's not
> actually what you want. E.g. string concatenation where variables are
> expected to be strings but maybe not, might not be initialized, sometimes
> you need vertical bars but not always etc. If you're used to the language
> you write it without thinking and avoid the traps, but the rules are there
> nonetheless.
> >
> > Java is relatively straightforward, and shares many rules with other
> languages - C++, C# etc. I'm not saying Java is perfect - it has its own
> traps (int vs Integer etc) but I find it a much easier language to work
> with.
> >
> > --
> > Andrew Rowley
> > Black Hill Software
> >
> > --
> > For IBM-MAIN subscribe / signoff / archive access instructions,
> > send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
>
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
>


-- 
Jay Maynard

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread David Crayford

I’m not sure I would use Java as a REXX alternative now we have Python. REXX is 
very much legacy now. The old timers love it because it’s all they know but 
push come to shove Python is much easier to learn then Java with all the OO 
cruft. 

> On 19 Apr 2024, at 7:50 AM, Andrew Rowley  
> wrote:
> 
> On 18/04/2024 8:29 pm, Rony G. Flatscher wrote:
>> The mileage of people here vary including the Java people themselves who 
>> have started to reduce the need of explicit declarations like the new "var" 
>> (imitating JavaScript) instead of strict types or foregoing the static main 
>> method such that one can at least code the main method without the explicit 
>> declarations. The motivation about these changes is to make Java easier, 
>> reduce typing needs and the like.
> 
> The Java var keyword is more like C# than Javascript. The variable still has 
> a strict type - you can only use var if the compiler can figure out the type 
> from other information e.g.
> 
> var start = ZonedDateTime.now();
> 
> start is a ZonedDateTime. You can't use it before it is defined, you can't 
> assign anything other than a ZoneDateTime to it, you can't create a new 
> variable called start in the same scope, whether or not it is a ZoneDateTime. 
> You can't e.g compare it to a LocalDateTime without specifying a timezone for 
> the LocalDateTime - that is one of those things that helps avoid errors.
> 
> var just reduces redundant code, e.g. specifying the type twice in the same 
> statement.
> 
> 
>> Of course a static and statically typed languages with a compiler must 
>> define as much rules as possible, such that the compiler can check for them 
>> all. The more rules the more time consuming and the more difficult to learn 
>> a language.
> 
> I think the syntax rules for Rexx are actually more complex than Java, 
> because it is less likely to flag an error if you do something that's not 
> actually what you want. E.g. string concatenation where variables are 
> expected to be strings but maybe not, might not be initialized, sometimes you 
> need vertical bars but not always etc. If you're used to the language you 
> write it without thinking and avoid the traps, but the rules are there 
> nonetheless.
> 
> Java is relatively straightforward, and shares many rules with other 
> languages - C++, C# etc. I'm not saying Java is perfect - it has its own 
> traps (int vs Integer etc) but I find it a much easier language to work with.
> 
> -- 
> Andrew Rowley
> Black Hill Software
> 
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Farley, Peter

+1 for the oleinfo utilities Rony points to here.  They were a great help to me 
in crafting and debugging a VBS script I was writing to help automate creation 
of an Excel report spreadsheet.

From: IBM Mainframe Discussion List  On Behalf Of 
Rony G. Flatscher
Sent: Friday, April 19, 2024 9:45 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question


On 18.04.2024 15:14, Bob Bridges wrote:

> I don't often admit it, because I expect to get flamed for it, but in fact 
> when I write in VBA almost all my variables are type VAR - that is, I hardly 
> ever use the Dim statement to assign a type.  To introduce an array, sure, or 
> to maintain correct spelling in the longer var names.  But it's rare indeed 
> that I feel the need to specify that a variable is going to be BYTE, STRING 
> or whatever.

>

> So obviously, coding in typeless REXX doesn't bother me 😊.



:-)



Seeing that you do quite a lot with OLE via VBA it may be interesting to take 
advantage of ooRexx

5.1 [1] little "oleinfo" utility [2] (see "oorexx\samples\ole\oleinfo" programs 
"createOleInfo.rex",

"getOleConstants.rex", and "listProgIds.rex"). For those interested about OLE 
and what one can do

with it see [3].



The generated HTML documentation about the OLE interfaces to Windows programs 
can be used for ooRexx

and VBA alike.



HTH



---rony



[1] : Installation packages for oorexx 5.1:

<https://urldefense.com/v3/__https://sourceforge.net/projects/oorexx/files/oorexx/5.1.0beta/__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxocSUcYbc$<https://urldefense.com/v3/__https:/sourceforge.net/projects/oorexx/files/oorexx/5.1.0beta/__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxocSUcYbc$>>.



[2]: OLEInfo Utility:

<https://urldefense.com/v3/__https://wi.wu.ac.at/rgf/wu/lehre/autowin/material/foils/130_AutoWin_oleinfo_V04.pdf__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxoc1JRMod$<https://urldefense.com/v3/__https:/wi.wu.ac.at/rgf/wu/lehre/autowin/material/foils/130_AutoWin_oleinfo_V04.pdf__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxoc1JRMod$>>



[3]: OLE and Nutshell Examples:

<https://urldefense.com/v3/__https://wi.wu.ac.at/rgf/wu/lehre/autowin/material/foils/110_AutoWin_V18.pdf__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxoRAs1_Tx$<https://urldefense.com/v3/__https:/wi.wu.ac.at/rgf/wu/lehre/autowin/material/foils/110_AutoWin_V18.pdf__;!!Ebr-cpPeAnfNniQ8HSAI-g_K5b7VKg!PKDIGv21yG1HutL5OYw-GXz7XNI2i-z5hDkCqU1pXXZkBvLUD1Y4DHC_4gno0d5HunpmDb9SpOqWmDOTlSK6KNPxoRAs1_Tx$>>



> -Original Message-

> From: IBM Mainframe Discussion List 
> mailto:IBM-MAIN@LISTSERV.UA.EDU>> On Behalf Of Rony 
> G. Flatscher

> Sent: Thursday, April 18, 2024 06:30

>

> The mileage of people here vary including the Java people themselves who have 
> started to reduce the need of explicit declarations like the new "var" 
> (imitating JavaScript) instead of strict types or foregoing the static main 
> method such that one can at least code the main method without the explicit 
> declarations. The motivation about these changes is to make Java easier, 
> reduce typing needs and the like.

>

> --- On 18.04.2024 02:22, Andrew Rowley wrote:

>> I find Rexx difficult because explicit declarations and static typing (as 
>> well as tightly controlled scopes) actually make programming easier, in 
>> general.  They show up bugs in the code and make it easier to write correct 
>> programs.

--

This message and any attachments are intended only for the use of the addressee 
and may contain information that is privileged and confidential. If the reader 
of the message is not the intended recipient or an authorized representative of 
the intended recipient, you are hereby notified that any dissemination of this 
communication is strictly prohibited. If you have received this communication 
in error, please notify us immediately by e-mail and delete the message and any 
attachments from your system.


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Rony G. Flatscher


On 19.04.2024 01:50, Andrew Rowley wrote:

On 18/04/2024 8:29 pm, Rony G. Flatscher wrote:
The mileage of people here vary including the Java people themselves who have started to reduce 
the need of explicit declarations like the new "var" (imitating JavaScript) instead of strict 
types or foregoing the static main method such that one can at least code the main method without 
the explicit declarations. The motivation about these changes is to make Java easier, reduce 
typing needs and the like.


The Java var keyword is more like C# than Javascript. The variable still has a strict type - you 
can only use var if the compiler can figure out the type from other information e.g.


var start = ZonedDateTime.now();

start is a ZonedDateTime. You can't use it before it is defined, you can't assign anything other 
than a ZoneDateTime to it, you can't create a new variable called start in the same scope, whether 
or not it is a ZoneDateTime. You can't e.g compare it to a LocalDateTime without specifying a 
timezone for the LocalDateTime - that is one of those things that helps avoid errors.


var just reduces redundant code, e.g. specifying the type twice in the same 
statement.


It is an attempt to apply dynamic typing to reduce the need to write the explicit type. This service 
gets carried out by the compiler. In true dynamically typed languages you can reuse variables like 
"start" or "tmp" to refer to values of different types. The context of interacting with them will 
determine whether the interaction is correct or not, maybe an example:


   a=123-- a number
   b="456"-- a number
   say a+b  -- yields: 579

   b='xyz' -- a string
   say a+b  -- yields: Bad arithmetic conversion. Nonnumeric value 
("xyz") used in arithmetic operation.

   b=.dateTime~new  -- current date and time
   say b-- will display the current date and time, e.g: 
2024-04-19T15:51:51.249000
   say b~addWeeks(17) -- yields: 2024-08-16T15:51:51.249000

   say a+b  -- yields: Bad arithmetic conversion. Nonnumeric value ("a 
DateTime") used in arithmetic operation.

A dynamic language when executing code needs nevertheless to check whether interaction with the 
dynamically typed values is correct or not.


Of course a static and statically typed languages with a compiler must define as much rules as 
possible, such that the compiler can check for them all. The more rules the more time consuming 
and the more difficult to learn a language.


I think the syntax rules for Rexx are actually more complex than Java, because it is less likely 
to flag an error if you do something that's not actually what you want. 


No the Java syntax is all in all much more complex. You note that when teaching novices Java and 
compare that to teaching novices Rexx or ooRexx (I have experiences in both).


E.g. string concatenation where variables are expected to be strings but maybe not, might not be 
initialized, sometimes you need vertical bars but not always etc. 


Well in Rexx concatenation rules are quite intuitive, surprisingly there is a blank concatenation 
operator (a blank between concatenated strings), an abuttal concatenation operator (no blank between 
concatenated strings) and using the explicit concatenation operator || (no blank between 
concatenated strings). Novices have no problems to understand:


   a=1
   say a "- hello!"   -- concatenation with a blank ...: 1 - hello!
   say a"- hello!"-- abuttal, concatenation without a blank: 1- 
hello!
   say a || "- hello!"-- concatenation with || operator ...: 1- 
hello!

In Java (and many other programming languages) there is only the + concatenation operator available 
(equivalent to Rexx' || operator), therefore one has always to use the + operator and has to write 
something like:


   int a=1;
   System.out.println(a+" - hello!"); // blank between both
   System.out.println(a+"- hello!");  // no blank between both

Of course this works, but it forces you to always use the + operator, whereas in the Rexx example it 
does not, yet the Rexx statements are intuitively understood by novices. So this does not add 
complexity per se.


Ad uninitialized variables: this is usually a no go in statically typed programming languages, the 
Java compiler therefore warns about it and uses default values wherever possible which is fine.


Rexx defines the value of variables that have no explicit value assigned to them to be the name of 
the variable in uppercase, so it does not cause a problem. (It does cause problems for programmers 
who got trained to always make sure that a value is assigned to variables. This is the reason why 
ooRexx has an option to activate checking for the use of uninitialized variables in Rexx programs to 
appease those who are not accustomed to it or feel that it should not be allowed. ;) )


If you're used to the language you write it without thinking and

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-19 Thread Rony G. Flatscher


On 18.04.2024 15:14, Bob Bridges wrote:

I don't often admit it, because I expect to get flamed for it, but in fact when 
I write in VBA almost all my variables are type VAR - that is, I hardly ever 
use the Dim statement to assign a type.  To introduce an array, sure, or to 
maintain correct spelling in the longer var names.  But it's rare indeed that I 
feel the need to specify that a variable is going to be BYTE, STRING or 
whatever.

So obviously, coding in typeless REXX doesn't bother me 😊.


:-)

Seeing that you do quite a lot with OLE via VBA it may be interesting to take advantage of ooRexx 
5.1 [1] little "oleinfo" utility [2] (see "oorexx\samples\ole\oleinfo" programs "createOleInfo.rex", 
"getOleConstants.rex", and "listProgIds.rex"). For those interested about OLE and what one can do 
with it see [3].


The generated HTML documentation about the OLE interfaces to Windows programs can be used for ooRexx 
and VBA alike.


HTH

---rony

[1] : Installation packages for oorexx 5.1: 
.


[2]: OLEInfo Utility: 



[3]: OLE and Nutshell Examples: 




-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Rony G. Flatscher
Sent: Thursday, April 18, 2024 06:30

The mileage of people here vary including the Java people themselves who have started to 
reduce the need of explicit declarations like the new "var" (imitating 
JavaScript) instead of strict types or foregoing the static main method such that one can 
at least code the main method without the explicit declarations. The motivation about 
these changes is to make Java easier, reduce typing needs and the like.

--- On 18.04.2024 02:22, Andrew Rowley wrote:

I find Rexx difficult because explicit declarations and static typing (as well 
as tightly controlled scopes) actually make programming easier, in general.  
They show up bugs in the code and make it easier to write correct programs.


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-18 Thread Andrew Rowley


On 18/04/2024 8:29 pm, Rony G. Flatscher wrote:
The mileage of people here vary including the Java people themselves 
who have started to reduce the need of explicit declarations like the 
new "var" (imitating JavaScript) instead of strict types or foregoing 
the static main method such that one can at least code the main method 
without the explicit declarations. The motivation about these changes 
is to make Java easier, reduce typing needs and the like.


The Java var keyword is more like C# than Javascript. The variable still 
has a strict type - you can only use var if the compiler can figure out 
the type from other information e.g.


var start = ZonedDateTime.now();

start is a ZonedDateTime. You can't use it before it is defined, you 
can't assign anything other than a ZoneDateTime to it, you can't create 
a new variable called start in the same scope, whether or not it is a 
ZoneDateTime. You can't e.g compare it to a LocalDateTime without 
specifying a timezone for the LocalDateTime - that is one of those 
things that helps avoid errors.


var just reduces redundant code, e.g. specifying the type twice in the 
same statement.



Of course a static and statically typed languages with a compiler must 
define as much rules as possible, such that the compiler can check for 
them all. The more rules the more time consuming and the more 
difficult to learn a language.


I think the syntax rules for Rexx are actually more complex than Java, 
because it is less likely to flag an error if you do something that's 
not actually what you want. E.g. string concatenation where variables 
are expected to be strings but maybe not, might not be initialized, 
sometimes you need vertical bars but not always etc. If you're used to 
the language you write it without thinking and avoid the traps, but the 
rules are there nonetheless.


Java is relatively straightforward, and shares many rules with other 
languages - C++, C# etc. I'm not saying Java is perfect - it has its own 
traps (int vs Integer etc) but I find it a much easier language to work 
with.


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-18 Thread Bob Bridges

I don't often admit it, because I expect to get flamed for it, but in fact when 
I write in VBA almost all my variables are type VAR - that is, I hardly ever 
use the Dim statement to assign a type.  To introduce an array, sure, or to 
maintain correct spelling in the longer var names.  But it's rare indeed that I 
feel the need to specify that a variable is going to be BYTE, STRING or 
whatever.

So obviously, coding in typeless REXX doesn't bother me 😊.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* This universe is full of magical things patiently waiting for our wits to 
grow sharper. */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Rony G. Flatscher
Sent: Thursday, April 18, 2024 06:30

The mileage of people here vary including the Java people themselves who have 
started to reduce the need of explicit declarations like the new "var" 
(imitating JavaScript) instead of strict types or foregoing the static main 
method such that one can at least code the main method without the explicit 
declarations. The motivation about these changes is to make Java easier, reduce 
typing needs and the like.

--- On 18.04.2024 02:22, Andrew Rowley wrote:
> I find Rexx difficult because explicit declarations and static typing (as 
> well as tightly controlled scopes) actually make programming easier, in 
> general.  They show up bugs in the code and make it easier to write correct 
> programs. 

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-18 Thread Rony G. Flatscher


On 18.04.2024 02:22, Andrew Rowley wrote:

On 18/04/2024 4:39 am, Rony G. Flatscher wrote:

As you know already Rexx it would be easy for you to learn about what ooRexx 
adds to Rexx.


...

Notabene: you write one ooRexx program that will be runnable without any changes on Windows, 
Linux and macOS. This means you develop it e.g. on Windows at home and execute it in a Linux 
s390x subsystem at work and vice versa. ;)

...
A dynamic and dynamically typed language as ooRexx allows to forgo many of the declarations a 
static and statically typed language mandates, thereby simplifying coding quite considerably.



I find Rexx difficult because explicit declarations and static typing (as well as tightly 
controlled scopes) actually make programming easier, in general. 


That is interesting and fine.

They show up bugs in the code and make it easier to write correct programs. 


The mileage of people here vary including the Java people themselves who have started to reduce the 
need of explicit declarations like the new "var" (imitating JavaScript) instead of strict types or 
foregoing the static main method such that one can at least code the main method without the 
explicit declarations. The motivation about these changes is to make Java easier, reduce typing 
needs and the like.


Of course a static and statically typed languages with a compiler must define as much rules as 
possible, such that the compiler can check for them all. The more rules the more time consuming and 
the more difficult to learn a language.



The IDE is also an important factor.


Yes, indeed.

In the case that you use IntelliJ (available for all major platforms) you could add the ooRexx 
plugin which syntax checks and syntax highlights normal Rexx programs and ooRexx programs. There is 
even a mode for mainframe REXX programs in it. The ooRexx IntelliJ plugin can be downloaded from 
. You download 
the zip archive and have IntelliJ load it in its plugin menu, just follow the instructions on that page.


One feature you get with this plugin is a documentation feature of Rexx and ooRexx programs (just 
use the right mouse button).



I already write programs on my Windows laptop and run them on z/OS using Java 
:-)


Yes, that makes sense! :)

---rony

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-18 Thread Rony G. Flatscher


On 17.04.2024 21:04, Bob Bridges wrote:

This whole post was fascinating me, partly because I'm still a novice at 
ooRexx, still wrapping my head around certain concepts (messaging being one 
example).  I may as well say, though, that when I finally broke down and got 
myself a copy, I then took not one hour but two or three days off to read the 
documentation before I started writing the program I had in mind.  There was so 
much more to it than I expected, having believed that it would be simply 
TSO-REXX with object support.

Messaging...As I said, I'm still wrapping my head around that.  I'm used to creating 
classes and then invoking their methods; to use the term "message" in this 
connection causes my brain to pause temporarily.  So far the only thing I've worked out 
is that messaging ~is~ invoking a class' method, that is, it's just another way of saying 
the same thing.  But the way you describe it, I suspect I'm missing something.


My take is that people tend to believe that there is more to the messaging 
paradigm than there is. :)

Think of a message expression to be something comparable to a call instruction or a function 
invocation, it will cause code to be executed like the others.


The nice thing about the message paradigm "receiver~message" is that the receiver is responsible to 
find a method (a routine defined in its structure, class, type) and invoke it. The receiver will 
take the name of the received message and starts to look for a method by the same name in its own 
class (the structure used to create the receiver). If the method is not found by the receiver, the 
receiver will look up the immediate superclass for the method and if not found, that superclass' 
superclass up the class hierarchy to the root class. The first method found in this lookup process 
will be the one the receiver will run, supplying any arguments the message carries and returning any 
result to the caller. This effectively realizes inheritance.


The programmer only needs to know about the functionality (methods and attributes/fields) documented 
for the class/structure/type that was used to create the receiver. Because of inheritance all 
functionality (methods and attributes/fields) on the shortest path to the root of the class 
hierarchy is available as well, the reuse of tested functionality is therefore huge in such OOP systems.


However, the programmer does not need to know any of the gory implementation details at times that 
need to be tackled by the receiver, e.g. if communicating with Windows OLE objects or Java objects, 
one merely sends normal ooRexx messages to receivers that represent these Windows OLE objects or 
Java objects. Or with other words: the message paradigm makes it easy to treat Windows OLE objects 
or Java objects as if they were normal ooRexx objects as they conceptually understand ooRexx messages.


But in the end: the only thing new here is that invoking desired functionality is possible using a 
simple message paradigm with the simple pattern: receiver~message


Probably because of the simplicity of the messaga paradigm it got overlooked when others started to 
create OO programming languages, e.g. C++, Java, C#, Python and the like.


---rony

P.S.: The message paradigm makes a lot of dynamics possible in a simple, i.e. conceptually easy 
manner, including triggering multithreading or intercepting or rerouting messages.


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-17 Thread Andrew Rowley


On 18/04/2024 4:39 am, Rony G. Flatscher wrote:
As you know already Rexx it would be easy for you to learn about what 
ooRexx adds to Rexx.


...

Notabene: you write one ooRexx program that will be runnable without 
any changes on Windows, Linux and macOS. This means you develop it 
e.g. on Windows at home and execute it in a Linux s390x subsystem at 
work and vice versa. ;)

...
A dynamic and dynamically typed language as ooRexx allows to forgo 
many of the declarations a static and statically typed language 
mandates, thereby simplifying coding quite considerably.



I find Rexx difficult because explicit declarations and static typing 
(as well as tightly controlled scopes) actually make programming easier, 
in general. They show up bugs in the code and make it easier to write 
correct programs. The IDE is also an important factor.


I already write programs on my Windows laptop and run them on z/OS using 
Java :-)


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-17 Thread Bob Bridges

This whole post was fascinating me, partly because I'm still a novice at 
ooRexx, still wrapping my head around certain concepts (messaging being one 
example).  I may as well say, though, that when I finally broke down and got 
myself a copy, I then took not one hour but two or three days off to read the 
documentation before I started writing the program I had in mind.  There was so 
much more to it than I expected, having believed that it would be simply 
TSO-REXX with object support.

Messaging...As I said, I'm still wrapping my head around that.  I'm used to 
creating classes and then invoking their methods; to use the term "message" in 
this connection causes my brain to pause temporarily.  So far the only thing 
I've worked out is that messaging ~is~ invoking a class' method, that is, it's 
just another way of saying the same thing.  But the way you describe it, I 
suspect I'm missing something.

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* Taxation ~with~ representation isn't all that great, either. */


-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Rony G. Flatscher
Sent: Wednesday, April 17, 2024 14:24

ooRexx adds the message expression to Rexx to simplify interactions with any 
kind of values. E.g. 
instead of coding

say reverse("abc")  /* yields a string "cba" */

you can optionally code:

say "abc"~reverse   /* yields a string "cba" */

The message expression consists of a receiver value (synonyms: object, 
instance) on the left-hand side of the tilde (~), which is the message 
operator, followed by the name of a message on the right hand side. If the 
message has arguments you would supply them in parentheses.

The receiver is then responsible to search for a method (function) by the name 
of the received message, invokes it and returns the result, if any.

This is a quite simple concept.

You may want to take a look at  the article 

 which introduces Rexx and ooRexx to engineering educators. Reading that 
article, any interested REXX programmer from this mailing list should be able 
to learn ooRexx in about half an hour!

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-17 Thread Rony G. Flatscher


On 17.04.2024 02:12, Andrew Rowley wrote:

On 16/04/2024 3:08 am, Jon Perryman wrote:
From a language standpoint, REXX is just another language but it's real strength is it's 
environment integration. Instead of the caller maintaining libraries, the environment 
automatically integrates with REXX. For instance, REXX in the TSO environment, gives you access 
to TSO commands (address TSO) and z/OS programs (address linkmvs). Start ISPF and address ISPEXEC 
is available. ISPF option 2 gives you address ISREDIT. SYSCALLS ON gives you address syscalls.


Rexx has better integration with z/OS, but Java has better integration with the 
rest of the world.

I just wrote a piece about sending SMS text messages from z/OS:

https://www.blackhillsoftware.com/news/2024/04/15/text-message-alerts-from-the-z-os-smf-real-time-interface/ 



Spoiler: it's 2 Java statements using the Twilio API.

Twilio.init(ACCOUNT_SID, AUTH_TOKEN); Message message = Message.creator( new 
com.twilio.type.PhoneNumber("+14159352345"), // to new 
com.twilio.type.PhoneNumber("+14158141829"), // from args[0]) .create();


Twilio provide a library that can be used to send text messages from z/OS. Amazon provide a 
library that can be used to work with AWS services from z/OS. It's very common for cloud providers 
to provide Java libraries for working with their services. Most of them will work on z/OS and open 
up those features to the mainframe.


Java is also a much more powerful language. I used to write a lot of Rexx, but I hate to go back 
because it is so much easier to get things done in Java.


Rexx is good for small tasks where the overhead of starting the JVM is significant, or where there 
isn't functionality in Java. Otherwise, Java is my choice.


As you know already Rexx it would be easy for you to learn about what ooRexx adds to Rexx. Take half 
an hour and read "Proposing ooRexx and BSF4ooRexx for Teaching Programming and Fundamental 
Programming Concepts" at 
.


Using the ooRexx-Java bridge BSF4ooRexx (which I have been authoring for over twenty years and 
available for all major operating systems like Windows, Linux, macOS, also a s390x version is 
available) you can easily write ooRexx programs that use any of the Java class libraries on any of 
the supported operating systems.


Notabene: you write one ooRexx program that will be runnable without any changes on Windows, Linux 
and macOS. This means you develop it e.g. on Windows at home and execute it in a Linux s390x 
subsystem at work and vice versa. ;)


To give you an idea I transcribed your interesting example given in Java using the depicted code 
supplied by your link above which looks like:


   /* Java version, 
cf.
   import com.twilio.Twilio;
   import com.twilio.rest.api.v2010.account.Message;
   import com.twilio.type.PhoneNumber;

   public class TwilioTest {
// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. Seehttp://twil.io/secure
public static final String ACCOUNT_SID = 
System.getenv("TWILIO_ACCOUNT_SID");
public static final String AUTH_TOKEN = 
System.getenv("TWILIO_AUTH_TOKEN");

public static void main(String[] args) {
Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
Message message = Message.creator(
new com.twilio.type.PhoneNumber("+14159352345"), // to
new com.twilio.type.PhoneNumber("+14158141829"), // from
args[0])
.create();

System.out.println(message.getSid());
}
   }

As practically all Java classes get documented as interlinked HTML files and usually are published 
on the Internet one can get at these JavaDocs using Internet search engines. One of the possible 
hits is e.g.: .


So anyone could take a look at how JavaDocs look like and use Internet search engines to get 
additional information.


Using the above Java program as an example here the (untested) ooRexx code:

   /* ooRexx version (using BSF4ooRexx) */
   parse arg argument  /* get argument */

   /* get values from process environment */
   account_sid=value("TWILIO_ACCOUNT_SID", ,"ENVIRONMENT")
   auth_token =value("TWILIO_AUTH_TOKEN" , ,"ENVIRONMENT")

   /* initalize Twilio environment */
   bsf.loadClass("com.twilio.Twilio")~init(account_sid, auth_token)

   /* create phone numbers */
   phoneTo  =.bsf~new("com.twilio.type.PhoneNumber", "+14159352345")
   phoneFrom=.bsf~new("com.twilio.type.PhoneNumber", "+14158141829")

   /* load Message class and use its static method creator) */
   clzMsg=bsf.importClass("com.twilio.rest.api.v2010.account.Message")

   /* create message */
   message=c

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-17 Thread Rony G. Flatscher

On 15.04.2024 19:08, Jon Perryman wrote:

Java's not perfect, but it is powerful and it is pretty much universally
available on z/OS.

People don't understand the ingenuity behind REXX and don't understand the real
problems it solves. From a language standpoint, REXX is just another language
but it's real strength is it's environment integration. Instead of the caller
maintaining libraries, the environment automatically integrates with REXX. For
instance, REXX in the TSO environment, gives you access to TSO commands
(address TSO) and z/OS programs (address linkmvs). Start ISPF and address
ISPEXEC is available. ISPF option 2 gives you address ISREDIT. SYSCALLS ON
gives you address syscalls.

For product developers, REXX is simple to integrate environments as witnessed
by the plethora of integrated environments on z/VM, z/OS and probably z/VSE
(e.g. some addressable environments: automation, CICS, CMS, CP, TSO, UNIX,
SYSCALLS and more)

OOREXX is not REXX because it does not have the automatic environment
integration and as you say, using JAVA instead of OOREXX would be preferable.
REXX on the other hand is preferable over JAVA in many IBM environments. For
instance, why would you use JAVA as your system automation environment language?

The complication of using OOP REXX is rarely beneficial for most environments.
Generally, you are not building complicated applications. For instance, system
automation will be the most complex but managing events under objects would be
complicated and unmanageable given the current automation environment design.

There is no "complication of using OOP REXX": ooRexx runs Rexx programs just like Rexx. It therefore
needs to support addressable command environments it also supports the REXXSAA APIs including exits.

ooRexx adds the message expression to Rexx to simplify interactions with any kind of values. E.g.
instead of coding

say reverse("abc") /* yields a string "cba" */

you can optionally code:

say "abc"~reverse /* yields a string "cba" */

The message expression consists of a receiver value (synonyms: object, instance) on the left-hand
side of the tilde (~), which is the message operator, followed by the name of a message on the right
hand side. If the message has arguments you would supply them in parentheses.

The receiver is then responsible to search for a method (function) by the name of the received
message, invokes it and returns the result, if any.

This is a quite simple concept.

Whether you take advantage of the message paradigm in ooRexx or not is up to you if working with
strings as for strings there are the REXX built-in functions (BIFs).

In the context of message expressions please note that Alan Kaye, one of the most influential and
seminal computer scientists who was working on Xerox PARC' SmallTalk gets cited Wikipedia
(https://en.wikipedia.org/wiki/Alan_Kay):

Along with some colleagues at PARC, Kay is one of the fathers of the idea of
object-oriented
programming
(OOP), which he named.
Some original object-oriented concepts, including the use of the words
'object' and 'class', had
been developed for Simula 67 at the
Norwegian Computing
Center . Kay said:

I'm sorry that I long ago coined the term "objects" for this topic
because it gets many
people to focus on the lesser idea. The big idea is "messaging
".

The idea of messaging is what the IBM research team in Hursley added to REXX to come up with Object
REXX, making it astonishingly simple to interact with any kind of value (object, instance) in any
programming environment.

The message paradigm not only works with string values, but with any kind of values (objects,
instances).

This is the reason why it is simple for novices who learn programming with ooRexx to interact with
Windows and Windows programs like MS Office or OpenOffice or LibreOffice via OLE: the ooRexx
programmer only needs to send messages to those Windows objects, how the receiver (an OLE object)
carries them out is not necessary to be known by the ooRexx programmer.

The same is true for Java: the ooRexx programmer only needs to send messages to Java objects, how
the receiver (a Java object) carries them out is not necessary to be known by the ooRexx programmer.

The same is true for DBus on Linux systems: the ooRexx programmer only needs to send messages to
Java objects, how the receiver (a DBus object) carries them out is not necessary to be known by the
ooRexx programmer.

And so on ...

---

The other addition of ooRexx to REXX are directive instructions. If present, they are put at the end
of a program and direct the ooRexx interpreter to carry out services on behalf of the ooRexx
programmer in the setup phase. E.g. the requires

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-16 Thread Andrew Rowley

On 16/04/2024 3:08 am, Jon Perryman wrote:
From a language standpoint, REXX is just another language but it's
real strength is it's environment integration. Instead of the caller
maintaining libraries, the environment automatically integrates with
REXX. For instance, REXX in the TSO environment, gives you access to
TSO commands (address TSO) and z/OS programs (address linkmvs). Start
ISPF and address ISPEXEC is available. ISPF option 2 gives you address
ISREDIT. SYSCALLS ON gives you address syscalls.

Rexx has better integration with z/OS, but Java has better integration
with the rest of the world.

I just wrote a piece about sending SMS text messages from z/OS:

https://www.blackhillsoftware.com/news/2024/04/15/text-message-alerts-from-the-z-os-smf-real-time-interface/

Spoiler: it's 2 Java statements using the Twilio API.

Twilio.init(ACCOUNT_SID, AUTH_TOKEN); Message message = Message.creator(
new com.twilio.type.PhoneNumber("+14159352345"), // to new
com.twilio.type.PhoneNumber("+14158141829"), // from args[0]) .create();

Twilio provide a library that can be used to send text messages from
z/OS. Amazon provide a library that can be used to work with AWS
services from z/OS. It's very common for cloud providers to provide Java
libraries for working with their services. Most of them will work on
z/OS and open up those features to the mainframe.

Java is also a much more powerful language. I used to write a lot of
Rexx, but I hate to go back because it is so much easier to get things
done in Java.

Rexx is good for small tasks where the overhead of starting the JVM is
significant, or where there isn't functionality in Java. Otherwise, Java
is my choice.

--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-15 Thread Seymour J Metz

There is no automatic environment integration. There is an API that makes it 
easy for the developer of an application to support Rexx scripts and there are 
environments whose developers have exploited that API. ooRexx is not inferior 
in that regard.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of Jon 
Perryman 
Sent: Monday, April 15, 2024 1:08 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: REXX vs other languages WAS: Rexx numeric digits and scientific 
notation question

>Java's not perfect, but it is powerful and it is pretty much universally
>available on z/OS.

People don't understand the ingenuity behind REXX and don't understand the real 
problems it solves. From a language standpoint, REXX is just another language 
but it's real strength is it's environment integration. Instead of the caller 
maintaining libraries, the environment automatically integrates with REXX. For 
instance, REXX in the TSO environment, gives you access to TSO commands 
(address TSO) and z/OS programs (address linkmvs). Start ISPF and address 
ISPEXEC is available. ISPF option 2 gives you address ISREDIT. SYSCALLS ON 
gives you address syscalls.

For product developers, REXX is simple to integrate environments as witnessed 
by the plethora of integrated environments on z/VM, z/OS and probably z/VSE 
(e.g. some addressable environments: automation, CICS, CMS, CP, TSO, UNIX, 
SYSCALLS and more)

OOREXX is not REXX because it does not have the automatic environment 
integration and as you say, using JAVA instead of OOREXX would be preferable. 
REXX on the other hand is preferable over JAVA in many IBM environments. For 
instance, why would you use JAVA as your system automation environment language?

The complication of using OOP REXX is rarely beneficial for most environments. 
Generally, you are not building complicated applications. For instance, system 
automation will be the most complex but managing events under objects would be 
complicated and unmanageable given the current automation environment design.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

REXX vs other languages WAS: Rexx numeric digits and scientific notation question

2024-04-15 Thread Jon Perryman

>Java's not perfect, but it is powerful and it is pretty much universally
>available on z/OS.

People don't understand the ingenuity behind REXX and don't understand the real 
problems it solves. From a language standpoint, REXX is just another language 
but it's real strength is it's environment integration. Instead of the caller 
maintaining libraries, the environment automatically integrates with REXX. For 
instance, REXX in the TSO environment, gives you access to TSO commands 
(address TSO) and z/OS programs (address linkmvs). Start ISPF and address 
ISPEXEC is available. ISPF option 2 gives you address ISREDIT. SYSCALLS ON 
gives you address syscalls.

For product developers, REXX is simple to integrate environments as witnessed 
by the plethora of integrated environments on z/VM, z/OS and probably z/VSE 
(e.g. some addressable environments: automation, CICS, CMS, CP, TSO, UNIX, 
SYSCALLS and more) 

OOREXX is not REXX because it does not have the automatic environment 
integration and as you say, using JAVA instead of OOREXX would be preferable. 
REXX on the other hand is preferable over JAVA in many IBM environments. For 
instance, why would you use JAVA as your system automation environment language?

The complication of using OOP REXX is rarely beneficial for most environments. 
Generally, you are not building complicated applications. For instance, system 
automation will be the most complex but managing events under objects would be 
complicated and unmanageable given the current automation environment design.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-20 Thread Oscar

El 2024-03-19 02:40, David Crayford escribió:

On 19 Mar 2024, at 9:08 am, Andrew Rowley
wrote:

On 19/03/2024 11:05 am, David Crayford wrote:
If you’re care so much about Java catching errors at compile time
then why don’t you use Kotlin instead? NPE’s are one of the most
common form of Java runtime errors that can be eliminated using
Kotlins null safety.

Java's not perfect, but it is powerful and it is pretty much
universally available on z/OS. I'm writing functions for others to
build on e.g.:

https://static.blackhillsoftware.com/easysmf-rti/javadoc/com.blackhillsoftware.smf.realtime/com/blackhillsoftware/smf/realtime/package-summary.html

So using/targeting the language that is most available makes sense.

But my question was: Why Python? What are the reasons for using Python
rather than e.g. Java?

Though the conversation initially compared REXX to Python, it's clear
they are fundamentally different beasts and different ends of the
spectrum. Python is a powerful and widely-used programming language
with applications across various industries. It underpins critical
systems like the backend of Instagram's photo-sharing platform, and is
utilized by major players such as Tesla, Spotify, Uber, Amazon, NASA,
Netflix, and Facebook. Notably, IBM is investing in Python for z/OS,
with the ability to run on a zIIP with a 70% generosity factor and
libraries facilitating integration with RACF, enabling the use of RACF
keyrings with micro web frameworks like Flask. Certainly, IBM's
investment in Java is crucial for the future sustainability of z/OS.
On the other hand, REXX is likely supported as cheaply as possible by
a very small team, along with TSO.

David,

Do you have more details about the enabling of RACF keyrings in Python?
We are developing a Flask webapp and that would be fantastic.

Thanks!

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-19 Thread Seymour J Metz

That is an issue for any language. If it is going into production then the 
installation needs to manage updates. That typically means that new release of 
external packages go through similar CM and QA management as the inhouse code 
does. You don't use the most recent release; you use the one that your shop has 
vetted.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Pew, Curtis G 
Sent: Tuesday, March 19, 2024 2:24 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

On Mar 18, 2024, at 6:01 PM, Farley, Peter 
<031df298a9da-dmarc-requ...@listserv.ua.edu> wrote:

The really tricky part of letting programmers use Python is how do they get the 
necessary non-standard libraries for themselves?  I suspect most large shops 
will, in the name of “security”, prevent open access to the PyPi library 
repository, and no doubt highly control it in a bureaucratic snarl, with the 
actual breadth of available packages highly restricted to only those libraries 
that are “approved for use” in a locally maintained private repository.  Sad to 
say, I can see the bureaucratic delays to get access to a library piling up 
already.

We’ve licensed a package manager (Artifactory in our case, but I imagine there 
are others) and have configured pip so that it looks there instead of PyPI. 
This is mostly so we can manage local packages that we’ve developed just for 
use at the University, and it’s actually set up to proxy PyPI for packages it 
doesn’t have already, but I believe it could be used to only allow curated 
packages, which might help with the bureaucrats.


--
Curtis Pew
ITS Campus Solutions
curtis@austin.utexas.edu




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-19 Thread Pew, Curtis G

On Mar 18, 2024, at 6:01 PM, Farley, Peter 
<031df298a9da-dmarc-requ...@listserv.ua.edu> wrote:

The really tricky part of letting programmers use Python is how do they get the 
necessary non-standard libraries for themselves?  I suspect most large shops 
will, in the name of “security”, prevent open access to the PyPi library 
repository, and no doubt highly control it in a bureaucratic snarl, with the 
actual breadth of available packages highly restricted to only those libraries 
that are “approved for use” in a locally maintained private repository.  Sad to 
say, I can see the bureaucratic delays to get access to a library piling up 
already.

We’ve licensed a package manager (Artifactory in our case, but I imagine there 
are others) and have configured pip so that it looks there instead of PyPI. 
This is mostly so we can manage local packages that we’ve developed just for 
use at the University, and it’s actually set up to proxy PyPI for packages it 
doesn’t have already, but I believe it could be used to only allow curated 
packages, which might help with the bureaucrats.


--
Curtis Pew
ITS Campus Solutions
curtis@austin.utexas.edu




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-19 Thread Jeremy Nicoll

On Sat, 16 Mar 2024, at 18:38, Jeremy Nicoll wrote:
> On Fri, 15 Mar 2024, at 23:35, David Crayford wrote:

>> Working with REXX doesn't feel comfortable to me at all. I'm troubled 
>> by the fact that every function call carries a potential side effect. 
>
> EVERY function call?  Including calls of builtin functions?
>
> What do you mean?
>
> Is it a flaw in REXX implementation(s) or in language design?
>
> What makes the newer scripting languages unflawed?


David, would you mind answering these questions?

-- 
Jeremy Nicoll - my opinions are my own.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question


On 19/03/2024 12:40 pm, David Crayford wrote:

We utilize both languages, selecting the most suitable for each task at hand. 
Our primary application runs on Java using the Spring Boot framework. We 
orchestrate records originating from various z/OS data sources, transforming 
them into JSON or other pluggable formats, and dispatch them to analytics 
platforms, AI engines, or serve Prometheus metrics. We've developed numerous 
Java record mapping classes generated by our tooling, which is crafted in 
Python using Jinja2 templates and YAML schemas. Opting for Java in this context 
wouldn't be pragmatic.


I've done JSON generation for all the SMF records supported by EasySMF 
in Java, so I guess it can be done either way. It certainly worked for me.



With AI technology already a reality, Python stands as the prevailing 
programming language of the moment. While much buzz surrounds the new Telum 
chip in the z16, the question remains: How do we leverage its potential? For 
this, we require Python libraries—either TensorFlow or PyTorch—running on s390x 
architecture (for now).


My impresson has been that Python is central to AI, but I'm curious 
about more general use cases. What you are using it for doesn't really 
tell me why you are using it. Is it a good choice for e.g. summarizing a 
few hundred million CICS SMF records? I guess AI implies processing 
large quantities of data so maybe it is. On the other hand, processing 
power tends to be less restricted on other platforms...


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread David Crayford

> On 19 Mar 2024, at 9:08 am, Andrew Rowley  
> wrote:
> 
> On 19/03/2024 11:05 am, David Crayford wrote:
>> If you’re care so much about Java catching errors at compile time then why 
>> don’t you use Kotlin instead? NPE’s are one of the most common form of Java 
>> runtime errors that can be eliminated using Kotlins null safety.
> 
> Java's not perfect, but it is powerful and it is pretty much universally 
> available on z/OS. I'm writing functions for others to build on e.g.:
> 
> https://static.blackhillsoftware.com/easysmf-rti/javadoc/com.blackhillsoftware.smf.realtime/com/blackhillsoftware/smf/realtime/package-summary.html
> 
> So using/targeting the language that is most available makes sense.
> 
> But my question was: Why Python? What are the reasons for using Python rather 
> than e.g. Java?

We utilize both languages, selecting the most suitable for each task at hand. 
Our primary application runs on Java using the Spring Boot framework. We 
orchestrate records originating from various z/OS data sources, transforming 
them into JSON or other pluggable formats, and dispatch them to analytics 
platforms, AI engines, or serve Prometheus metrics. We've developed numerous 
Java record mapping classes generated by our tooling, which is crafted in 
Python using Jinja2 templates and YAML schemas. Opting for Java in this context 
wouldn't be pragmatic. Employing SnakeYAML and utilizing a map-like interface 
for traversing the object graph, or even resorting to POJO classes and beans, 
would entail significantly more effort. Python serves as our go-to choice for 
tooling, encompassing DevOps pipelines, and managing artifactory processes.

With AI technology already a reality, Python stands as the prevailing 
programming language of the moment. While much buzz surrounds the new Telum 
chip in the z16, the question remains: How do we leverage its potential? For 
this, we require Python libraries—either TensorFlow or PyTorch—running on s390x 
architecture (for now). Our AI products process mainframe data, including SMF, 
exclusively in Python. Noteworthy examples like ChatGPT and the Autopilot AI 
model training for Tesla automobiles are also Python-based. Additionally, 
automation tools like Red Hat Ansible, written in Python, are gaining traction 
on z/OS.

Concerns about uninitialized variables and similar issues need not weigh 
heavily on our minds. Modern IDEs catch such errors in real-time, offering 
robust support akin to Java, especially when configured to block commits if 
there are outstanding liniting warnings. While I personally use the enterprise 
versions of the IntelliJ suite, VS Code stands as a commendable and cost-free 
alternative.

Though the conversation initially compared REXX to Python, it's clear they are 
fundamentally different beasts and different ends of the spectrum. Python is a 
powerful and widely-used programming language with applications across various 
industries. It underpins critical systems like the backend of Instagram's 
photo-sharing platform, and is utilized by major players such as Tesla, 
Spotify, Uber, Amazon, NASA, Netflix, and Facebook. Notably, IBM is investing 
in Python for z/OS, with the ability to run on a zIIP with a 70% generosity 
factor and libraries facilitating integration with RACF, enabling the use of 
RACF keyrings with micro web frameworks like Flask. Certainly, IBM's investment 
in Java is crucial for the future sustainability of z/OS. On the other hand, 
REXX is likely supported as cheaply as possible by a very small team, along 
with TSO.

> 
> -- 
> Andrew Rowley
> Black Hill Software
> 
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question


On 19/03/2024 11:05 am, David Crayford wrote:

If you’re care so much about Java catching errors at compile time then why 
don’t you use Kotlin instead? NPE’s are one of the most common form of Java 
runtime errors that can be eliminated using Kotlins null safety.


Java's not perfect, but it is powerful and it is pretty much universally 
available on z/OS. I'm writing functions for others to build on e.g.:


https://static.blackhillsoftware.com/easysmf-rti/javadoc/com.blackhillsoftware.smf.realtime/com/blackhillsoftware/smf/realtime/package-summary.html

So using/targeting the language that is most available makes sense.

But my question was: Why Python? What are the reasons for using Python 
rather than e.g. Java?


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread Seymour J Metz

One of the things that makes a language useful is a large library. You can 
start using, e.g., Ada, C++, Java, LaTeX, ooRexx, Perl, Python, with only a 
handful of packages, and look for others as the need arises.

BTDT,GTTS

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר

From: IBM Mainframe Discussion List  on behalf of 
Farley, Peter <031df298a9da-dmarc-requ...@listserv.ua.edu>
Sent: Monday, March 18, 2024 7:01 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

IMHO the learning curve for Java and all the libraries you have to know and 
understand to make it at all useful far outweighs its presumptive establishment 
 in the z/OS ecosystem.

Again IMHO Python is intended to be a scripting language and as such it shares 
much design philosophy with Rexx and awk and other scripting languages that are 
primarily interpreted rather than compiled like Java.  Mind you I am not in 
love with the “significant indentation” syntax (far too easy to make a 
structural mistake), but it takes a much smaller learning curve to deal with 
that then learning and remembering all of the lengthy Java library names you 
need to know to do anything useful (in reverse hierarchical order no less, most 
significant qualifier at the end of every “name”? really?  Whose bright idea 
was that?).

Personally I welcome having Python available by default on z/OS (which isn’t 
here yet for most shops, but hopefully will be soon), along with all the other 
open source programs and utilities being actively ported to z/OS.  The really 
tricky part of letting programmers use Python is how do they get the necessary 
non-standard libraries for themselves?  I suspect most large shops will, in the 
name of “security”, prevent open access to the PyPi library repository, and no 
doubt highly control it in a bureaucratic snarl, with the actual breadth of 
available packages highly restricted to only those libraries that are “approved 
for use” in a locally maintained private repository.  Sad to say, I can see the 
bureaucratic delays to get access to a library piling up already.

As has been said many times before:  “You can’t win, you can’t break even, and 
you can’t get out of the game.  That’s Life.”

Peter

From: IBM Mainframe Discussion List  On Behalf Of 
Andrew Rowley
Sent: Monday, March 18, 2024 6:18 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

On 16/03/2024 11:17 am, David Crayford wrote:

> IBM and ISVs are working on Python APIs for products right now. And they will 
> be better than the REXX versions.

Why Python? I know it's the latest hot language, but what advantages

does it have over e.g. Java (well established on z/OS)?

I have looked into it a few times, but get as far as "significant

indentation" and "no variable declarations" and decide it's not

something I want to use. Is it a sign of weakness to ask the compiler to

help me avoid bugs?

--

This message and any attachments are intended only for the use of the addressee 
and may contain information that is privileged and confidential. If the reader 
of the message is not the intended recipient or an authorized representative of 
the intended recipient, you are hereby notified that any dissemination of this 
communication is strictly prohibited. If you have received this communication 
in error, please notify us immediately by e-mail and delete the message and any 
attachments from your system.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread David Crayford

Python has had type hints for ages 
https://docs.python.org/3/library/typing.html. If you use an IDE you can set 
the review to block commits if liniting fails. 

If you’re care so much about Java catching errors at compile time then why 
don’t you use Kotlin instead? NPE’s are one of the most common form of Java 
runtime errors that can be eliminated using Kotlins null safety. 

> On 19 Mar 2024, at 7:30 am, Andrew Rowley  
> wrote:
> 
> On 19/03/2024 9:53 am, Pew, Curtis G wrote:
>> You get used to the “significant indentation” thing pretty quickly. It 
>> really makes sense: you should be indenting blocks anyway to make them easy 
>> to read, so why clutter things up with braces or keywords?
>> 
>> Most scripting languages (including REXX) don’t require declaring variables. 
>> Since there’s no separate compile step you get the errors when they happen 
>> in any case, so declaring variables doesn’t buy you much.
> 
> I probably would get used to significant indentation, although I do indent 
> for readability and I'm not sure I want to be mixing readability and logic in 
> the same construct.
> 
> Explicitly declaring variables has a number of advantages:
> 
> - it flags errors due to e.g. misspellings
> 
> - it flags errors when you intend to create a new variable but reuse an 
> existing one
> 
> - it checks data types, e.g. for SMF data if you have a ZonedDateTime you 
> can't assign/compare a LocalDateTime without specifying the time zone. So the 
> class designers can protect you form a whole heap of common errors, and flag 
> them before the program starts.
> 
> -- 
> Andrew Rowley
> Black Hill Software
> 
> --
> For IBM-MAIN subscribe / signoff / archive access instructions,
> send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question


On 19/03/2024 10:01 am, Farley, Peter wrote:

IMHO the learning curve for Java and all the libraries you have to know and 
understand to make it at all useful far outweighs its presumptive establishment 
 in the z/OS ecosystem.


You really don't have to learn a lot of libraries to use Java. Basic I/O 
and Java collections will get you a very long way.


There are a lot of libraries, but they are there because they are 
(hopefully) easier than writing something yourself. You don't need to 
learn them until you actually need that function, and then you can make 
your choice whether to use an existing library or write your own.


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question


On 19/03/2024 9:53 am, Pew, Curtis G wrote:

You get used to the “significant indentation” thing pretty quickly. It really 
makes sense: you should be indenting blocks anyway to make them easy to read, 
so why clutter things up with braces or keywords?

Most scripting languages (including REXX) don’t require declaring variables. 
Since there’s no separate compile step you get the errors when they happen in 
any case, so declaring variables doesn’t buy you much.


I probably would get used to significant indentation, although I do 
indent for readability and I'm not sure I want to be mixing readability 
and logic in the same construct.


Explicitly declaring variables has a number of advantages:

- it flags errors due to e.g. misspellings

- it flags errors when you intend to create a new variable but reuse an 
existing one


- it checks data types, e.g. for SMF data if you have a ZonedDateTime 
you can't assign/compare a LocalDateTime without specifying the time 
zone. So the class designers can protect you form a whole heap of common 
errors, and flag them before the program starts.


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread Farley, Peter

IMHO the learning curve for Java and all the libraries you have to know and 
understand to make it at all useful far outweighs its presumptive establishment 
 in the z/OS ecosystem.

Again IMHO Python is intended to be a scripting language and as such it shares 
much design philosophy with Rexx and awk and other scripting languages that are 
primarily interpreted rather than compiled like Java.  Mind you I am not in 
love with the “significant indentation” syntax (far too easy to make a 
structural mistake), but it takes a much smaller learning curve to deal with 
that then learning and remembering all of the lengthy Java library names you 
need to know to do anything useful (in reverse hierarchical order no less, most 
significant qualifier at the end of every “name”? really?  Whose bright idea 
was that?).

Personally I welcome having Python available by default on z/OS (which isn’t 
here yet for most shops, but hopefully will be soon), along with all the other 
open source programs and utilities being actively ported to z/OS.  The really 
tricky part of letting programmers use Python is how do they get the necessary 
non-standard libraries for themselves?  I suspect most large shops will, in the 
name of “security”, prevent open access to the PyPi library repository, and no 
doubt highly control it in a bureaucratic snarl, with the actual breadth of 
available packages highly restricted to only those libraries that are “approved 
for use” in a locally maintained private repository.  Sad to say, I can see the 
bureaucratic delays to get access to a library piling up already.

As has been said many times before:  “You can’t win, you can’t break even, and 
you can’t get out of the game.  That’s Life.”

Peter

From: IBM Mainframe Discussion List  On Behalf Of 
Andrew Rowley
Sent: Monday, March 18, 2024 6:18 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

On 16/03/2024 11:17 am, David Crayford wrote:

> IBM and ISVs are working on Python APIs for products right now. And they will 
> be better than the REXX versions.

Why Python? I know it's the latest hot language, but what advantages

does it have over e.g. Java (well established on z/OS)?

I have looked into it a few times, but get as far as "significant

indentation" and "no variable declarations" and decide it's not

something I want to use. Is it a sign of weakness to ask the compiler to

help me avoid bugs?

--

This message and any attachments are intended only for the use of the addressee 
and may contain information that is privileged and confidential. If the reader 
of the message is not the intended recipient or an authorized representative of 
the intended recipient, you are hereby notified that any dissemination of this 
communication is strictly prohibited. If you have received this communication 
in error, please notify us immediately by e-mail and delete the message and any 
attachments from your system.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread Pew, Curtis G

On Mar 18, 2024, at 5:17 PM, Andrew Rowley  wrote:

Why Python? I know it's the latest hot language, but what advantages does it 
have over e.g. Java (well established on z/OS)?

The context here was using Python in place of REXX. It’s a scripting language, 
meaning you can just write your text file and then run it, without compiling or 
linking or such.


I have looked into it a few times, but get as far as "significant indentation" 
and "no variable declarations" and decide it's not something I want to use. Is 
it a sign of weakness to ask the compiler to help me avoid bugs?

You get used to the “significant indentation” thing pretty quickly. It really 
makes sense: you should be indenting blocks anyway to make them easy to read, 
so why clutter things up with braces or keywords?

Most scripting languages (including REXX) don’t require declaring variables. 
Since there’s no separate compile step you get the errors when they happen in 
any case, so declaring variables doesn’t buy you much.

Python allows me to mix object-oriented and functional programming, it doesn’t 
require a lot of “ceremony”, and it makes it easy to write short but readable 
programs.


--
Curtis Pew
ITS Campus Solutions
curtis@austin.utexas.edu




--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question


On 16/03/2024 11:17 am, David Crayford wrote:

IBM and ISVs are working on Python APIs for products right now. And they will 
be better than the REXX versions.


Why Python? I know it's the latest hot language, but what advantages 
does it have over e.g. Java (well established on z/OS)?


I have looked into it a few times, but get as far as "significant 
indentation" and "no variable declarations" and decide it's not 
something I want to use. Is it a sign of weakness to ask the compiler to 
help me avoid bugs?


--
Andrew Rowley
Black Hill Software

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread Seymour J Metz

Ruby is available on *ix and W; if you're going by use then you probably want 
Java and Python.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of Bob 
Bridges <0587168ababf-dmarc-requ...@listserv.ua.edu>
Sent: Monday, March 18, 2024 9:38 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

Perl...what environment(s) is it available in?  My usual coding platforms are 
z/OS (specifically TSO) and Windows, mostly MS Office.

I don't actually know PowerShell; I've been exposed to it, see that it's very 
powerful for some purposes, and have modified PS scripts in minor ways.  In 
other words my facility with PS is very much like younger mainframers' with 
JCL.  But since I'm supposed to be a security jock, and sometimes have reason 
to extract data from AD to compare with RACF/TSS/ACF2, I see that really 
learning PS would be a good thing.

As I've probably said here before, I lusted after ooRexx from the first day I 
heard about it, but at first couldn't see where I'd actually use it; I can't 
hand ooRexx code to clients, unless they already use it (and no one does).  I 
finally broke down and got myself a copy for a small 
plain-text-to-formatted-PDF conversion I did for an error manual; I tried 
converting the plain text to formatted RTF using VBA, but gave it up as a bad 
job and did it in ooRexx, after taking a few days off to learn what I don't 
know.  (There's a lot more to it than I expected.)  Now I use it for automation 
on my own machine, but that’s all.

Ruby -- no, never have.  Again, what environment(s) is it available on?

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* When I have a little money, I buy books; and if I have any left, I buy food 
and clothes.  -Erasmus */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Seymour J Metz
Sent: Sunday, March 17, 2024 15:14

CLIST will never go away, but I avoid it as much as possible. There is a very 
limited set of use cases for it, IMHO, and REXX has been my goto scripting 
language for decades, with a grudging nod to Perl when CPAN can make my life 
easier.

PowerShell suggests that you're not limited to Z, inwhich case it's worth 
looking at ooRexx.

Have you looked at Ruby?


From: IBM Mainframe Discussion List  on behalf of Bob 
Bridges <0587168ababf-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 7:58 PM

I can tell you how it happened to me, at any rate.  I was a long-time CLISTer, 
and then one day, back in the mid '80s it might have been, I ran across a 
warning from IBM that someday soon CLIST might go away and REXX would be the 
only supported language for system automation (or something like that).  I took 
them seriously - I didn't know at the time that they used to issue that warning 
periodically - and sat down with a manual to start learning REXX.  I quickly 
realized that it's ~much~ superior to CLIST, and have been an enthusiast ever 
since.

But that needn't stop me from tacking on other languages; I'm not tired of that 
yet, and I still have ambitions of adding more.  Python is better, you say?  
But can I use it in the TSO environment?  If it's only for Unix, I may pass for 
now.  I still work for multiple clients and it seems to me I could usefully 
focus on languages that the clients are likely to use themselves.  That means 
TSO REXX, VBA and VBS, SQL, assembler, probably PowerShell, maybe PL/1...  What 
else?  Seriously I'm open to the next one I should tackle.  I keep hearing 
about Python, Lua, Ruby, C++ and others, but in what environment(s) would I use 
them?

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

2024-03-18 Thread Bob Bridges

Perl...what environment(s) is it available in?  My usual coding platforms are 
z/OS (specifically TSO) and Windows, mostly MS Office.

I don't actually know PowerShell; I've been exposed to it, see that it's very 
powerful for some purposes, and have modified PS scripts in minor ways.  In 
other words my facility with PS is very much like younger mainframers' with 
JCL.  But since I'm supposed to be a security jock, and sometimes have reason 
to extract data from AD to compare with RACF/TSS/ACF2, I see that really 
learning PS would be a good thing.

As I've probably said here before, I lusted after ooRexx from the first day I 
heard about it, but at first couldn't see where I'd actually use it; I can't 
hand ooRexx code to clients, unless they already use it (and no one does).  I 
finally broke down and got myself a copy for a small 
plain-text-to-formatted-PDF conversion I did for an error manual; I tried 
converting the plain text to formatted RTF using VBA, but gave it up as a bad 
job and did it in ooRexx, after taking a few days off to learn what I don't 
know.  (There's a lot more to it than I expected.)  Now I use it for automation 
on my own machine, but that’s all.

Ruby -- no, never have.  Again, what environment(s) is it available on?

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* When I have a little money, I buy books; and if I have any left, I buy food 
and clothes.  -Erasmus */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Seymour J Metz
Sent: Sunday, March 17, 2024 15:14

CLIST will never go away, but I avoid it as much as possible. There is a very 
limited set of use cases for it, IMHO, and REXX has been my goto scripting 
language for decades, with a grudging nod to Perl when CPAN can make my life 
easier.

PowerShell suggests that you're not limited to Z, inwhich case it's worth 
looking at ooRexx.

Have you looked at Ruby?


From: IBM Mainframe Discussion List  on behalf of Bob 
Bridges <0587168ababf-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 7:58 PM

I can tell you how it happened to me, at any rate.  I was a long-time CLISTer, 
and then one day, back in the mid '80s it might have been, I ran across a 
warning from IBM that someday soon CLIST might go away and REXX would be the 
only supported language for system automation (or something like that).  I took 
them seriously - I didn't know at the time that they used to issue that warning 
periodically - and sat down with a manual to start learning REXX.  I quickly 
realized that it's ~much~ superior to CLIST, and have been an enthusiast ever 
since.

But that needn't stop me from tacking on other languages; I'm not tired of that 
yet, and I still have ambitions of adding more.  Python is better, you say?  
But can I use it in the TSO environment?  If it's only for Unix, I may pass for 
now.  I still work for multiple clients and it seems to me I could usefully 
focus on languages that the clients are likely to use themselves.  That means 
TSO REXX, VBA and VBS, SQL, assembler, probably PowerShell, maybe PL/1...  What 
else?  Seriously I'm open to the next one I should tackle.  I keep hearing 
about Python, Lua, Ruby, C++ and others, but in what environment(s) would I use 
them?

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

2024-03-17 Thread Mike Schwab

https://github.com/CBTTape/CBT993

Probably other CBT tape members to process.

On Sun, Mar 17, 2024 at 7:11 PM Rupert Reynolds  wrote:
>
> SMF logging of data for management information? I never did much with SMF,
> but I can't see why not.
>
> I did briefly consider being able to parse existing mapping macros, but
> that's bound to be a bigger job than it seems, especially now I'm a bit
> rusty and only have Hercules to play with.
>
> Structures (maybe 'map' because 'str' is already short for the most basic
> type of 'string'). And pointers to them, yes. Wouldn't be without them :-)
>
> I'll probably be old and slow, or losing my concentration, before it's even
> half finished. Still, it keeps me out of mischief when I'm not at work or
> converting the van for mobile glamping  :-)
>
> Roops
>
> On Sun, 17 Mar 2024, 18:31 Seymour J Metz,  wrote:
>
> > I probably would use ":=" for assignment and "=" for equality.
> >
> > Are you supporting SMF-like structures?
> >
> > --
> > Shmuel (Seymour J.) Metz
> > http://mason.gmu.edu/~smetz3
> > עַם יִשְׂרָאֵל חַי
> > נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
> >
> > ________________
> > From: IBM Mainframe Discussion List  on behalf
> > of Rupert Reynolds 
> > Sent: Sunday, March 17, 2024 2:08 PM
> > To: IBM-MAIN@LISTSERV.UA.EDU
> > Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> > question
> >
> > It's too soon to publish much, especially when I have a full time job doing
> > something else. To be honest I probably never will, because it only suits
> > my pet bigotries :-)
> >
> > But briefly, I looked at day 1 notes (on back of a gas bill). They included
> > these, not all of which will ever make it into use of course:
> >
> > . fairly terse {} syntax, borrowing from 'C' etc.
> >
> > . strongly typed by default
> >
> > . one type is bignum--arbitrary precision and base arithmetic, trig, logs
> >
> > . correctness and flexibility more important than speed (like external
> > functions in Rexx scripts, for example)
> >
> > . project to include thorough test cases, and any bugs/unintended quirks in
> > either impl or tests will be fixed ruthlessly, not supported. If it fails
> > the test, it is not the real thing.
> >
> > . compiled code could include interpreter for scripting
> >
> > . preserves case, but keywords and functions etc. not case sensitive
> >
> > . all keywords can be abbreviated (eg. if min abbreviation is 3, 'fun' is
> > same as 'function')
> >
> > . '=' not required for assignment!
> >
> > . ability to convert 'C' style strings and call 'C' code
> >
> > . all built-in functions for handling null-terminated data and UTF-16 to be
> > prefixed gk_ (short for "ghastly kludge" ;-) )
> >
> > Feel free to laugh/crjticise, but please be kind--I was drinking during
> > lockdown when I finished that list :-)
> >
> > I made some progress on the bignum logarithms and trig early, borrowing
> > heavily on the external Rexx functions I used under Windows.
> >
> > It does basics such as finding and moving files interpreted, so I can use
> > it to test my Rexx admin scripts, and vice versa, but there are *huge*
> > gaps, and I'm moving house this year, so... :-)
> >
> > Roops
> >
> >
> > On Sun, 17 Mar 2024, 16:58 Seymour J Metz,  wrote:
> >
> > > >  I'm developing a language
> > >
> > > Have you published any details?
> > >
> > > --
> > > Shmuel (Seymour J.) Metz
> > > http://mason.gmu.edu/~smetz3
> > > עַם יִשְׂרָאֵל חַי
> > > נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
> > >
> > > 
> > > From: IBM Mainframe Discussion List  on behalf
> > > of Rupert Reynolds 
> > > Sent: Saturday, March 16, 2024 9:07 AM
> > > To: IBM-MAIN@LISTSERV.UA.EDU
> > > Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> > > question
> > >
> > > My experience of modern scripting languages, compared with classic Rexx,
> > is
> > > that they all do something new more easily, but also I can't think of one
> > > that doesn't have an obvious pitfall (such as, for example, stumbling
> > badly
> > > over certain byte values such as NUL in strings).
> > &g

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

2024-03-17 Thread Rupert Reynolds

SMF logging of data for management information? I never did much with SMF,
but I can't see why not.

I did briefly consider being able to parse existing mapping macros, but
that's bound to be a bigger job than it seems, especially now I'm a bit
rusty and only have Hercules to play with.

Structures (maybe 'map' because 'str' is already short for the most basic
type of 'string'). And pointers to them, yes. Wouldn't be without them :-)

I'll probably be old and slow, or losing my concentration, before it's even
half finished. Still, it keeps me out of mischief when I'm not at work or
converting the van for mobile glamping  :-)

Roops

On Sun, 17 Mar 2024, 18:31 Seymour J Metz,  wrote:

> I probably would use ":=" for assignment and "=" for equality.
>
> Are you supporting SMF-like structures?
>
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
> עַם יִשְׂרָאֵל חַי
> נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
>
> 
> From: IBM Mainframe Discussion List  on behalf
> of Rupert Reynolds 
> Sent: Sunday, March 17, 2024 2:08 PM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> question
>
> It's too soon to publish much, especially when I have a full time job doing
> something else. To be honest I probably never will, because it only suits
> my pet bigotries :-)
>
> But briefly, I looked at day 1 notes (on back of a gas bill). They included
> these, not all of which will ever make it into use of course:
>
> . fairly terse {} syntax, borrowing from 'C' etc.
>
> . strongly typed by default
>
> . one type is bignum--arbitrary precision and base arithmetic, trig, logs
>
> . correctness and flexibility more important than speed (like external
> functions in Rexx scripts, for example)
>
> . project to include thorough test cases, and any bugs/unintended quirks in
> either impl or tests will be fixed ruthlessly, not supported. If it fails
> the test, it is not the real thing.
>
> . compiled code could include interpreter for scripting
>
> . preserves case, but keywords and functions etc. not case sensitive
>
> . all keywords can be abbreviated (eg. if min abbreviation is 3, 'fun' is
> same as 'function')
>
> . '=' not required for assignment!
>
> . ability to convert 'C' style strings and call 'C' code
>
> . all built-in functions for handling null-terminated data and UTF-16 to be
> prefixed gk_ (short for "ghastly kludge" ;-) )
>
> Feel free to laugh/crjticise, but please be kind--I was drinking during
> lockdown when I finished that list :-)
>
> I made some progress on the bignum logarithms and trig early, borrowing
> heavily on the external Rexx functions I used under Windows.
>
> It does basics such as finding and moving files interpreted, so I can use
> it to test my Rexx admin scripts, and vice versa, but there are *huge*
> gaps, and I'm moving house this year, so... :-)
>
> Roops
>
>
> On Sun, 17 Mar 2024, 16:58 Seymour J Metz,  wrote:
>
> > >  I'm developing a language
> >
> > Have you published any details?
> >
> > --
> > Shmuel (Seymour J.) Metz
> > http://mason.gmu.edu/~smetz3
> > עַם יִשְׂרָאֵל חַי
> > נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
> >
> > 
> > From: IBM Mainframe Discussion List  on behalf
> > of Rupert Reynolds 
> > Sent: Saturday, March 16, 2024 9:07 AM
> > To: IBM-MAIN@LISTSERV.UA.EDU
> > Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> > question
> >
> > My experience of modern scripting languages, compared with classic Rexx,
> is
> > that they all do something new more easily, but also I can't think of one
> > that doesn't have an obvious pitfall (such as, for example, stumbling
> badly
> > over certain byte values such as NUL in strings).
> >
> > Classic Rexx under TSO and Regina Rexx under Windows and Linux, despite
> > certain old-fashioned quirks, are still sometimes what I reach for when I
> > want to process some data while avoiding those pitfalls.
> >
> > The differences are so strong to me that I'm developing a language which
> is
> > effectively the best bits (IMHO) of Rexx, C and even older languages such
> > as Algol 68 (much underrated in my book) and hints of PL/1. I don't make
> > that much effort without reason :-)
> >
> > By definition it works the same interpreted or compiled, which brings a
> > couple of restrictions

Re: Rexx numeric digits and scientific notation question

CLIST will never go away, but I avoid it as much as possible. There is a very 
limited set of use cases for it, IMHO, and REXX has been my goto scripting 
language for decades, with a grudging nod to Perl when CPAN can make my life 
easier.

PowerShell suggests that you're not limited to Z, inwhich case it's worth 
looking at ooRexx.

Have you looked at Ruby?

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of Bob 
Bridges <0587168ababf-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 7:58 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

I can tell you how it happened to me, at any rate.  I was a long-time CLISTer, 
and then one day, back in the mid '80s it might have been, I ran across a 
warning from IBM that someday soon CLIST might go away and REXX would be the 
only supported language for system automation (or something like that).  I took 
them seriously - I didn't know at the time that they used to issue that warning 
periodically - and sat down with a manual to start learning REXX.  I quickly 
realized that it's ~much~ superior to CLIST, and have been an enthusiast ever 
since.

But that needn't stop me from tacking on other languages; I'm not tired of that 
yet, and I still have ambitions of adding more.  Python is better, you say?  
But can I use it in the TSO environment?  If it's only for Unix, I may pass for 
now.  I still work for multiple clients and it seems to me I could usefully 
focus on languages that the clients are likely to use themselves.  That means 
TSO REXX, VBA and VBS, SQL, assembler, probably PowerShell, maybe PL/1...  What 
else?  Seriously I'm open to the next one I should tackle.  I keep hearing 
about Python, Lua, Ruby, C++ and others, but in what environment(s) would I use 
them?

---
Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313

/* Sometimes you feel like a nut.  After a day of working on a walnut farm, you 
don't.  -Mike Rowe of the TV show "Dirty Jobs" */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
David Crayford
Sent: Friday, March 15, 2024 18:41

REXX can indeed be quite tricky to navigate. I recently conducted a session 
titled "Python for REXX programmers" at work, and during the preparation, I was 
surprised (although not entirely) by the numerous traps and pitfalls inherent 
in REXX. When you add to this its absence of basic functionalities like sorting 
lists, it begs the question: Why opt for REXX when we have a plethora of 
alternatives available today?

The obvious answer may be familiarity, but in our industry, this argument seems 
rather weak unless you're confined to a limited environment. After all, I 
wouldn't want to revert to using a 1990s-era flip-top phone, let alone a rotary 
dial from the 1970s.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

I probably would use ":=" for assignment and "=" for equality.

Are you supporting SMF-like structures?

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר

From: IBM Mainframe Discussion List  on behalf of 
Rupert Reynolds 
Sent: Sunday, March 17, 2024 2:08 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation 
question

It's too soon to publish much, especially when I have a full time job doing
something else. To be honest I probably never will, because it only suits
my pet bigotries :-)

But briefly, I looked at day 1 notes (on back of a gas bill). They included
these, not all of which will ever make it into use of course:

. fairly terse {} syntax, borrowing from 'C' etc.

. strongly typed by default

. one type is bignum--arbitrary precision and base arithmetic, trig, logs

. correctness and flexibility more important than speed (like external
functions in Rexx scripts, for example)

. project to include thorough test cases, and any bugs/unintended quirks in
either impl or tests will be fixed ruthlessly, not supported. If it fails
the test, it is not the real thing.

. compiled code could include interpreter for scripting

. preserves case, but keywords and functions etc. not case sensitive

. all keywords can be abbreviated (eg. if min abbreviation is 3, 'fun' is
same as 'function')

. '=' not required for assignment!

. ability to convert 'C' style strings and call 'C' code

. all built-in functions for handling null-terminated data and UTF-16 to be
prefixed gk_ (short for "ghastly kludge" ;-) )

Feel free to laugh/crjticise, but please be kind--I was drinking during
lockdown when I finished that list :-)

I made some progress on the bignum logarithms and trig early, borrowing
heavily on the external Rexx functions I used under Windows.

It does basics such as finding and moving files interpreted, so I can use
it to test my Rexx admin scripts, and vice versa, but there are *huge*
gaps, and I'm moving house this year, so... :-)

Roops

On Sun, 17 Mar 2024, 16:58 Seymour J Metz,  wrote:

> >  I'm developing a language
>
> Have you published any details?
>
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
> עַם יִשְׂרָאֵל חַי
> נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
>
> 
> From: IBM Mainframe Discussion List  on behalf
> of Rupert Reynolds 
> Sent: Saturday, March 16, 2024 9:07 AM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> question
>
> My experience of modern scripting languages, compared with classic Rexx, is
> that they all do something new more easily, but also I can't think of one
> that doesn't have an obvious pitfall (such as, for example, stumbling badly
> over certain byte values such as NUL in strings).
>
> Classic Rexx under TSO and Regina Rexx under Windows and Linux, despite
> certain old-fashioned quirks, are still sometimes what I reach for when I
> want to process some data while avoiding those pitfalls.
>
> The differences are so strong to me that I'm developing a language which is
> effectively the best bits (IMHO) of Rexx, C and even older languages such
> as Algol 68 (much underrated in my book) and hints of PL/1. I don't make
> that much effort without reason :-)
>
> By definition it works the same interpreted or compiled, which brings a
> couple of restrictions I'm willing to live with :-)
>
> Roops
> p.s. I'm not convinced that that familiarity is a reason to criticise
> choosing a language. Using something you know well is often a way of giving
> bettet value and reliability for ones employers.
>
>
>
>
>
> On Sat, 16 Mar 2024, 11:49 David Crayford, <
> 0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:
>
> > Hey Rony,
> >
> > From what I understand, you haven't had experience working on z/OS. Let's
> > stick to the topic and focus on discussing REXX as it functions on z/OS.
> > This means no discussions about ooRexx or Java bridges, as they don't
> exist
> > and are unlikely to in the future on z/OS.
> >
> > The majority of REXX programmers here utilize classic TSO REXX and
> > primarily work within a TSO/ISPF environment. In this setup, REXX lacks a
> > module system. Therefore, any routines or libraries need to be manually
> > copied and pasted wherever they're needed, or you have to create a
> > pre-processor to merge source files together. If your language lacks the
> > fundam

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

2024-03-17 Thread Rupert Reynolds

It's too soon to publish much, especially when I have a full time job doing
something else. To be honest I probably never will, because it only suits
my pet bigotries :-)

But briefly, I looked at day 1 notes (on back of a gas bill). They included
these, not all of which will ever make it into use of course:

. fairly terse {} syntax, borrowing from 'C' etc.

. strongly typed by default

. one type is bignum--arbitrary precision and base arithmetic, trig, logs

. correctness and flexibility more important than speed (like external
functions in Rexx scripts, for example)

. project to include thorough test cases, and any bugs/unintended quirks in
either impl or tests will be fixed ruthlessly, not supported. If it fails
the test, it is not the real thing.

. compiled code could include interpreter for scripting

. preserves case, but keywords and functions etc. not case sensitive

. all keywords can be abbreviated (eg. if min abbreviation is 3, 'fun' is
same as 'function')

. '=' not required for assignment!

. ability to convert 'C' style strings and call 'C' code

. all built-in functions for handling null-terminated data and UTF-16 to be
prefixed gk_ (short for "ghastly kludge" ;-) )

Feel free to laugh/crjticise, but please be kind--I was drinking during
lockdown when I finished that list :-)

I made some progress on the bignum logarithms and trig early, borrowing
heavily on the external Rexx functions I used under Windows.

It does basics such as finding and moving files interpreted, so I can use
it to test my Rexx admin scripts, and vice versa, but there are *huge*
gaps, and I'm moving house this year, so... :-)

Roops

On Sun, 17 Mar 2024, 16:58 Seymour J Metz,  wrote:

> >  I'm developing a language
>
> Have you published any details?
>
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
> עַם יִשְׂרָאֵל חַי
> נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
>
> 
> From: IBM Mainframe Discussion List  on behalf
> of Rupert Reynolds 
> Sent: Saturday, March 16, 2024 9:07 AM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation
> question
>
> My experience of modern scripting languages, compared with classic Rexx, is
> that they all do something new more easily, but also I can't think of one
> that doesn't have an obvious pitfall (such as, for example, stumbling badly
> over certain byte values such as NUL in strings).
>
> Classic Rexx under TSO and Regina Rexx under Windows and Linux, despite
> certain old-fashioned quirks, are still sometimes what I reach for when I
> want to process some data while avoiding those pitfalls.
>
> The differences are so strong to me that I'm developing a language which is
> effectively the best bits (IMHO) of Rexx, C and even older languages such
> as Algol 68 (much underrated in my book) and hints of PL/1. I don't make
> that much effort without reason :-)
>
> By definition it works the same interpreted or compiled, which brings a
> couple of restrictions I'm willing to live with :-)
>
> Roops
> p.s. I'm not convinced that that familiarity is a reason to criticise
> choosing a language. Using something you know well is often a way of giving
> bettet value and reliability for ones employers.
>
>
>
>
>
> On Sat, 16 Mar 2024, 11:49 David Crayford, <
> 0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:
>
> > Hey Rony,
> >
> > From what I understand, you haven't had experience working on z/OS. Let's
> > stick to the topic and focus on discussing REXX as it functions on z/OS.
> > This means no discussions about ooRexx or Java bridges, as they don't
> exist
> > and are unlikely to in the future on z/OS.
> >
> > The majority of REXX programmers here utilize classic TSO REXX and
> > primarily work within a TSO/ISPF environment. In this setup, REXX lacks a
> > module system. Therefore, any routines or libraries need to be manually
> > copied and pasted wherever they're needed, or you have to create a
> > pre-processor to merge source files together. If your language lacks the
> > fundamental basic features to sort an array then to me that’s a good
> > indication you should use one that does.
> >
> > I'm not spreading fear, uncertainty, and doubt (FUD). I'm simply stating
> > my observations based on over 30 years of using REXX on z/OS, including
> > developing extensions. I believe this gives me a significant level of
> > expertise to offer commentary on the matter.
> >
> >
>
> --
> For IB

Re: Rexx numeric digits and scientific notation question

> every function call carries a potential side effect.

Function calls in most languages carry potential side effects. In that respect 
REXX is superior because PROCEDURE drops access to everything except what you 
expose.

> When I hear about adapting to quirks, it seems to translate to "I acknowledge 
> REXX's flaws,
>  but I stick with it because it's what I'm familiar with, even if I have to 
> tolerate it.”

Not even close: it translates to "as with any other language, you have to carve 
the bird at the joints."

> brought attention to the shortcomings and limitations of REXX as a 
> programming language.

IMHO, if you can't recognize the shortcomings and limitations of foo then you 
don't understand foo.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 7:35 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

Working with REXX doesn't feel comfortable to me at all. I'm troubled by the 
fact that every function call carries a potential side effect. While we can 
resort to procedures, we then encounter the challenge of dealing with 
telescoping exposure lists. When I hear about adapting to quirks, it seems to 
translate to "I acknowledge REXX's flaws, but I stick with it because it's what 
I'm familiar with, even if I have to tolerate it.” The recent discussions on 
this forum have brought attention to the shortcomings and limitations of REXX 
as a programming language.

In comparison to other platforms, Z/OS used to offer limited options in terms 
of programming languages. However, that's no longer the case. What struck me as 
ironic during my recent presentation was that the majority of the audience were 
millennials who were unfamiliar with REXX. This might come as a surprise to 
seasoned veterans of mainframes who are used to REXX, but in today's landscape, 
familiarity with it isn't necessary.

> On 16 Mar 2024, at 7:19 am, Seymour J Metz  wrote:
>
> Every language has pitfalls. While I generally prefer strongly typed 
> languages, I find Rexx and ooRexx to be comfortable to work with, and it is 
> not difficult to adapt to its quirks:
>
> <http://www.rexxla.org/Newsletter/9812safe.html>
> <http://www.rexxla.org/Newsletter/9901safe.html>
>
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
> עַם יִשְׂרָאֵל חַי
> נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
>
> 
> From: IBM Mainframe Discussion List  on behalf of 
> David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
> Sent: Friday, March 15, 2024 6:40 PM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: Rexx numeric digits and scientific notation question
>
> REXX can indeed be quite tricky to navigate. I recently conducted a session 
> titled "Python for REXX programmers" at work, and during the preparation, I 
> was surprised (although not entirely) by the numerous traps and pitfalls 
> inherent in REXX. When you add to this its absence of basic functionalities 
> like sorting lists, it begs the question: Why opt for REXX when we have a 
> plethora of alternatives available today?
>
> The obvious answer may be familiarity, but in our industry, this argument 
> seems rather weak unless you're confined to a limited environment. After all, 
> I wouldn't want to revert to using a 1990s-era flip-top phone, let alone a 
> rotary dial from the 1970s.
>
>> On 16 Mar 2024, at 2:47 am, Charles Mills  wrote:
>>
>> Well, that explains a mystery. I did not realize that SIGNAL ON was pushed 
>> and popped on subroutine calls. I have had this vague problem where my 
>> SIGNAL ON NOVALUE did not seem to work but at the time of an error it is 
>> always easier to fix the NOVALUE condition than troubleshoot the SIGNAL ON.
>>
>> Thanks!
>> Charles
>>
>> On Thu, 14 Mar 2024 12:04:00 -0500, Glenn Knickerbocker  
>> wrote:
>>
>>> On Wed, 13 Mar 2024 11:01:30 -0500, Charles Mills  wrote:
>>>> And the answer is ... "The three numeric settings are automatically saved 
>>>> across internal and external subroutine and function calls."
>>>> I was setting numeric digits in an initialization subroutine, so Rexx 
>>>> helpfully unset it on return from initialization. I thought I had done it 
>>>> that way before but I guess I have not.
>>>
>>> Funny, I work with a lot of code that has a common subroutine for 
>>

Re: Rexx numeric digits and scientific notation question

CALL ON is intend for exception handlers that return; that code should never 
have survived review.

It's SIGNAL ON that unwinds the stack.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
Paul Gilmartin <042bfe9c879d-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 7:47 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

On Fri, 15 Mar 2024 23:24:38 +, Seymour J Metz wrote:

>CALL ON or SIGNAL ON?
>
???
CALL ON to a procedure coded in front of the main loop and drop
through without RETURN?  That would make things worse.

He would have wanted ITERATE ON.

>
>From:  Paul Gilmartin
>Sent: Friday, March 15, 2024 5:38 PM
>On Fri, 15 Mar 2024 19:36:12 +, Seymour J Metz wrote:
>
>>"unwinds" in a very disruptive and partial fashion.  I once debugged a naive 
>>co-workers
>program which handled an exception in a subroutine by SIGNAL to top of main 
>loop.
>Worked fine in a modest test data set.  Overflowed CALL/RETURN stack on a 
>larger
>data set.

--
gil

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN


--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Rexx numeric digits and scientific notation question

For OMVS and z/Linux, ooRexx is the gold standard and comparisons to classic 
Rexx are irrelevant.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר


From: IBM Mainframe Discussion List  on behalf of 
David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
Sent: Friday, March 15, 2024 8:17 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Rexx numeric digits and scientific notation question

> On 16 Mar 2024, at 7:45 am, Jay Maynard 
> <05997213d6c2-dmarc-requ...@listserv.ua.edu> wrote:
>
> That depends. Can you use, say, Python to implement all the scripting kinds
> of things you can use REXX for?

Like what, TSO? I don’t find I need to do that any more as I work in a UNIX 
shell. Let me flip that around. Can I use REXX to implement the kind of 
scripting that I do in Python? For example, process a YAML configuration file. 
We need to do that stuff on z/OS now. CICS resource definitions can be defined 
as YAML documents, configuration as code and all that stuff. DevOps, Git repos. 
REXX is a pretty poor language for anything modern.

IBM and ISVs are working on Python APIs for products right now. And they will 
be better than the REXX versions.

>
> On Fri, Mar 15, 2024 at 6:36 PM David Crayford <
> 0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:
>
>> Working with REXX doesn't feel comfortable to me at all. I'm troubled by
>> the fact that every function call carries a potential side effect. While we
>> can resort to procedures, we then encounter the challenge of dealing with
>> telescoping exposure lists. When I hear about adapting to quirks, it seems
>> to translate to "I acknowledge REXX's flaws, but I stick with it because
>> it's what I'm familiar with, even if I have to tolerate it.” The recent
>> discussions on this forum have brought attention to the shortcomings and
>> limitations of REXX as a programming language.
>>
>> In comparison to other platforms, Z/OS used to offer limited options in
>> terms of programming languages. However, that's no longer the case. What
>> struck me as ironic during my recent presentation was that the majority of
>> the audience were millennials who were unfamiliar with REXX. This might
>> come as a surprise to seasoned veterans of mainframes who are used to REXX,
>> but in today's landscape, familiarity with it isn't necessary.
>>
>>> On 16 Mar 2024, at 7:19 am, Seymour J Metz  wrote:
>>>
>>> Every language has pitfalls. While I generally prefer strongly typed
>> languages, I find Rexx and ooRexx to be comfortable to work with, and it is
>> not difficult to adapt to its quirks:
>>>
>>> <http://secure-web.cisco.com/1AatOlNoQ_1AfQlinDttzfh317YDeo-4sTIzlpTQgzz972u1_a0Uc6Zjajez1X0fOgNwevYuxc3iXlnJrVcDP32Tuud8_YL99u1ssdNKutkPojNTTkGX_RUaqKJE989FehJd2D0x03lNc7Uv894CKNjAr9OrwJBwMhkh1-UjSLcA-LFnZRaQT05KZm3AFiNLGXoxpseHTdEYJUUuNLoGsu_zUd26CMLdcjitDnXq4HDv_F2aeY2jvQ4ZaZ6cyYikm1syDEzCTNddqJ6eo2fobR-7yA3ZxZy0mU1e9V_Pn1HzbxZUqJpIkiVWTiNCcGP06aS1zCODlm79HQX-r4Jx1vGhHZ2OwD5GhOciwrJQwoPtdlnhzEsKpdQh13cy2mO-jeu0DcUIbvA6gBdoPBjAdtPhmeKhh3I_vb77MATAh4Wg/http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9812safe.html>
>>> <http://secure-web.cisco.com/1bQGzBCAzgINWEPx1EI4ITocCLWfjE3LWLYMvDqkSE01h_Gu3KHIh0Ij1onPd_24i0uwINVK7YZ6hAqCLr2RBz8nH4uQaIbzFpMUBt_lpSFys7jDAvamt_NffhO1U55zrap4UPSv15I87TcL8MhCliSyVWWcxnNd-26yPXYxSm8bredfUj1zcO0x8Uc5g6Fivf1uLVgURxNX0gICHg366LufM4etYVXfx4poXzsmQMDiZvZlDTrwQsMYp7k5_dMvgEmKKnuOJgDbByHXTgTo1KB7IAq_YrtRGjt85E0OyFMGuxYb7FtGaiKqGyHf6CARWxYV-7W5-M4GK6xMMoY1uCSyABaV5lne6hldEbt8mHFjI0_vNr1lJD0VCOUwhWzulOBrJTh0nSrgtaPqAtOlVjuG4RdKj1DHGtLBNfncxRpg/http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9901safe.html>
>>>
>>> --
>>> Shmuel (Seymour J.) Metz
>>> http://mason.gmu.edu/~smetz3
>>> עַם יִשְׂרָאֵל חַי
>>> נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר
>>>
>>> 
>>> From: IBM Mainframe Discussion List  on
>> behalf of David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
>>> Sent: Friday, March 15, 2024 6:40 PM
>>> To: IBM-MAIN@LISTSERV.UA.EDU
>>> Subject: Re: Rexx numeric digits and scientific notation question
>>>
>>> REXX can indeed be quite tricky to navigate. I recently conducted a
>> session titled "Python for REXX programmers" at work, and during the
>> preparation, I was surprised (although not entirely) by the numerous traps
>> and pitfalls inherent in REXX. When you add to this its absence of basic
>> functionalities like sorting lists, it begs the question: Why opt for REXX
>&

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

Every language has warts, including PL/I and REXX, but I believe that they are 
the best choices for writing ISPF dialogs, especially if you are allowed to use 
PCRE.

I don't supposed that a fully supported IBM port of Ruby to z/OS will ever 
happen, but it would catch my eye if it did. Likewise replacing the current 
backlevel REXX with ooRexx.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר

From: IBM Mainframe Discussion List  on behalf of 
David Crayford <0595a051454b-dmarc-requ...@listserv.ua.edu>
Sent: Saturday, March 16, 2024 7:49 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation 
question

Hey Rony,

From what I understand, you haven't had experience working on z/OS. Let's stick 
to the topic and focus on discussing REXX as it functions on z/OS. This means 
no discussions about ooRexx or Java bridges, as they don't exist and are 
unlikely to in the future on z/OS.

The majority of REXX programmers here utilize classic TSO REXX and primarily 
work within a TSO/ISPF environment. In this setup, REXX lacks a module system. 
Therefore, any routines or libraries need to be manually copied and pasted 
wherever they're needed, or you have to create a pre-processor to merge source 
files together. If your language lacks the fundamental basic features to sort 
an array then to me that’s a good indication you should use one that does.

I'm not spreading fear, uncertainty, and doubt (FUD). I'm simply stating my 
observations based on over 30 years of using REXX on z/OS, including developing 
extensions. I believe this gives me a significant level of expertise to offer 
commentary on the matter.

> On 16 Mar 2024, at 6:03 pm, Rony G. Flatscher  wrote:
>
> On 16.03.2024 01:17, David Crayford wrote:
>>> On 16 Mar 2024, at 7:45 am, Jay 
>>> Maynard<05997213d6c2-dmarc-requ...@listserv.ua.edu>  wrote:
>>>
>>> That depends. Can you use, say, Python to implement all the scripting kinds
>>> of things you can use REXX for?
>> Like what, TSO? I don’t find I need to do that any more as I work in a UNIX 
>> shell. Let me flip that around. Can I use REXX to implement the kind of 
>> scripting that I do in Python? For example, process a YAML configuration 
>> file.
> Yes, if you wanted, it is fairly easy BTW and would not be as potentially 
> dangerous if done in REXX than done with Perl or Python (cf. 
> <https://en.wikipedia.org/wiki/YAML#Security>).
>> We need to do that stuff on z/OS now. CICS resource definitions can be 
>> defined as YAML documents, configuration as code and all that stuff. DevOps, 
>> Git repos. REXX is a pretty poor language for anything modern.
>
> Again, unsubstantiated and derogative, please just stop behaving like a 
> religious warrior and stick to facts and discuss sorberly, stop your FUD 
> please!
>
>> IBM and ISVs are working on Python APIs for products right now.
> That is fine. On slides and in imaginations everything in the future is 
> always much better than what is available at present.
>> And they will be better than the REXX versions.
>
> Well, that has yet to be seen. If improvements materialize, then it would a) 
> be fine and b) be a reason to look into the existing, working REXX versions 
> for the same improvements then.
>
> A massive improvement for the mainframes were to make ooRexx available on 
> them.
>
> Combine ooRexx with the ooRexx-Java bridge and software engineers have 
> immediately gained the ability to use *any* Java API from ooRexx, without a 
> need to learn Java at all, it suffices to be able to read the HTML 
> documentation of Java classes. The easiness and the productivity gains can be 
> inferred if you know that my novices can do this successfully during the last 
> two months of the semester even becoming able to exploit the SSL/TLS Java 
> socket classes, besides awt/swing, JavaFX and some more.
>
> The potential savings for the mainframe users would be enormeous if they 
> started to exploit that combination. It is actually available already today 
> in the Linux subsystems such that one can assess the technology (I know of 
> deployments that exploit this combination in production, using ooRexx to run 
> programs that interact with DB2 using JDBC).
>
> ---rony
>
>>> On Fri, Mar 15, 2024 at 6:36 PM David Crayford <
>>> 0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:
>>>
>>>> Working with REXX doesn't feel comfortable to me at all. I'm troubled by
>>>> the fact that every function call carries a potential side effect. While we
>>>> can resort

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question

>  I'm developing a language

Have you published any details?

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3
עַם יִשְׂרָאֵל חַי
נֵ֣צַח יִשְׂרָאֵ֔ל לֹ֥א יְשַׁקֵּ֖ר

From: IBM Mainframe Discussion List  on behalf of 
Rupert Reynolds 
Sent: Saturday, March 16, 2024 9:07 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation 
question

My experience of modern scripting languages, compared with classic Rexx, is
that they all do something new more easily, but also I can't think of one
that doesn't have an obvious pitfall (such as, for example, stumbling badly
over certain byte values such as NUL in strings).

Classic Rexx under TSO and Regina Rexx under Windows and Linux, despite
certain old-fashioned quirks, are still sometimes what I reach for when I
want to process some data while avoiding those pitfalls.

The differences are so strong to me that I'm developing a language which is
effectively the best bits (IMHO) of Rexx, C and even older languages such
as Algol 68 (much underrated in my book) and hints of PL/1. I don't make
that much effort without reason :-)

By definition it works the same interpreted or compiled, which brings a
couple of restrictions I'm willing to live with :-)

Roops
p.s. I'm not convinced that that familiarity is a reason to criticise
choosing a language. Using something you know well is often a way of giving
bettet value and reliability for ones employers.

On Sat, 16 Mar 2024, 11:49 David Crayford, <
0595a051454b-dmarc-requ...@listserv.ua.edu> wrote:

> Hey Rony,
>
> From what I understand, you haven't had experience working on z/OS. Let's
> stick to the topic and focus on discussing REXX as it functions on z/OS.
> This means no discussions about ooRexx or Java bridges, as they don't exist
> and are unlikely to in the future on z/OS.
>
> The majority of REXX programmers here utilize classic TSO REXX and
> primarily work within a TSO/ISPF environment. In this setup, REXX lacks a
> module system. Therefore, any routines or libraries need to be manually
> copied and pasted wherever they're needed, or you have to create a
> pre-processor to merge source files together. If your language lacks the
> fundamental basic features to sort an array then to me that’s a good
> indication you should use one that does.
>
> I'm not spreading fear, uncertainty, and doubt (FUD). I'm simply stating
> my observations based on over 30 years of using REXX on z/OS, including
> developing extensions. I believe this gives me a significant level of
> expertise to offer commentary on the matter.
>
>

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN

Re: Hmm, 3 ... (Re: Rexx numeric digits and scientific notation question