Re: Assembler courses

[David Crayford]

On 26/9/22 10:13, Steve Smith wrote:

lol... We definitely need a guide to refracturing code.

More seriously, a decent commentary on how to use goto "correctly" would be
a nice thing to see.
Here you go, just in case you missed it the first time I posted 
https://koblents.com/Ches/Links/Month-Mar-2013/20-Using-Goto-in-Linux-Kernel-Code/ 


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

Re: Assembler courses

[David Crayford]

Here is another example of using a cleanup stack 
https://github.com/eclipse-openj9/openj9-omr/blob/openj9/port/win32/omrsignal.c. 
That's how we write our C code. SP evangelists would be inclined to nest 
if statements which would be harder to read and wouldn't pass code 
review in my team. Of course, withmore sophisticated languages cleanup 
is done using automatic finalization such as destructors in C++, 
try-with-resources in Java, using declarations in C#, "with" statements 
in Python etc. In programming languages that don't support finalization 
goto is a very good idea. I include COBOL in that statement. I've seen 
some god awful COBOL code with out of control nesting in my time.



On 26/9/22 02:07, Bernd Oppolzer wrote:

After looking at your example at
https://github.com/eclipse-openj9/openj9/blob/master/runtime/vm/classsupport.c 


I would like to comment:

the "goto done" in the first function is only necessary, because in C 
the return statement

serves two purposes:

- setting the return value
- returning control to the caller

In Pascal, for example, the return value of a function is set by 
assigning a value to the function name
(inside the function) and control is returned by reaching the end of 
the function, or (in case of
Stanford Pascal and more recent Pascal dialects) the return statement 
(which has no parameters etc.).


So there is a separation between the two purposes.

In Pascal then, there would be no need to branch to the end of the 
function, because there is the
one and only place where you set the function result from the local 
temp variable. Hence,
no need for a goto (no use case). The return statement would be at the 
position where the
goto done is. The value is assigned to the function name instead of 
the temp variable

(can be done at multiple places).

IIRC, this (the two purposes of the C return statement) has been 
mentioned in one
of the videos posted by Peter Sylvester. This (IMO) is a flaw of the C 
language.
There are others, for example that it's impossible to declare 
functions inside of functions

(no true ALGOL block concept).

Kind regards

Bernd


Am 25.09.2022 um 13:51 schrieb David Crayford:
Another thing that makes me incredibly dubious about some of the 
opinions in these videos is the hackneyed nonsense about "goto 
considered harmful". The original paper was misunderstood in that all 
goto statements are harmful and brainwashed a generation. Some of 
these videos present a trivial example using goto and refactor it 
using if/ifelse. In programming languages without scope based cleanup 
goto is not harmful. In fact it's leads to clean code as the branch 
direction is always descending to a cleanup block. Happily for me, 
the young guys I work with writing systems level Metal/C code haven't 
been seduced by this dogmatic BS.  Good C code uses goto statements 
as opposed to heavily nested or superfluously functionally decomposed 
routines. The IBM Openj9 JVM C code is a case in point 
https://github.com/eclipse-openj9/openj9/blob/master/runtime/vm/classsupport.c. 
I challenge anybody to write better code without goto statements.


On 20/09/2022 5:46 pm, Peter Sylvester wrote:

Hi,

49 years ago I 'stumbled' over Simula 67 (see video 1), well, at the 
university "informatik 1" course. I had gotten an Algol60 book given 
to me by my math teacher 2 years earlier. The student a year older 
learned PL/1. WE had an /168 and the Simula 67 system from the NCC 
(you can find it on the CBTTAPE, the turnkey system and elsewhere.


To assembler: On error, you got a nicely formatted storage dump of 
objects. One motivation


After two years and the first graduation (Vordiplom) with punched 
cards etc (but using the MFT like a PC), a got a job at at  the CS 
research center GMD:  MVS, TSO SPF, another universe. It would take 
to much here to explain all the reason why I did a lot of assembler 
(because of this I was able to work in an internship at the swiss 
Colony Computing Center), but I always more than mildly disliked aka 
hated the non structured way of assembled. My work was to write a 
fast program to create microfiches (block letters, index pages). The 
result were a set of structured programming macros (also on the 
cbttape).


Later  with UCLA/Mail, the formatting of "objects" on traces, dumps. 
and stack of function. Just read the "assembler" code (CBTTAPE).


Anyway, here some nice videos.

https://www.youtube.com/watch?v=pH-q2m5sb04

actually, why is smalltalk so close to objective C. Because of a 
Byte Magazine cover page.


https://www.youtube.com/watch?v=SFv8Wm2HdNM

https://www.youtube.com/watch?v=QM1iUe6IofM

https://www.youtube.com/watch?v=eEBOvqMfPoI

Some are provocative. There are many others. I really like "going 
virtually" to these conferences.


https://www.youtube.com/watch?v=_mZBa3sqTrI&t=45s

Sorry for this side tra

Re: IBM python documentation?

[David Crayford]

On 26/9/22 07:34, Farley, Peter x23353 wrote:

I know Rocket's port of python has some documented enhancements to support MVS dataset access among 
other things, but I have failed to find any documentation on the IBM websites for an IBM-produced 
"python Programmers Guide" (or similar) that would describe and provide examples for any 
"IBM-specific" functional enhancements to the base language facilities.

Is there any such documentation?  Or are the python.org documentation websites 
the only reference material available for the IBM port of python? (i.e., no 
functional enhancements at all are provided in the IBM port)

Correct! It's trivial to write an MVS I/O package if you have a C compiler.

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

Re: Assembler courses

[David Crayford]

According to Linus you’ve been brainwashed by using a garbage language 
https://koblents.com/Ches/Links/Month-Mar-2013/20-Using-Goto-in-Linux-Kernel-Code/

> On 26 Sep 2022, at 1:43 am, Bernd Oppolzer  wrote:
> 
> I try to be not dogmatic about GOTO statements,
> in fact, I am coding COBOL in my money (everyday) job, and there are lots of 
> GO TOs around;
> I try to remove them, when I do larger refactoring, but if not, I leave them 
> untouched.
> 
> But now for another GOTO story.
> 
> When I started my Stanford Pascal compiler adventure in 2011, the first 
> compiler pass (PASCAL1)
> had around 50 GOTO statements in it (in fact: 50 numeric labels which are 
> targets of GOTOs in Pascal;
> in Pascal, BTW, GOTOs are allowed, but they are sort of uncomfortable;
> you need a label declaration for them, not only the GOTO statement and the 
> target label -
> because the label is local to a block, the label number may be reused in 
> different blocks).
> The Stanford compiler, as many other Pascal compilers, is self-hosted,
> that means, it is written in Stanford Pascal and compiled by itself.
> The Stanford Pascal compiler pass 1 had 6.000 lines in 2011 ... with the 50 
> labels mentioned above
> (well, this was the 1982 McGill version, to be honest).
> 
> One of my first extensions to Stanford Pascal was to add CONTINUE, BREAK and 
> RETURN statements
> to it (semantics like in C). It turned out that almost all GOTOs were used to 
> implement the missing
> statements CONTINUE, BREAK and RETURN using GOTOs. I then started (after some 
> time)
> to remove the GOTOs by replacing them by the new statements, where this was 
> possible
> without problems.
> 
> Today the compiler pass 1 has almost 25.000 lines. It only contains 7 GOTO 
> statemens (I just checked it).
> Because, see above, I am not dogmatic about GOTO, I will leave them, as long 
> as there is no need
> to work on the procedures containing them.
> The compiler story (including downloads) is here: 
> http://bernd-oppolzer.de/job9.htm
> 
> IMO, GOTOs (and the statements mentioned above) must be used with care.
> If you don't use them right, nobody will be able to follow the logic in your 
> programs,
> including yourself (after some time). Indentation is key, and meaningful 
> comments.
> 
> Kind regards
> 
> Bernd
> 
> 
>> Am 25.09.2022 um 13:51 schrieb David Crayford:
>> Another thing that makes me incredibly dubious about some of the opinions in 
>> these videos is the hackneyed nonsense about "goto considered harmful". The 
>> original paper was misunderstood in that all goto statements are harmful and 
>> brainwashed a generation. Some of these videos present a trivial example 
>> using goto and refactor it using if/ifelse. In programming languages without 
>> scope based cleanup goto is not harmful. In fact it's leads to clean code as 
>> the branch direction is always descending to a cleanup block. Happily for 
>> me, the young guys I work with writing systems level Metal/C code haven't 
>> been seduced by this dogmatic BS.  Good C code uses goto statements as 
>> opposed to heavily nested or superfluously functionally decomposed routines. 
>> The IBM Openj9 JVM C code is a case in point 
>> https://github.com/eclipse-openj9/openj9/blob/master/runtime/vm/classsupport.c.
>>  I challenge anybody to write better code without goto statements.
>> 
>> 
> 
> --
> 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: Assembler courses

[David Crayford]

Another thing that makes me incredibly dubious about some of the 
opinions in these videos is the hackneyed nonsense about "goto 
considered harmful". The original paper was misunderstood in that all 
goto statements are harmful and brainwashed a generation. Some of these 
videos present a trivial example using goto and refactor it using 
if/ifelse. In programming languages without scope based cleanup goto is 
not harmful. In fact it's leads to clean code as the branch direction is 
always descending to a cleanup block. Happily for me, the young guys I 
work with writing systems level Metal/C code haven't been seduced by 
this dogmatic BS.  Good C code uses goto statements as opposed to 
heavily nested or superfluously functionally decomposed routines. The 
IBM Openj9 JVM C code is a case in point 
https://github.com/eclipse-openj9/openj9/blob/master/runtime/vm/classsupport.c. 
I challenge anybody to write better code without goto statements.


On 20/09/2022 5:46 pm, Peter Sylvester wrote:

Hi,

49 years ago I 'stumbled' over Simula 67 (see video 1), well, at the 
university "informatik 1" course. I had gotten an Algol60 book given 
to me by my math teacher 2 years earlier. The student a year older 
learned PL/1. WE had an /168 and the Simula 67 system from the NCC 
(you can find it on the CBTTAPE, the turnkey system and elsewhere.


To assembler: On error, you got a nicely formatted storage dump of 
objects. One motivation


After two years and the first graduation (Vordiplom) with punched 
cards etc (but using the MFT like a PC), a got a job at at  the CS 
research center GMD:  MVS, TSO SPF, another universe. It would take to 
much here to explain all the reason why I did a lot of assembler 
(because of this I was able to work in an internship at the swiss 
Colony Computing Center), but I always more than mildly disliked aka 
hated the non structured way of assembled. My work was to write a fast 
program to create microfiches (block letters, index pages). The result 
were a set of structured programming macros (also on the cbttape).


Later  with UCLA/Mail, the formatting of "objects" on traces, dumps. 
and stack of function. Just read the "assembler" code (CBTTAPE).


Anyway, here some nice videos.

https://www.youtube.com/watch?v=pH-q2m5sb04

actually, why is smalltalk so close to objective C. Because of a Byte 
Magazine cover page.


https://www.youtube.com/watch?v=SFv8Wm2HdNM

https://www.youtube.com/watch?v=QM1iUe6IofM

https://www.youtube.com/watch?v=eEBOvqMfPoI

Some are provocative. There are many others. I really like "going 
virtually" to these conferences.


https://www.youtube.com/watch?v=_mZBa3sqTrI&t=45s

Sorry for this side track



--
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: Assembler courses

[David Crayford]

On 25/09/2022 3:56 pm, Peter Sylvester wrote:

On 25/09/2022 05:02, David Crayford wrote:
There's some interesting videos here. All entertaining in their own 
way. It's like any dogma, if you want to believe then you will. If 
you have spent your entire career using structured programming you 
probably think "hell yeah"!


Is such a person the primary target audience of this presentation? I 
don't think so (the audience is younger). In some other presentation 
(I don't know the conf/presenter): "If you agree with me, you haven't 
understood".


Maybe, but young people just want a decent job and that usually means 
using either an OO or FP language in todays job market. We've got a lot 
of HLASM in our code base and it's not easy to find young people who 
want to commit to learning a language they consider to be a dead end.
Young people move around a lot and want to pick up skills that are 
transferable. The job market for HLASM programmers may get lively as 
more people start to retire. Same for COBOL and PL/I. Half of our team 
have moved to 3 day weeks with a view to retiring.



One funny "critique/comment" is the fortran COMEFROM :-) Easy to 
implement btw. The spaghetti monster"s programming language, (R)amen.


IMHO, your last sentence may provide a hint. If one spends all his 
career using the same "paradigm" (or whatever one may call a 
"religion") ... And then may even reinvent a square shaped wheel 
(where pi equals 4) ...  Or a cubic sphere (in my neighborhood), which 
is actually fun :-)


  https://www.youtube.com/watch?v=cNSTJ2Y80OQ

Lot's of things to be critized about the following, too. But whow, 
putting *all* this into a short presentation. (I missed some, e.g. 
SNOBOL, CDL).


  https://www.youtube.com/watch?v=0fpDlAEQio4


LOL. Agreed, good fun :)



As already said, I was lucky to work as a student (and later as IBM 
systems programmer) in a mainframe environment of a CS and math 
research institute (GMD) with >1000 people. Chance to see "beyond and 
avove" and "play with" a multitude of different perspectives and 
experiments, some good, some no so, software (totally unstructured 
programs), hardware (lisp/reduction machine, Suprenum, Eumel), 
theories (Petri Nets, Interval arithmetic). And, of course, preachers, 
dogmas.


Our ported tools team develop the SciPy libraries for IBM machine 
learning products on z/OS using highly optimized C/C++ code to implement 
Python libraries. The MIT "Introduction to programming" course is now 
taught in Python. SciPy supports both OOP and FP paradigms. 
https://docs.scipy.org/doc/scipy/






Best












--
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: Assembler courses

[David Crayford]

On 24/09/2022 9:48 pm, Kirk Wolf wrote:

On Fri, Sep 23, 2022, at 6:09 PM, Paul Gilmartin wrote:

On Fri, 23 Sep 2022 23:18:21 +0200, Bernd Oppolzer wrote:


Many thanks for these links;

I especially appreciate the tutorials by Brian Will "Object-Oriented
Programming is Bad",
https://www.youtube.com/watch?v=QM1iUe6IofM


Far worse is the attempt to use OO techniques in non-OO languages.
"Where is this function called?"
"A pointer to it is saved in a struct."
After that, it's anyone's guess.


Some of the very best, most ubiquitous C-language software uses object-based techniques 
such as you describe ("struct with function pointer" interfaces).It's 
actually quite common, and when used correctly it provides for separation of concerns in 
large systems.   Granted, some bad software uses it too :-)


Indeed. A perfect example is the Linux VFS (Virtual File System) which 
sure looks like a polymorphic plugin implementation using function 
pointers to me ;) https://tldp.org/LDP/khg/HyperNews/get/fs/vfstour.html





Kirk Wolf
Dovetailed Technologies
http://coztoolkit.com

--
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: Assembler courses

[David Crayford]

There's some interesting videos here. All entertaining in their own way. 
It's like any dogma, if you want to believe then you will. If you have 
spent your entire career using structured programming you probably think 
"hell yeah"!


On 20/09/2022 5:46 pm, Peter Sylvester wrote:

Anyway, here some nice videos.

https://www.youtube.com/watch?v=pH-q2m5sb04


I enjoyed this video the most because it's not peddling dogma. It covers 
some very interesting topics on the current trend in programming, which 
is functional programming. Almost all popular OO languages support the 
FP paradigm, C++, Java, C#, Scala, Kotlin, JavaScript, Python etc. 
Immutability, value types, monads have been around for a least a decade 
and that is the way people are writing programs. I'm afraid I don't see 
a return to structured programming happening in my lifetime. Of course, 
the mainframe is an exception in that the huge legacy code base is 
mostly written in COBOL with a significant amount of PL/I. Having said 
that, most of the modernization initiatives in DB2, CICS, IMS are Java 
frameworks/libraries.






actually, why is smalltalk so close to objective C. Because of a Byte 
Magazine cover page.


https://www.youtube.com/watch?v=SFv8Wm2HdNM

https://www.youtube.com/watch?v=QM1iUe6IofM

https://www.youtube.com/watch?v=eEBOvqMfPoI

Some are provocative. There are many others. I really like "going 
virtually" to these conferences.


https://www.youtube.com/watch?v=_mZBa3sqTrI&t=45s

Sorry for this side track


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

Re: z/OS ISPF Git Interface (ZIGI) Version 3.15 Released

[David Crayford]

There are no tar files anymore Wayne. You need to use conda unless you 
have enterprise support where you can use SMP/E.


https://community.rocketsoftware.com/forums/forum-home/digestviewer/viewthread?GroupId=79&MessageKey=8cde99be-0255-49f5-87e6-e59b4016f965&CommunityKey=1e694975-142d-4f2d-9b52-0e37e225db41&tab=digestviewer#bm8cde99be-0255-49f5-87e6-e59b4016f965

On 25/09/2022 7:19 am, Wayne Bickerdike wrote:

Trying the Zigi update. During the install says I need updated versions of
bash, perl, gzip etc. On the Rocket download site I can't find the .tar
files.

Can someone point me to the correct location? Thanks.

On Tue, Sep 13, 2022 at 12:28 AM Lionel B. Dyck  wrote:


We have released version 3.15 of ZIGI - the z/OS ISPF Git Interface.

You can find it at
  - https://zigi.rocks
or
- https://cbttape.org/ftp/updates/CBT997.zip

Enjoy

Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what
you
are, reputation merely what others think you are.”   - - - John Wooden

--
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: Assembler courses

[David Crayford]

On 25/09/2022 1:12 am, Bernd Oppolzer wrote:
IMO, there are some really interesting use cases for such techniques, 
for example


- sort routines where the comparison functions is generic, that is, a 
function pointer

- same for search routines
- same for dynamic arrays of structs, indexed by key structs (I 
implemented one, using AVL trees)

- a function package which prints or plots other functions

and so on.

In C, I did this using function pointers.
In Pascal, I can pass procedures or functions to procedure parameters 
(procedures passed as
parameters to other procedures), which is virtually the same as 
function pointers, but IMO
looks nicer. This is from the 1960s. I never considered this as being 
OO, but in fact,
all the above things, although implemented in procedural languages 
like C and Pascal,

are TEMPLATES.

If I really feel the need for such solutions (which I do sometimes), I 
anyway like to stick
with procedural languages like, see above, Pascal and C, and I don't 
use C++;

all the OO overhead makes me feel bad.


What is this overhead you talk about? The C++ mantra is "you don't pay 
for what you don't use". If you don't want to use virtual inheritance 
then don't! What you will gain is strong typing, RAII, STL with strings, 
containers etc.
Modern C++ is heavy on generics (templates) which are stored in header 
files so open up more possibilities for optimization at the cost of 
compile times and module size. I would take the Pepsi Challenge in a 
drag race between your AVL tree library using a callback with linkage 
overhead against std::map or
a similar generic library that generates bespoke code for the type.  To 
really make it interesting I could roll out the big guns and use a 
highly optimized library from Google 
https://code.google.com/archive/p/cpp-btree/wikis/UsageInstructions.wiki


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

Re: Assembler courses

[David Crayford]

On 25/09/2022 1:38 am, Bernd Oppolzer wrote:
The link to the video once again, because it was damaged by my eMail 
client:

https://www.youtube.com/watch?v=IRTfhkiAqPw

Brian's videos are entertaining but his modus operandi is to take some 
really bad code and then demonstrate how to refactor it using structured 
programming. That may be convincing for folks that haven't used OO 
languages but it's not for those that have. For example, his Java 
command line parser is just bogus. Modern Java APIs (Java 1.5 +) use 
annotations https://rvesse.github.io/airline/. Sure beats the hell out 
of using getopt() in C.




HTH, kind regards

Bernd


Am 24.09.2022 um 19:12 schrieb Bernd Oppolzer:

Sorry for this topic drift, but this is interesting, anyway.

IMO, there are some really interesting use cases for such techniques, 
for example


- sort routines where the comparison functions is generic, that is, a 
function pointer

- same for search routines
- same for dynamic arrays of structs, indexed by key structs (I 
implemented one, using AVL trees)

- a function package which prints or plots other functions

and so on.

In C, I did this using function pointers.
In Pascal, I can pass procedures or functions to procedure parameters 
(procedures passed as
parameters to other procedures), which is virtually the same as 
function pointers, but IMO
looks nicer. This is from the 1960s. I never considered this as being 
OO, but in fact,
all the above things, although implemented in procedural languages 
like C and Pascal,

are TEMPLATES.

If I really feel the need for such solutions (which I do sometimes), 
I anyway like to stick
with procedural languages like, see above, Pascal and C, and I don't 
use C++;

all the OO overhead makes me feel bad.

See this video:

Object-Oriented Programming is Embarrassing: 4 Short Examples - 
YouTube 


Kind regards

Bernd


Am 24.09.2022 um 18:51 schrieb Tony Harminc:

On Fri, 23 Sept 2022 at 19:10, Paul Gilmartin <
042bfe9c879d-dmarc-requ...@listserv.ua.edu> wrote:

Far worse is the attempt to use OO techniques in non-OO languages.

"Where is this function called?"
"A pointer to it is saved in a struct."
After that, it's anyone's guess.

Years ago I inherited a good size (~200 kLOC) assembler program that 
had a
lot of old-fashioned techniques. But at the same time it had a 
structured
macro scheme that was quite advanced, and included an internal 
subroutine

call/stack mechanism. I updated the macros to generate symbols for the
assembler xref/ADATA about what was being called and from where, and 
only
then discovered that the subcall macro had the option to load the 
"function

pointer" (address) from a field in a "struct" (DSECT), thus making a
complete static xref of calls impossible. The best that could be done
(other than a complete control/data flow analysis) was to also log what
updated those pointers in the struct, but correlating them was almost
impossible.

Bad code can be written using just about any programming paradigm in 
any

language.

Tony H.

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email tolists...@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


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

Re: Assembler courses

[David Crayford]

On 24/09/2022 7:09 am, Paul Gilmartin wrote:

On Fri, 23 Sep 2022 23:18:21 +0200, Bernd Oppolzer wrote:


Many thanks for these links;

I especially appreciate the tutorials by Brian Will "Object-Oriented
Programming is Bad",
https://www.youtube.com/watch?v=QM1iUe6IofM


Far worse is the attempt to use OO techniques in non-OO languages.


What nonsense! JavaScript didn't get classes until ES6 but everybody was 
implementing objects using closures and the prototype. Same with Lua, no 
classes but OO can be implemented using meta-tables.




"Where is this function called?"
"A pointer to it is saved in a struct."
After that, it's anyone's guess.


In a language like C which lacks generics how would you write a generic 
data structure library without using function pointers for comparators?






the tips how to improve procedural programming from minute 33 ca.
This is so true, but certain tips require a language more powerful than C,
for example PL/1 or Pascal, which supports nesting of procedure and
function definitions.


I sometimes perceive nested procedure definitions as a primitive ancestor
of Objects -- they contain data and methods (so does a DCB.)
I suspect language designers eschew nested procedures for the poor
excuse that a procedure must be identified by two pointers, not just one.

I also liked the term "curly brace languages", which I never heard

before :-)


Which is PL/I?



Even if you don't agree with the opinions expressed here, it is IMO of
great value to look at these videos.

Am 20.09.2022 um 11:46 schrieb Peter Sylvester:

Anyway, here some nice videos.

https://www.youtube.com/watch?v=pH-q2m5sb04

actually, why is smalltalk so close to objective C. Because of a Byte
Magazine cover page.

https://www.youtube.com/watch?v=SFv8Wm2HdNM

https://www.youtube.com/watch?v=QM1iUe6IofM

https://www.youtube.com/watch?v=eEBOvqMfPoI

Some are provocative. There are many others. I really like "going
virtually" to these conferences.

https://www.youtube.com/watch?v=_mZBa3sqTrI&t=45s


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

Re: Assembler courses

[David Crayford]

Another example is the pthread library which uses a naming convention 
that describes the context it's operating on. For example, 
pthread_mutex_lock, pthread_cond_wait etc. I've used this kind of naming 
convention myself but I only write Metal/C these days and C++ when using 
LE.


FWIW, the term method is used to describe a virtual function. The reason 
Java refers to member functions as methods is because by default all 
functions are virtual unless you declare them final. It's the other way 
round in C++.


On 22/09/2022 11:29 pm, Charles Mills wrote:

You want an example of object oriented design on the mainframe? I have = no 
idea what the implementation language is but it could be PL/X, = assembler, C, 
etc. It does not matter. (It is clearly not a pure C++ =
library.)

IBM System SSL, a crypto library on z/OS.

Every call operates on one particular kind of data structure: an = "environment," a 
socket, etc. Each of those "packages" of {data = structure, one or more calls} could be 
thought of as an object and its =
methods.=20

Charles

--
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: Assembler courses

[David Crayford]

On 20/09/2022 10:56 pm, Michael Stein wrote:

I have been coding in C++ and Java for so long OOP is second nature to me
now. Well, in C++ I prefer the interfaces using templates. Java has morphed
into into a hybrid OO/FP language since the introduction of the Streams API
in Java 8. It's common now not to code imperative loop statements at all.
One can use object based programming in any language that supports function
pointers. I have seen a lot of HLASM code that would benefit from such a
design. One of the key principles of OO was to replace conditional logic
with polymorphic types. An example in C is the z/OS stdio library. fopen()
is a factory function that returns an opaque handle with read/write/close
functions pointers set that can handle many different access methods using
the same abstract functions. This is a clean design that unfortunately isn't
as common as it should be.

And when you open a DCB for QSAM you don't care about the device type...


Not quite what I was talking about which is polymorphism. For example, 
fopen() can instantiate QSAM, BSAM, VSAM (KSDS, RRDS, ESDS), Hiperspace, 
z/OS UNIX file etc. I have no doubt that object based design is possible in
assembler but I have never seen it. I've seen plenty of structured 
programming using macros. The majority of HLASM programmers haven't been 
exposed to OOP so don't look to solve problems using that paradigm.





How old is that 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

Re: Assembler courses

[David Crayford]

On 19/09/2022 7:59 am, Charles Mills wrote:

I've never had occasion to try write OO programs on the mainframe.
to me it seems that the chief value of classes and class methods is a
way of organizing my subroutines and functions and limiting their
scope to particular uses which seems to me would be useful in some
mainframe programs
I gather some OO languages are available to OMVS users here

Let me jump in here with a very personal note and say I *have* written a very 
successful* mainframe program in a totally OO paradigm. So yes, OO is totally 
relevant to mainframe software.


And kudos to you because not everybody could make the jump from HLASM to 
C++.


I have been coding in C++ and Java for so long OOP is second nature to 
me now. Well, in C++ I prefer the interfaces using templates. Java has 
morphed into into a hybrid OO/FP language since the introduction of the 
Streams API in Java 8. It's common now not to code imperative loop 
statements at all. One can use object based programming in any language 
that supports function pointers. I have seen a lot of HLASM code that 
would benefit from such a design. One of the key principles of OO was to 
replace conditional logic with polymorphic types. An example in C is the 
z/OS stdio library. fopen() is a factory function that returns an opaque 
handle with read/write/close functions pointers set that can handle many 
different access methods using the same abstract functions. This is a 
clean design that unfortunately isn't as common as it should be.





To me, yes, it is a method of organization of data and subroutines. It is a totally different way of thinking 
about things. Let me see if I can express this. You have a program. You want to add some functionality to it. 
Rather than thinking separately "I will need some new data fields" and "I will need some new 
subroutines" instead you think "I will need a 'package' of new data fields and subroutines that 
operate on those fields." It is a way of organizing the effort that I found to work extremely well for 
me. I cannot picture writing a large program any other way: not as a hodgepodge of fields and subroutines, 
but rather as a collection of smallish 'packages' of data and their attendant subroutines.

Utterly industry-standard C++ is available for developing both "legacy" and UNIX programs on z/OS. The 
program I refer to above is run with JCL as an STC; nothing external about it screams "C" or "OO" 
or "OMVS."

*Licensed by quite a few "name" companies and then acquired by a big-name 
software company for fairly big bucks.

Charles

--
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: realtime monitoring of various storage subpools

[David Crayford]

> On 26 Aug 2022, at 1:31 pm, Hank Oerlemans 
> <03c4d8bf55f3-dmarc-requ...@listserv.ua.edu> wrote:
> 
> I'm very fond of the new stuff in SDSF with z/OS 2.5 .

Me too. Rob and his team are adding outstanding features with every new 
release. The x-mem browsing into foreign address spaces was particularly 
popular in our team. 

> 
> --
> 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: Worldwide IBM zSystems Security Conference: October 11-14, 2022

[David Crayford]

On 19/08/2022 12:10 am, Charles Mills wrote:

There is always a line of tourists -- many of them American -- at the McDonalds 
on the Champs-Élysées.


There's also a Starbucks on the Champs-Élysées! Considering the French 
pride themselves on their cafe culture that's quite a surprise.




I am told even the most dedicated fans of French cuisine can get a hankering 
for a hamburger after a couple of weeks of withdrawal.


I'm sure Paris can serve up a better burger than a dirty Macca's! 
Although they do have a tailored menu that offers croque monsieur's etc. 
I believe they call that grill cheese in the US and cheese toasties in 
the UK and Australia.
IMO, you would be bonkers to hanker for a Big Mac in Paris when the best 
sandwich is without doubt the Jambon-Beurre with lashings of French 
butter, mustard and if you really want to guild the lily a few cornichons.





Burger King has been in France since at least the 80's. I remember seeing them 
there in 1989.


No doubt America is known for junk food but I have had some amazing 
eating in the most unexpected places. I went to SHARE in Orlando and 
visited a shopping mall to get the kids some sneakers. Luckily, I 
skipped the food court and ended
up in a ground floor restaurant that served me the most unbelievable 
baby beet and goats cheese salad with artisan sourdough breads. All the 
top notch ingredients were produced locally or in the continental USA. 
The only thing that puzzles me is
for a country which loves BBQ so much why Americans don't dig lamb. It 
doesn't get any better then slow-cooked shoulder of lamb.





Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Pommier, Rex
Sent: Thursday, August 18, 2022 8:03 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Worldwide IBM zSystems Security Conference: October 11-14, 2022

Timothy,

I don't think people go to France to eat Burger King.  :-)

--
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: TESTAUTH from C/C++

[David Crayford]

inline bool isauth() {
  int rc;
  __asm (" TESTAUTH FCTN=1"
    : "=NR:r15"(rc)
    :
    : "r1", "r14", "r15");
  return rc == 0;
}

On 16/08/2022 2:17 am, Tony Harminc wrote:

Marginally related to my previous question - I'd like to do a TESTAUTH from
C/C++ code, and refuse to run if I'm not APF authorized. I'm not proposing
to actual use the result for any sort of my own security testing, but just
to know if calling a C/C++ library function that is documented to require
APF (or better) is likely to fail so I can tell the user early.

I don't see a C library function to do this. The TESTAUTH expansion is
tiny, and I could use __ASM(...), but it's perhaps neater to just test
JSCBAUTH directly in C code. Yes, I realize TESTAUTH is more than just
testing that one bit, but I think it's true that if that bit is off (and
I'm not in supervisor state or system key, which I won't be), then a
TESTAUTH would fail, and that's all I want to know.

Oddly enough, there *is* a library function that appears to test for the
Program Controlled state. Well, maybe not - it's __must_stay_clean() which
tests for the "must not lose Program Controlled" status, so not quite the
same.

What's the best approach?

Tony H.

--
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: CC compiler under CMS - LSEARCH option

[David Crayford]

You will have to use macro file extension in the C code. 

#include “file.macro”

> On 14 Aug 2022, at 8:09 am, Paul Gilmartin 
> <042bfe9c879d-dmarc-requ...@listserv.ua.edu> wrote:
> 
> On Sun, 14 Aug 2022 00:49:20 +0300, Binyamin Dissen wrote:
> 
>> I am trying to tell the C compiler to use MACRO file types for #include.
>> 
> Are you the author or are you working from FOSS or other distributed source?
> 
> If the latter, consider BFS.  Its directory structure may be more similar to 
> what
> exists in the real world.
> 
> on MVS-z/OS, I found it easier to build from HFS than struggle with Classic 
> PDS.
> 
> One other thing I found invaluable was gmake's VPATH for building for 
> disparate
> targets (MVS, Solaris) from a single NFS source tree.
> 
> 
>> The doc states:
>> ==
>> COMMANDS CC All Help Information
>> LSEarch(opt)|NOLSEarch NOLSEARCH is the default. The LSEARCH option
>> directs the preprocessor to
>>   look for the user include files in the specified libraries or MACLIBs,
>> on the specified minidisks, or in the specified BFS directories. The
>> format of the LSEARCH option is:LSEARCH (opt,opt,...)
>> where:   opt may be one of the following:-  A CMS 
>> filemode
>> -  A BFS path name-  (fname.suffix) = (subopt,subopt,...) where:
>> - fname is the name of the include file or *   - suffix is the
>> suffix of the include file or *   - subopt can be a filemode,
>> LIB(maclib_name,maclib_name,...), or NOLIB.
>> ==
>> 
>> I have tried multiple versions of LSEARCH with no luck.
>> 
>> cc **name** c * (lsearch(*.macro)
>> WARNING CCN3261 Suboption *.macro is not valid for option LSEARCH.
>> 
>> cc **name** c * (lsearch(*.*.*)
>> WARNING CCN3261 Suboption *.*.* is not valid for option LSEARCH.
>> 
>> I can simply rename the MACRO to H and it works, but this is a bug in my
>> bonnet.
> 
> -- 
> 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: Location of IBM python SDK language and standard library documentation?

[David Crayford]

Rockets Python could do I/O to MVS data sets. Rocket also ported the 
Python CFFI package which would make writing a library in pure Python a 
snip. I wonder if IBM has ported CFFI? I would open an RFE. IBM have 
created MVS file I/O packages for golang and Node.js.



On 31/07/2022 7:02 am, Farley, Peter x23353 wrote:

I have been looking around on various IBM websites trying to find the IBM 
versions of the normal python language and python standard library 
documentation to answer a few z/OS-specific python questions.

1.  Does the z/OS implementation of the python language standard function "open()" accept z/OS Unix System Services 
file name format for MVS flat and PDS(E) datasets (e.g., "//'MVS.FLAT.FILE'" and "//'MVS.PDS(PDSMEM)'")?  
(I.E., under the covers does it use the "open()" or "fopen()" C library function?)
2.  Is the "zos_util" library package available in all versions of the z/OS 
python SDK?

TIA for any RTFM or url's you can point me to.  PDF's of the documentation for 
offline reading would be welcome if they are available.

Peter
--


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: HLASM Developer - Full-time, direct hire - 100% Remote

[David Crayford]

I think the salary may be $144kAUD. If not, I need to ask for a pay rise :)

On 13/07/2022 1:37 am, Tommy Phillips wrote:

Hi Everybody,

I have a job opportunity (full-time, direct hire and remote) I wanted to share 
with you all. My client is an international software company looking for a 
HLASM developer to work remotely from the pacific time zone (for overlap with a 
team based in Australia). The pay is around $144k/yr with some potential 
flexibility. I've included the description below for your review. Please reach 
out if you're potentially interested and want to talk through the details.

Thanks,
Tommy

TITLE: Sr. Software Engineer
LOCATION: Fully Remote
BENEFITS & PERKS: Excellent healthcare plan, life & disability insurance, health 
& fitness reimbursements, great PTO plan, 401k plan with match, leadership and skills 
training opportunities, two paid work days for off-site training, and a paid work day for 
community service.

HOW YOU WILL MAKE AN IMPACT
We are seeking a Systems Software Engineer to develop and support IMS 
performance products for IBM z/OS mainframes.

In this role, you'd become a highly valued technical expert taking ownership of 
one or more products with the support of a globally distributed team of 
engineering experts.
You would find opportunities for creative collaboration with your peers through 
enhancements to our world-class portfolio of IMS performance products.

TECHNICAL EXPERIENCE

   *   High Level Assembler (HLASM) and technical knowledge of IMS internals.
   *   Highly desirable skills include C, DTL, REXX, and familiarity with IMS 
performance products.
   *   The successful applicant may have previously worked on IMS performance 
or monitoring products, have a solid understanding of IMS logs, and may also 
have worked with IMS control blocks and ma.
   *   You will feel at home in this role if you have a background in mainframe 
product development and support coupled with an eagerness to both learn new 
things and to share what you know with others.

Tommy Phillips | Sr. Technical Recruiter
o. 303.569.8993 | m. 614.301.6607
[https://bridgeviewit.intersellerusercontent.com/uploads/5pgfibqu/image001.png]
Want to chat? Get on my 
calendar.
LinkedIn 

 | Twitter 

 | 
Facebook


--
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: NOTSP The Latin of Software Code Is Thriving - The New York TimesThat'

[David Crayford]

That’s awesome. Did maintenance programmers really exist back then?

> On 13 Jul 2022, at 8:13 am, Charles Mills  wrote:
> 
> Sorry 'bout the link. How about
> 
> https://bit.ly/3z2y5XO 
> 
> Charles
> 
> 
> -Original Message-
> From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
> Behalf Of Charles Mills
> Sent: Tuesday, July 12, 2022 4:50 PM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: NOTSP The Latin of Software Code Is Thriving - The New York
> TimesThat'
> 
> Or as I said in 1974
> 
> https://books.google.com/books?id=XrgyMRVh128C&lpg=PA16&ots=Zc1NP23_DN&dq=co
> mputerworld%20cobol%20charles%20mills&pg=PA16 
> 
> 
> 
> Charles
> 
> 
> -Original Message-
> From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
> Behalf Of Seymour J Metz
> Sent: Tuesday, July 12, 2022 5:55 AM
> To: IBM-MAIN@LISTSERV.UA.EDU
> Subject: Re: NOTSP The Latin of Software Code Is Thriving - The New York
> TimesThat'
> 
> That's a lesson that they learned on Multics way back one; worry about the
> design first. During an I/O redesign, they wrote PL/I code to replace code
> originally written in ALM (assembler), and the PL/I version was faster. Not
> because of the compiler, but because of the improved 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

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

Re: NOTSP The Latin of Software Code Is Thriving - The New York Times

[David Crayford]

On 12/07/2022 12:21 am, Charles Mills wrote:

+1

And when new hardware comes out, taking advantage of the new architecture is a 
simple matter of updating ARCH() in your C/C++ compile and re-building. You 
probably don't have the appetite to re-work your carefully hand-tuned assembler.


+1 you can't optimize for hardware that hasn't been invented yet



I know whereof I speak. I wrote a commercial product in C++ that successfully handled 
millions of events per second, with CPU utilization that was considered satisfactory by 
customers. Non-trivial events: basically taking an SMF record, reformatting a hundred or 
more fields using a "report writer"* type architecture, translating it to UTF-8 
(non-trivial) and pushing it out the TCP stack.

*By report writer type architecture, I mean it did not work the way you would 
write a hard-coded program, working its way through one SMF record section at a 
time. It went customer-specified-field by customer-specified-field, so for two 
adjacent fields in the same section, it had to decode the relevant triplet 
twice.
We can easily push millions of events through our stack  which is 
written in Metal/C and Java.


https://www.ibm.com/docs/en/om-im/5.6.0?topic=monitor-getting-started



Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Andrew Rowley
Sent: Sunday, July 10, 2022 6:22 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: NOTSP The Latin of Software Code Is Thriving - The New York Times

On 9/07/2022 1:10 am, Colin Paice wrote:

I was told
If it executes

 1. a million times a second - write in assembler
 2. a thousand times a second write it in cobol or C
 3. once a second - write it in Java
 4. Else /bash/rexx/

Probably not an accurate picture these days.

It would have to be a very select piece of assembler to have any
significant advantage over C / C++. C and C++ have the advantage that
the compiler doesn't have to produce maintainable or comprehensible
code, so it can do lots of optimizations, inlining, loop unrolling etc.
- whatever the compiler writers found produces the fastest code. Of
course you can do the same in assembler - it is just a question of
whether it is practicable for larger pieces of code.

Java: that is probably reasonable if you are talking about starting a
JVM from scratch every time e.g. like a z/OS batch job. If you are
talking about a routine executed by a running program, I would expect
Java to be close to C. (Certainly not 3 orders of magnitude different.)



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

Re: Java (Re: Some questions on SYSCALL

[David Crayford]

On 10/07/2022 6:49 pm, Rony wrote:
  
Am 09.07.2022 um 03:15 schrieb David Crayford :

On 8/07/2022 7:17 pm, Rony G. Flatscher wrote:

On 07.07.2022 17:45, David Crayford wrote:
On 7/07/2022 7:53 pm, Rony G. Flatscher wrote:

On 06.07.2022 11:03, Seymour J Metz wrote:

... cut ...

There is one ecosystem that beats Perl, Python and practically any others: 
Java. For every problem domain, for new emerging technologies there are Java 
class libraries which one can take advantage of. As Java classes get compiled 
to intermediate byte code, these Java class libraries can be deployed and used 
immediately on any hardware and any operating system for which a Java virtual 
machine exists.

That's debatable! I'm a full time Java programmer in the last few years and I 
like. We use Spring Boot which is a high quality framework that makes it 
pleasant to use. I would use SB even for a slightly complex command line 
interface. However, the build systems are a bit spotty compared to Node.js, 
Python etc.

Eclipse, NetBeans, IntelliJ, ...

I build Java in IntelliJ using Maven. Also, we use a DevOps pipeline driven by 
Jenkins so using an IDE is out of the question.



Maven is creaking with it's ugly XML pom.xml and

Beauty lies in the eyes of the beholder ...

Maven is not Java and still an incredible boon!

I agree. I just don't like XML. I would rather use Gradle with it's nice Groovy 
DSL where I can drop down and write code for tricky configurations.



Gradle doesn't work very well on some systems.

What does not work for you?

Would you think that the Java multiplatform build system which is done with 
Gradle would be possible, if that were true what you say?

Gradle doesn't work properly on z/OS. First thing I tried was to nobble 
spawning the daemon. I used AOT -Xshareclasses so start up times were not a 
problem. However, Gradle was downloading lots of unwanted dependencies and 
filled up the file system cache. I abandoned it and stuck to Maven.



C# is a far better language then Java.

Excuse me? 😂

Off the top of my header.

1. Generics done properly with reflection support, not puny type erasure.

Java retains generics information in byte code (for the compiler) after type 
erasure (such that the runtime does not have to recheck after compilation, 
after all the compiler checked already).


2. No checked exceptions

One can use no checked exceptions in Java if one wished. OTOH checked 
exceptions are there and one can take advantage of them.


The JRE uses checked exceptions so you can't avoid them. The damage is 
done. The mess created by checked exceptions became more evident when 
Java 8 introduced Lambda's. There is nothing more ugly than a try/catch 
block in a lambda function. Some people create wrappers but that's just 
bloat. Checked exceptions are widely considered a failed experiment.






3. Unsigned integer types

Not really a problem.


It's a problem for our products. We process a lot of unsigned 64-bit 
integers and perform arithmetic such as division and a BigInteger is not 
acceptable for performance reasons. James Gosling admitted that Java 
didn't implemented unsigned integers as he wanted to keep the language 
simple for new programmers. That's another historical mistake that we 
are paying the price off. Back then Java was designed for very different 
use cases. Writing cryptographic algorithms in Java without an unsigned 
Long is painful. Gosling's nanny state hand holding hasn't aged well. He 
didn't implement operator overloading because he didn't like the way it 
was used for iostreams in C++. Another BIG mistake that makes the 
language awkward to use when doing arithmetic on BigDecimal, BigInteger 
types.


BTW, the very existence of Long.divideUnsigned() is proof enough that 
Java needs unsigned integers. In JDK16 they have optimized the function 
to use an algorithm from Hackers Delight that uses twos-complement 
binary operators. It's a shame we're stuck on JDK8 and the JDK16 code 
uses an unfriendly license for IBM code.




4. Value types

Not really a problem.


Maybe not for you. It's my understanding that you're an educator that 
teaches stuff like OLE and Windows GUI programming using JavaFX. The 
products I work on are back-end systems that process missions of records 
that originate from z/OS data sources. We need to serialize those binary 
records to other formats such as JSON as efficiently as possible. C# has 
struct value types and pointers (unsafe blocks) which would be brilliant 
for this kind of work. IBM realizes this and have implemented 
PackedObjects in their JDK which use intrinsics. Very similar to structs 
and value types in C#. Shame it's not portable!


https://www.ibm.com/docs/en/sdk-java-technology/7.1?topic=poet-packed-objects-2





5. Better support for functional program, LINQ

How so, which bytecodes do you think of?

Re: Java (Re: Some questions on SYSCALL

[David Crayford]

On 8/07/2022 7:43 pm, Rony G. Flatscher wrote:

On 08.07.2022 03:38, David Crayford wrote:

On 7/07/2022 7:53 pm, Rony G. Flatscher wrote:
When I select a language for a job, one of the things that I look 
at is the ecosystem. I prefer ooRexx to Perl, but I find myself using
Perl for some tasks because CPAN is an awesome resource. Python may 
not be the best language for the task at hand, but it pays to check 
what packages are available.


Indeed Perl and Python have a great wealth of libraries available to 
them.


There is one ecosystem that beats Perl, Python and practically any 
others: Java


According to http://www.modulecounts.com/ which shows the number of 
unique packages


Methodology: "... Data is collected /by scraping the relevant websites 
/once a day via a cron job and then stored in a Postgresql database 
for later retrieval. Growth rates are calculated by averaging data 
over the last week. I'm gathering counts of separate modules, so 
multiple versions of the same module/package/gem only count once 
(foo-1.2, foo-1.3 and bar-1.0 would count as 2 total).  ..."


Questioning the methodology, completeness, correctness and as a result 
the relevance. Did not find any checkbox for Java there hence 
wondering where your Java figures come from.


It gets the Java figures from Maven Central 
https://search.maven.org/stats. There is no denying that Java has an 
gigantic eco-system. And a hell of a lot of it is top notch. The product 
I'm currently working on wouldn't exist without Java open source.






Node.js   2019534
Java       483102
Python  386118
Perl      18354

So the undisputed winner as far as ecosystem is JavaScript. 


This may be more an indication that there are many shortcomings and 
many packages by different authors that try to make the same needed 
functionalities available.


... cut ...

Ad Java: JRE comes already with a wealth of packages on board that are 
add-ons in other languages.


The gripe I have is that what comes with the JRE is typically not as 
good as open source. For example, JDK 11 finally included a half decent 
HttpClient but it doesn't support anyway near the feature set of open 
source clients such as OkHttp or Jetty 
https://www.mocklab.io/blog/which-java-http-client-should-i-use-in-2020/. 
To my knowledge there is still no support for JSON or Yaml even in JDK 18.





In addition, almost all important business applications have Java APIs 
such that one can regard such applications as additional Java packages 
(e.g. OpenOffice/LibreOffice mainly implemented in C++ gained Java 
APIs and the ability to implement modules in Java; one result is the 
creation of a Java scripting framework for OpenOffice/LibreOffice 
which allows any language for which a javax.script implementation 
exists to be used as a scripting and macro language; one example for 
this comes with BSF4ooRexx).


Or think of the JDBC packages of the different database vendors, or ...

I just downloaded vsam.js to process a VSAM data set in Node on z/OS 
and it works well. IBM are certainly giving

Node more love then REXX which will never officially support VSAM.


Indeed this is strange that IBM does not support REXX the same as 
other technologies.


IBM also provide a VSAM I/O module for Go 
https://github.com/ibmruntimes/go-recordio.





Has that possibly to do (wild guess) that the developers do not know 
how to create REXX APIs on the mainframe? As probably C++ has a role 
here, then probably CMake based ooRexx 5 with its C++ APIs would make 
the creation of external ooRexx function libraries quite simple on the 
mainframe as well (judging from the existence of "z/OS XL C/C++ 
Library Reference SA22-7821" and "z/OS XL C/C++ Programming Guide 
SC09-4765").


The REXX programming services on z/OS are built for assembler. Bridging 
to C/C++ can be done. I have code to do that but it's tricky. Porting 
ooRexx to z/OS is very difficult. I actually managed to build it around 
2008. If you look in the oorexx-devel archives you will se conversations 
between myself and Rick McGuire. There is a lot of weird pthread stuff 
intertwined with message passing that made it unsuitable for running in 
an ISPF environment. I put it in the too-hard basket and a a couple of 
years later discovered Lua which was simple to port and unbelievably 
effecient. Several orders of magnitude faster than TSO REXX.




But then, if ooRexx and BSF4ooRexx were there (and they are available 
in the Linux subsystem), then one can use ooRexx to exploit 
com.ibm.jzos.ZFile (there seem to be samples on the Internet that 
demonstrate using it 
<https://www.ibm.com/docs/en/sdk-java-technology/7?topic=SSYKE2_7.0.0/com.ibm.java.zsecurity.api.70.doc/com.ibm.jzos/com/ibm/jzos/sample/vsam/file/package-summary.html>).


The first requirement from users on this list would be to run ooRexx 
from TSO. The vast majority of z/OS folks don't know how

Re: Java (Re: Some questions on SYSCALL

[David Crayford]

On 8/07/2022 7:17 pm, Rony G. Flatscher wrote:

On 07.07.2022 17:45, David Crayford wrote:

On 7/07/2022 7:53 pm, Rony G. Flatscher wrote:

On 06.07.2022 11:03, Seymour J Metz wrote:

... cut ...


There is one ecosystem that beats Perl, Python and practically any 
others: Java. For every problem domain, for new emerging 
technologies there are Java class libraries which one can take 
advantage of. As Java classes get compiled to intermediate byte 
code, these Java class libraries can be deployed and used 
immediately on any hardware and any operating system for which a 
Java virtual machine exists.


That's debatable! I'm a full time Java programmer in the last few 
years and I like. We use Spring Boot which is a high quality 
framework that makes it pleasant to use. I would use SB even for a 
slightly complex command line interface. However, the build systems 
are a bit spotty compared to Node.js, Python etc. 

Eclipse, NetBeans, IntelliJ, ...


I build Java in IntelliJ using Maven. Also, we use a DevOps pipeline 
driven by Jenkins so using an IDE is out of the question.




Maven is creaking with it's ugly XML pom.xml and


Beauty lies in the eyes of the beholder ...

Maven is not Java and still an incredible boon!


I agree. I just don't like XML. I would rather use Gradle with it's nice 
Groovy DSL where I can drop down and write code for tricky configurations.






Gradle doesn't work very well on some systems.


What does not work for you?

Would you think that the Java multiplatform build system which is done 
with Gradle would be possible, if that were true what you say?


Gradle doesn't work properly on z/OS. First thing I tried was to nobble 
spawning the daemon. I used AOT -Xshareclasses so start up times were 
not a problem. However, Gradle was downloading lots of unwanted 
dependencies and filled up the file system cache. I abandoned it and 
stuck to Maven.





C# is a far better language then Java. 


Excuse me? 😂


Off the top of my header.

1. Generics done properly with reflection support, not puny type erasure.
2. No checked exceptions
3. Unsigned integer types
4. Value types
5. Better support for functional program, LINQ
6. Better enumeration support, with the yield|| statement

I could go on. I don't use C# but I spent a weekend learning it and it's 
a great language. Kotlin has similar features but is crippled by the 
JVM. For example, there is no byte code support for unsigned integers.



Kotlin meets 95% of the requirements but we dismissed it because it's 
not mainstream so we're stuck with Java.


Poor you! ;)
(You got stuck in one of the most up-to-date and maintained languages 
and environments that sets you free from being locked-in in a specific 
platform.)


I use Java every day. I'm happy to use it. But I disagree that it's on 
of the most up-to-date languages. There differences between Java 8 and 
Java 16 are so insignificant it's worth upgrading.





Yes. But you need to use Open Source libraries for it to be easy to 
use. The JRE doesn't cut it.


Hmm?

The JRE includes a wealth of functionality, a wealth of packages that 
in other languages are only available as add-ons.


However, we still need libraries such as Google Guava, Apache Commons, 
Lombok to plug the gaps.







Seeing the OpenJDK (open-source Java) community and how vigorously 
Java gets developed further, continually updated in critical areas 
like security, there is no end in sight for this great ecosystem. 
Witnessing also OpenJDK distributions (from Java 8 LTS to the latest 
Java 18) from IBM, Amazon, SAP, even Microsoft, and many, many more 
competent and leading IT-related companies, the support for Java is 
unique compared to any other software there is. 


One of the reasons for the surge in C++ is because Java is flabby. 


Flabby? 😎
ROTFL


I stand by my comment. It doesn't mean I dislike Java. I like it a lot.




It's uses a huge amount of memory and GC is costly in visualized 
environments. 


That is just not true as many of the other statements. You seem to not 
really have followed the huge work and improvements over the decades 
and the state.


Yes it is. I work on z/OS performance monitoring products. One of our 
monitors is for the z/OS JVM. I see the metrics every day. The JVM 
starts about 8 threads. 2 for JIT, 3 for GC, 3 for OMR and some others I 
can't remember. It will do that even if you run a hello world program. 
Some of our products are written
in Java and we have to write documentation on how to tune the heap so GC 
cycles don't go crazy. Memory requirements for Java is eye watering 
compared to native code. The equivalent product written in C++ would use 
a fraction of the resources. One of the big plus point for Java on z/OS 
is that it runs on zIIP processors.


We use Spring Boot and are keeping an eye on Spring Boot Native which 
compiles to native code using GraalVM

FedEx to move entirely to the cloud

[David Crayford]

Bit of a shock this one. FedEx are closing all of their data centers and 
moving to Microsofts Azure Cloud. They are a massive mainframe customer 
and close friends of ours for a long time.
We had one of their guys on the floor in our office working with us on 
solutions. Times are changing...


https://www.theregister.com/2022/07/05/fedex_to_close_all_datacenters/

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

Re: Java (Re: Some questions on SYSCALL

[David Crayford]

On 7/07/2022 7:53 pm, Rony G. Flatscher wrote:
When I select a language for a job, one of the things that I look at 
is the ecosystem. I prefer ooRexx to Perl, but I find myself using
Perl for some tasks because CPAN is an awesome resource. Python may 
not be the best language for the task at hand, but it pays to check 
what packages are available.


Indeed Perl and Python have a great wealth of libraries available to 
them.


There is one ecosystem that beats Perl, Python and practically any 
others: Java


According to http://www.modulecounts.com/ which shows the number of 
unique packages


Node.js   2019534
Java       483102
Python  386118
Perl      18354

So the undisputed winner as far as ecosystem is JavaScript. And it's 
growing the fastest. I just downloaded vsam.js to process a VSAM data 
set in Node on z/OS and it works well. IBM are certainly giving

Node more love then REXX which will never officially support VSAM.

https://www.npmjs.com/package/vsam.js?S_TACT=


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

Re: Java (Re: Some questions on SYSCALL

[David Crayford]

On 7/07/2022 7:53 pm, Rony G. Flatscher wrote:

On 06.07.2022 11:03, Seymour J Metz wrote:
When I select a language for a job, one of the things that I look at 
is the ecosystem. I prefer ooRexx to Perl, but I find myself using
Perl for some tasks because CPAN is an awesome resource. Python may 
not be the best language for the task at hand, but it pays to check 
what packages are available.


Indeed Perl and Python have a great wealth of libraries available to 
them.


Perls moribund. It's fallen off a cliff since it's heyday. Same with 
Ruby. Poorly designed programming languages only last as long as there 
is nothing better to replace them.


https://trends.google.com/trends/explore?date=all&q=%2Fm%2F05zrn



There is one ecosystem that beats Perl, Python and practically any 
others: Java. For every problem domain, for new emerging technologies 
there are Java class libraries which one can take advantage of. As 
Java classes get compiled to intermediate byte code, these Java class 
libraries can be deployed and used immediately on any hardware and any 
operating system for which a Java virtual machine exists.


That's debatable! I'm a full time Java programmer in the last few years 
and I like. We use Spring Boot which is a high quality framework that 
makes it pleasant to use. I would use SB even for a slightly complex 
command line interface. However, the build systems are a bit spotty 
compared to Node.js, Python etc. Maven is creaking with it's ugly XML 
pom.xml and Gradle doesn't work very well on some systems. In 
particular, z/OS. C# is a far better language then Java. I don't use it 
because I because I'm not a Windows guy but I look on in envy. Kotlin 
meets 95% of the requirements but we dismissed it because it's not 
mainstream so we're stuck with Java.


I was surprised to notice when I followed Timothy's link to the TIOBE 
index that C++ is about to leapfrog Java. 
https://www.tiobe.com/tiobe-index/.  The article cites rapid standard 
rollouts and ground breaking new features such as co-routines. As a Lua 
fan I can't for C++ co-routines. On TIOBE Lua has raced back into the 
top 20 which is due to the surging popularity of gaming frameworks such 
as Roblox.


Since C++11 the language has evolved into a language that some experts 
have called Pythonic [1]. We're using the new z/OS Open XL C/C++ and 
it's a breath of fresh air. You need to be a good programmer to be 
proficient at C++ but IBM are delivering the goods on z/OS.


[1] https://preshing.com/20141202/cpp-has-become-more-pythonic/




The Java runtime environment (JRE) already comes with a wealth of 
professional and tested class libraries covering practically all 
aspects of modern programming, covering everything that any modern 
application may have a need to exploit and interact with.


Yes. But you need to use Open Source libraries for it to be easy to use. 
The JRE doesn't cut it.




Seeing the OpenJDK (open-source Java) community and how vigorously 
Java gets developed further, continually updated in critical areas 
like security, there is no end in sight for this great ecosystem. 
Witnessing also OpenJDK distributions (from Java 8 LTS to the latest 
Java 18) from IBM, Amazon, SAP, even Microsoft, and many, many more 
competent and leading IT-related companies, the support for Java is 
unique compared to any other software there is. 


One of the reasons for the surge in C++ is because Java is flabby. It's 
uses a huge amount of memory and GC is costly in visualized 
environments. GraalVM is a valiant attempt to solve that problem. 
Hopefully OpenJ9 will do something similar.


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

Re: Ad importance of the message paradigm (Re: Secure sockets (Re: Some questions on SYSCALL

[David Crayford]

IIRC Lisp was designed in 1956. That must have been ground breaking at the 
time. 

> On 3 Jul 2022, at 18:51, Rupert Reynolds  wrote:
> 
> The thing about Smalltalk (and a lot of other developments) is just how old
> they are. And we keep re-inventing some things. Smalltalk was remarkable in
> 1970-ish. Lambdas in Algol-68, but it wasn't the first I believe, and they
> can be tracked back further to maths in 1932.
> 
> Great insights in the 1968 NATO conference on "Software Engineering".
> 
> TDD can be traced back to awk and further bsck than that, I reckon.
> 
> I think a lot of Alan Kay's energy is frustration that everything takes so
> long!
> 
> Roops
> 
>> On Sun, 3 Jul 2022, 03:47 David Crayford,  wrote:
>> 
>> He wasn't too complementary about Java either. I never used Smalltalk
>> but I've seen examples in the GoF Design Patterns book. Guys I've spoken
>> to that used it extensively talk very fondly about it.
>> 
>>> On 3/07/2022 5:37 am, Rupert Reynolds wrote:
>>> I can't remember which of Alan Kay's talks it's in, but I have a few of
>> his
>>> saved and one or two have him saying "the big idea is messaging" and
>>> something like "whatever I had in mind, I can tell you now it wasn't C++"
>>> :-)
>>> 
>>> The late great Joe Armstrong (of Erlang fame) also quoted Alan Kay on
>> this
>>> at least once.
>>> 
>>> In my opinion, a lot of language development jumped on the OO bandwagon
>>> without thinking things through properly.
>>> 
>>> Roops
>>> 
>>>> On Sat, 2 Jul 2022, 21:06 Bob Bridges,  wrote:
>>> 
>>>> Rony, could you (or someone) say more about that?  The ooRexx
>>>> documentation has a lot to say about messaging, which is a bit
>> confusing to
>>>> me because I first got a handle on OOP in VBA and VBSCript, which do
>> not.
>>>> If the big idea is messaging, does VBA do that and I just didn't notice?
>>>> Or are the VB flavors something different that don't do messaging, or
>> not
>>>> very much?
>>>> 
>>>> ---
>>>> Bob Bridges, robhbrid...@gmail.com, cell 336 382-7313
>>>> 
>>>> /* It is in vain to say that democracy is less vain, less proud, less
>>>> selfish, less ambitious, or less avaricious than aristocracy or
>>>> monarchyWhen clear prospects are opened before vanity, pride,
>> avarice,
>>>> or ambition, for their easy gratification, it is hard for the most
>>>> considerate philosophers and the most conscientious moralists to resist
>> the
>>>> temptation. Individuals have conquered themselves. Nations and large
>> bodies
>>>> of men, never.  -from "The Letters of John and Abigail Adams" */
>>>> 
>>>> -Original Message-
>>>> From: IBM Mainframe Discussion List  On
>> Behalf
>>>> Of Rony G. Flatscher
>>>> Sent: Saturday, July 2, 2022 15:05
>>>> 
>>>> Alan Kay is regarded to have coined the term "object-oriented
>> programming
>>>> (OOP)" in the context of his work while at PARC. He is being cited on
>>>> Wikipedia:
>>>> 
>>>> 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".[8]
>>>> 
>>>> Cf. <https://en.wikipedia.org/wiki/Alan_Kay#cite_ref-8>.
>>>> 
>>>> --
>>>> 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
>> 
> 
> --
> 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: Ad importance of the message paradigm (Re: Secure sockets (Re: Some questions on SYSCALL

[David Crayford]

He wasn't too complementary about Java either. I never used Smalltalk 
but I've seen examples in the GoF Design Patterns book. Guys I've spoken 
to that used it extensively talk very fondly about it.


On 3/07/2022 5:37 am, Rupert Reynolds wrote:

I can't remember which of Alan Kay's talks it's in, but I have a few of his
saved and one or two have him saying "the big idea is messaging" and
something like "whatever I had in mind, I can tell you now it wasn't C++"
:-)

The late great Joe Armstrong (of Erlang fame) also quoted Alan Kay on this
at least once.

In my opinion, a lot of language development jumped on the OO bandwagon
without thinking things through properly.

Roops

On Sat, 2 Jul 2022, 21:06 Bob Bridges,  wrote:


Rony, could you (or someone) say more about that?  The ooRexx
documentation has a lot to say about messaging, which is a bit confusing to
me because I first got a handle on OOP in VBA and VBSCript, which do not.
If the big idea is messaging, does VBA do that and I just didn't notice?
Or are the VB flavors something different that don't do messaging, or not
very much?

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

/* It is in vain to say that democracy is less vain, less proud, less
selfish, less ambitious, or less avaricious than aristocracy or
monarchyWhen clear prospects are opened before vanity, pride, avarice,
or ambition, for their easy gratification, it is hard for the most
considerate philosophers and the most conscientious moralists to resist the
temptation. Individuals have conquered themselves. Nations and large bodies
of men, never.  -from "The Letters of John and Abigail Adams" */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf
Of Rony G. Flatscher
Sent: Saturday, July 2, 2022 15:05

Alan Kay is regarded to have coined the term "object-oriented programming
(OOP)" in the context of his work while at PARC. He is being cited on
Wikipedia:

 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".[8]

Cf. .

--
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: Java?

[David Crayford]

JZOS does. It flips a magic bit. 

> On 2 Jul 2022, at 10:52 am, Ed Jaffe  wrote:
> 
> On 7/1/2022 4:26 PM, David Crayford wrote:
>> The fact that the JNI code is offloaded to a zIIP is extra goodness.
> 
> Your JNI code runs on zIIP?
> 
> Ours does not seem to do so...
> 
> 
> -- 
> Phoenix Software International
> Edward E. Jaffe
> 831 Parkview Drive North
> El Segundo, CA 90245
> https://www.phoenixsoftware.com/
> 
> 
> 
> This e-mail message, including any attachments, appended messages and the
> information contained therein, is for the sole use of the intended
> recipient(s). If you are not an intended recipient or have otherwise
> received this email message in error, any use, dissemination, distribution,
> review, storage or copying of this e-mail message and the information
> contained therein is strictly prohibited. If you are not an intended
> recipient, please contact the sender by reply e-mail and destroy all copies
> of this email message and do not otherwise utilize or retain this email
> message or any or all of the information contained therein. Although this
> email message and any attachments or appended messages are believed to be
> free of any virus or other defect that might affect any computer system into
> which it is received and opened, it is the responsibility of the recipient
> to ensure that it is virus free and no responsibility is accepted by the
> sender for any loss or damage arising in any way from its opening or use.
> 
> --
> 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: Secure sockets (Re: Some questions on SYSCALL

[David Crayford]

Thanks Rony. I really enjoyed reading that paper.

Do you know why the tilde character was chosen as the message passing 
operator? It's quite unusual.


On 30/06/2022 6:55 pm, Rony G. Flatscher wrote:

On 30.06.2022 00:52, David Crayford wrote:

On 30/06/2022 6:37 am, Farley, Peter x23353 wrote:

Gentle listers,

Can we all agree to let this discussion be resolved by agreeing to 
the Perl mongers motto, TMTOWTD
TWTOWTD? Or maybe not. Show me how to create a secure socket in REXX 
without using PAGENT.


You may want to check out the slides in 
<https://wi.wu.ac.at/rgf/wu/lehre/slides/BusinessProgramming/230_AutoJava_Sockets_V03.pdf> 
for a simple solution with ooRexx.


---rony

P.S.: The above slides were used to teach non-programmers from the 
university's administration who were interested to learn/see the 
concepts of programming. They were able to come up with homework 
excercises exploiting secure sockets on their own.


--
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: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 2:58 pm, David Crayford wrote:
REXX is never the right language unless you have no choice, such as 
using an API such as SDSF or an environment such as Netview.


I'm going to take that back, which is unusual for me. I just realized 
that I have recently coded lots of REXX that uses the SDSF API. I create 
JSON which is processed in a pipe by Python code using the curses 
library so I get the goodness of SDSF without having to leave the shell. 
I also wrote a Redis command processor called RedisRexx. It's a good 
example of where REXX is a good choice and pleasant to use. Redis turbo 
charges REXX. You can use it for pub/sub models where you run pools of 
address spaces to process tasks or as a distributed data structure 
server. REXX doesn't have sorted sets, binary trees etc and Redis 
provides that and is lightening fast.





On 30/06/2022 11:21 am, Charles Mills wrote:

Charles knows C++ so I don't understand why he would pick REXX
One factor is that my deployment machine does not have a C++ compiler 
and does not share DASD with my development machine. So for C++ the 
cycle is


- Edit in IDE on Windows
- Build in IDE on Windows; get to clean compile
- Upload to development machine
- Build on z/OS (hopefully no z-specific errors; if so, iterate)
- Copy load module from development to deployment (complex load 
module FTP)

- Test
- Repeat as necessary

For Rexx OTOH the cycle is
- Edit in text editor in Windows
- Upload to deployment machine (simple ASCII text upload)
- Test
- Repeat as necessary


You need a better IDE. I recommend Intellij.


A much faster development cycle.

I built, tested and deployed the new HLASM module and the Rexx code 
in about 13 hours billable (including all the discussion here). I 
doubt that I could have done that with C++. There is more to "best 
language for the job" than elegance, conciseness, "modernness" and 
efficiency of execution.


For Python there is no way of knowing, but I think I might have spent 
that much time trying to get Python downloaded and installed. IBM 
manages to make the most simple tasks difficult. For one of the two 
machines I would have had a "business" or "legal" issue that might 
have taken 13 hours; certainly would have taken weeks elapsed. And 
that is before any "learning Python" issues. I am sure it is a 
wonderful language, but I think it is wishful thinking to say "see, 
you had some API issues with Rexx; therefore you would have been 
better off with Python." I suspect I might have had some API issues 
with my first Python program. 


Also, I get great Rexx community support right here on this forum. 
Where would I go for mainframe-specific Python community support? I'm 
sure there is some relevant forum, but how active is it? OT, but I 
have gotten pretty unhappy with Stack Overflow. Too many questions 
there now seem to draw a "not a perfect question" rebuke from some 
self-important moderator.


BTW, I do think I might want to learn Python. I bought an O'Reilly 
textbook. I have a six-hour flight coming up, and I think that it 
might be just perfect for learning Python.


Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] 
On Behalf Of David Crayford

Sent: Wednesday, June 29, 2022 3:27 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 30/06/2022 5:52 am, Bernd Oppolzer wrote:

The only reason why your Python code is shorter is because you use
the builtin os.walk method to walk through the directory recursively.

Isn't that the point? Python has an enormous standard library to do
useful things. Also note the use of iterators (or generators). In most
languages I use you can turn a subroutine inside out
that returns a value using "yield". The advantages of this model should
be obvious. If you wanted to grab the first 10 items from a list of
100,000 you don't need to build the entire list as you would with REXX.

Going back to Charles original requirement and why I piped up. Charles
knows C++ so I don't understand why he would pick REXX for a z/OS UNIX

--
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: Java?

[David Crayford]

JZOS is the perfect example of the genius of simplicity. I can remember 
the JRIO monstrosity with all the silly OO abstractions to do something 
as simple as file I/O. JZOS ZFile was a breath of fresh air. The fact 
that the JNI code is offloaded to a zIIP is extra goodness.


On 30/06/2022 10:55 pm, Kirk Wolf wrote:

"dubbing" basically means that a TCB gets assigned a z/OS UNIX pid.If you 
run z/OS Java under a batch address space (like with the JZOS batch launcher), then 
dubbing will occur since the JVM is written in C and uses z/OS Unix services.   Actually 
in this case it would be the JZOS batch launcher program that would be dubbed since it 
uses z/OS Unix services itself prior to invoking the JVM.

Kirk Wolf
Dovetailed Technologies, LLC
http://coztoolkit.com


Note: Our website and domain name have changed from dovetail.com to 
coztoolkit.com


On Thu, Jun 30, 2022, at 8:45 AM, Paul Gilmartin wrote:

On Thu, 30 Jun 2022 10:47:59 +, Seymour J Metz wrote:


I believe that Java in z/OS requires dubbing It's also available in Linux. Off 
the mainframe, it's also available for many PC and server systems.


Why is "requires dubbing" a thing?

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


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

Re: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 11:21 am, Charles Mills wrote:

Charles knows C++ so I don't understand why he would pick REXX

One factor is that my deployment machine does not have a C++ compiler and does 
not share DASD with my development machine. So for C++ the cycle is


Sound compelling, doesn't it? Unfortunately, you may trip up as soon as 
you require functionality that other languages provide that REXX is 
impoverished. How do I?


1. Sort an array
2. Use a data structure such as a binary tree, linked list etc
3. Access world class open source code
4. Process a VSAM data set
5. Write an external package with state
6. Functions as first class values?

I could go on and on. I'm in violent agreement with Rony. If you are 
must code REXX then use NetRexx which liberates you from mediocrity. 
Whenever somebody makes the argument to use REXX citing productivity I 
object because it's BS.






- Edit in IDE on Windows
- Build in IDE on Windows; get to clean compile
- Upload to development machine
- Build on z/OS (hopefully no z-specific errors; if so, iterate)
- Copy load module from development to deployment (complex load module FTP)
- Test
- Repeat as necessary

For Rexx OTOH the cycle is
- Edit in text editor in Windows
- Upload to deployment machine (simple ASCII text upload)
- Test
- Repeat as necessary

A much faster development cycle.

I built, tested and deployed the new HLASM module and the Rexx code in about 13 hours billable 
(including all the discussion here). I doubt that I could have done that with C++. There is more to 
"best language for the job" than elegance, conciseness, "modernness" and 
efficiency of execution.

For Python there is no way of knowing, but I think I might have spent that much time trying to get Python downloaded and 
installed. IBM manages to make the most simple tasks difficult. For one of the two machines I would have had a 
"business" or "legal" issue that might have taken 13 hours; certainly would have taken weeks elapsed. And 
that is before any "learning Python" issues. I am sure it is a wonderful language, but I think it is wishful 
thinking to say "see, you had some API issues with Rexx; therefore you would have been better off with Python." I 
suspect I might have had some API issues with my first Python program. 

Also, I get great Rexx community support right here on this forum. Where would I go for 
mainframe-specific Python community support? I'm sure there is some relevant forum, but 
how active is it? OT, but I have gotten pretty unhappy with Stack Overflow. Too many 
questions there now seem to draw a "not a perfect question" rebuke from some 
self-important moderator.

BTW, I do think I might want to learn Python. I bought an O'Reilly textbook. I 
have a six-hour flight coming up, and I think that it might be just perfect for 
learning Python.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Wednesday, June 29, 2022 3:27 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 30/06/2022 5:52 am, Bernd Oppolzer wrote:

The only reason why your Python code is shorter is because you use
the builtin os.walk method to walk through the directory recursively.

Isn't that the point? Python has an enormous standard library to do
useful things. Also note the use of iterators (or generators). In most
languages I use you can turn a subroutine inside out
that returns a value using "yield". The advantages of this model should
be obvious. If you wanted to grab the first 10 items from a list of
100,000 you don't need to build the entire list as you would with REXX.

Going back to Charles original requirement and why I piped up. Charles
knows C++ so I don't understand why he would pick REXX for a z/OS UNIX

--
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: Some questions on SYSCALL

[David Crayford]

You need to invest in a new IDE. You can get free stuff that support the 
mainframe over TCP here 
https://www.openmainframeproject.org/blog/2021/12/01/zowe-embraces-visual-studio-code-extensions. 



If you are prepared to spend money you have more options. This includes 
deployment to sync projedts to z/OS over FTP or SFTP.



On 30/06/2022 11:21 am, Charles Mills wrote:

Charles knows C++ so I don't understand why he would pick REXX

One factor is that my deployment machine does not have a C++ compiler and does 
not share DASD with my development machine. So for C++ the cycle is

- Edit in IDE on Windows
- Build in IDE on Windows; get to clean compile
- Upload to development machine
- Build on z/OS (hopefully no z-specific errors; if so, iterate)
- Copy load module from development to deployment (complex load module FTP)
- Test
- Repeat as necessary

For Rexx OTOH the cycle is
- Edit in text editor in Windows
- Upload to deployment machine (simple ASCII text upload)
- Test
- Repeat as necessary

A much faster development cycle.

I built, tested and deployed the new HLASM module and the Rexx code in about 13 hours billable 
(including all the discussion here). I doubt that I could have done that with C++. There is more to 
"best language for the job" than elegance, conciseness, "modernness" and 
efficiency of execution.

For Python there is no way of knowing, but I think I might have spent that much time trying to get Python downloaded and 
installed. IBM manages to make the most simple tasks difficult. For one of the two machines I would have had a 
"business" or "legal" issue that might have taken 13 hours; certainly would have taken weeks elapsed. And 
that is before any "learning Python" issues. I am sure it is a wonderful language, but I think it is wishful 
thinking to say "see, you had some API issues with Rexx; therefore you would have been better off with Python." I 
suspect I might have had some API issues with my first Python program. 

Also, I get great Rexx community support right here on this forum. Where would I go for 
mainframe-specific Python community support? I'm sure there is some relevant forum, but 
how active is it? OT, but I have gotten pretty unhappy with Stack Overflow. Too many 
questions there now seem to draw a "not a perfect question" rebuke from some 
self-important moderator.

BTW, I do think I might want to learn Python. I bought an O'Reilly textbook. I 
have a six-hour flight coming up, and I think that it might be just perfect for 
learning Python.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Wednesday, June 29, 2022 3:27 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 30/06/2022 5:52 am, Bernd Oppolzer wrote:

The only reason why your Python code is shorter is because you use
the builtin os.walk method to walk through the directory recursively.

Isn't that the point? Python has an enormous standard library to do
useful things. Also note the use of iterators (or generators). In most
languages I use you can turn a subroutine inside out
that returns a value using "yield". The advantages of this model should
be obvious. If you wanted to grab the first 10 items from a list of
100,000 you don't need to build the entire list as you would with REXX.

Going back to Charles original requirement and why I piped up. Charles
knows C++ so I don't understand why he would pick REXX for a z/OS UNIX

--
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: Some questions on SYSCALL

[David Crayford]

REXX is never the right language unless you have no choice, such as 
using an API such as SDSF or an environment such as Netview.


On 30/06/2022 11:21 am, Charles Mills wrote:

Charles knows C++ so I don't understand why he would pick REXX

One factor is that my deployment machine does not have a C++ compiler and does 
not share DASD with my development machine. So for C++ the cycle is

- Edit in IDE on Windows
- Build in IDE on Windows; get to clean compile
- Upload to development machine
- Build on z/OS (hopefully no z-specific errors; if so, iterate)
- Copy load module from development to deployment (complex load module FTP)
- Test
- Repeat as necessary

For Rexx OTOH the cycle is
- Edit in text editor in Windows
- Upload to deployment machine (simple ASCII text upload)
- Test
- Repeat as necessary


You need a better IDE. I recommend Intellij.


A much faster development cycle.

I built, tested and deployed the new HLASM module and the Rexx code in about 13 hours billable 
(including all the discussion here). I doubt that I could have done that with C++. There is more to 
"best language for the job" than elegance, conciseness, "modernness" and 
efficiency of execution.

For Python there is no way of knowing, but I think I might have spent that much time trying to get Python downloaded and 
installed. IBM manages to make the most simple tasks difficult. For one of the two machines I would have had a 
"business" or "legal" issue that might have taken 13 hours; certainly would have taken weeks elapsed. And 
that is before any "learning Python" issues. I am sure it is a wonderful language, but I think it is wishful 
thinking to say "see, you had some API issues with Rexx; therefore you would have been better off with Python." I 
suspect I might have had some API issues with my first Python program. 

Also, I get great Rexx community support right here on this forum. Where would I go for 
mainframe-specific Python community support? I'm sure there is some relevant forum, but 
how active is it? OT, but I have gotten pretty unhappy with Stack Overflow. Too many 
questions there now seem to draw a "not a perfect question" rebuke from some 
self-important moderator.

BTW, I do think I might want to learn Python. I bought an O'Reilly textbook. I 
have a six-hour flight coming up, and I think that it might be just perfect for 
learning Python.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Wednesday, June 29, 2022 3:27 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 30/06/2022 5:52 am, Bernd Oppolzer wrote:

The only reason why your Python code is shorter is because you use
the builtin os.walk method to walk through the directory recursively.

Isn't that the point? Python has an enormous standard library to do
useful things. Also note the use of iterators (or generators). In most
languages I use you can turn a subroutine inside out
that returns a value using "yield". The advantages of this model should
be obvious. If you wanted to grab the first 10 items from a list of
100,000 you don't need to build the entire list as you would with REXX.

Going back to Charles original requirement and why I piped up. Charles
knows C++ so I don't understand why he would pick REXX for a z/OS UNIX

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

[David Crayford]

On 30/06/2022 7:44 am, Bob Bridges wrote:

I've heard the word "awk", but never been exposed to it.  I had the impression, 
though, that I've heard of it in the context of Unix; am I mistaken?

Remember, the topic of the moment was whether there's any use for REXX 
~outside~ TSO.  This was on a Windows system; I'm guessing awk wouldn't be one 
of the available tools (even if I knew anything about it, I mean).


Gil says "I nominate ADDRESS SYSCALL and ADDRESS ISREDIT. What other 
languages are comparable?" where he conflates a language with a library.


What other languages are comparable? OMG, every language that supports 
regular expression or has a PEG library. Hammer and nail again (and again)!





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

/* Engineers will go without food and hygiene for days to solve a problem.  (Other times 
just because they forgot.)  -from "Are You an Engineer?" */

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
Paul Gilmartin
Sent: Wednesday, June 29, 2022 13:06

On Wed, 29 Jun 2022 12:00:12 -0400, Bob Bridges wrote:

... writing a REXX that read the raw firewall extract and created a CSV in 
about 20 seconds.  REXX makes ~very~ short work of parsing.  At the time I 
don’t think I knew VBScript, but it surely would have been harder.


For that sort of thing, I generally rely on "awk".  PARSE and regex have 
considerable overlap.



... Again, I see REXX's most valuable strength as parsing strings.  
Occasionally that strength is valuable outside TSO.


I nominate ADDRESS SYSCALL and ADDRESS ISREDIT.  What other languages are 
comparable?  OK.  The SYSCALL functions are mostly in C RTL, and ISREDIT 
commands callable from HLASM, C, COBOL, ... but harder.

Now that ISPF Edit has regex, it would be precious if it suupported 
back-references.

--
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: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 5:33 am, Paul Gilmartin wrote:

On Wed, 29 Jun 2022 22:22:39 +0200, Bernd Oppolzer wrote:

This is an old OS/2 REXX program (from the 1990s, IIRC),
used to traverse a directory tree recursively and issue a command in
every subdirectory found:

... with local variables protected by "procedure".


Protected? That's a good one! Another reason to hate on REXX is the lack 
of lexical scoping. It's ok for small programs but as soon as you start 
to scale
it's a nightmare when you"i" loop counter gets clobbered in a 
subroutine. "procedure" helps but then you have to use "expose" which 
normally results in
using a compound global variable such as g._namespace. REXX is a 
language that you program into.


You have choices on z/OS now kids!

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

Re: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 6:37 am, Farley, Peter x23353 wrote:

Gentle listers,

Can we all agree to let this discussion be resolved by agreeing to the Perl 
mongers motto, TMTOWTD
TWTOWTD? Or maybe not. Show me how to create a secure socket in REXX 
without using PAGENT.





I think the discussion you have had so far is more than sufficient.  I would 
also suggest that you take it offline if you would prefer to continue along 
these lines.

I will say in defense of parts of this discussion that I learned a few things 
about Rexx on z/OS that I previously had not encountered and which will give me 
assistance in future activities, so thank you to the contributing posters for 
those nuggets of knowledge.

Peter
--

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: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 5:52 am, Bernd Oppolzer wrote:

The only reason why your Python code is shorter is because you use
the builtin os.walk method to walk through the directory recursively.


Isn't that the point? Python has an enormous standard library to do 
useful things. Also note the use of iterators (or generators). In most 
languages I use you can turn a subroutine inside out
that returns a value using "yield". The advantages of this model should 
be obvious. If you wanted to grab the first 10 items from a list of 
100,000 you don't need to build the entire list as you would with REXX.


Going back to Charles original requirement and why I piped up. Charles 
knows C++ so I don't understand why he would pick REXX for a z/OS UNIX 
solution. It's the worst language for the job and I stand by
that assertion in that he is already asking questions on here about the 
API.


Python is a first class language on z/OS now. You can't write an ISPF 
macro in Python but you can write Instagram, which uses the Django 
framework. No contest!




A similar method could have been used in my REXX example, too,
but I wanted a command to be issued in every subdirectory
when walking through the tree,
so I had to do the recursive directory walk myself, using the 
recursive call

to the tree procedure. This is what makes my coding longer,
but this is not due to the REXX language. Be fair.

To call this verbose is simply wrong, and you are missing the point 
completely;
please show me how your Python solution looks, if you also walk the 
directory tree
by yourself and issue a command given as a parameter at every 
subdirectory

and not only print the name.

but I don't really want to argue on this ... this seems like a waste 
ot time.


I use the tools I have at hand ... and I didn't have Python in 1998 on 
my OS/2 boxes.
This has nothing to do with personal favor; I use the tools which make 
the most
sense for me, given my knowledge or my personal skills (which can of 
course

change or improve over time).

Earlier in a similar thread I told you or other posters how easy it is 
to append

small pieces of information every 15 minutes to a file using IBM's C
and still having a large blocksize etc. ... and how I would support
the simultaneous update and the reporting. The thread degraded into a
discussion about started tasks and how to implement the operator commands
to control the STCs using REXX or other languages ... again: what a 
waste of time.
For appending information to a file every 15 minutes, I would create a 
batch job
which is started every 15 minutes, controlled by UC4 or cron or 
whatever you have
... and which terminates after some milliseconds. No need for a 
started task,

which is idle most of the time.

I miss sometimes a certain cost sensitivity with the discussions here 
in IBM-MAIN,

but this should be part of our profession.

Kind regards

Bernd



Am 29.06.2022 um 23:24 schrieb David Crayford:

On 30/06/2022 4:22 am, Bernd Oppolzer wrote:



This is an old OS/2 REXX program (from the 1990s, IIRC),
used to traverse a directory tree recursively and issue a command in 
every subdirectory found:



/* rexx */

arg command

call RxFuncAdd "SysLoadFuncs", "REXXUTIL", "SysLoadFuncs"
call SysLoadFuncs

dir = directory()
if right(dir,1) = "\" then
   dir = left(dir, length(dir) - 1)

call tree dir, command

x = directory(dir)

exit


tree: procedure

   arg dir, command

   say "*** Verzeichnis in Bearbeitung: "dir" ***"

   x = directory(dir)

   command

   rc = SysFileTree("*.*", verz, "D")
   do i = 1 to verz.0
  dir = word(verz.i, 5)
  call tree dir, command
   end

   return


you may notice the recursive call of the procedure "tree".

I don't see any justification for your REXX bashing;
it's just another flavor of scripting language, which allows to do 
great things,

once you manage to use it.


Sorry Brend, but I don't consider that snippet to be great! It's a 
perfect example of flabby, verbose REXX code. The only justification 
for using REXX is that you personally favor the language. Python is 
far more succinct.


|for| |root, dirs, files ||in| |os.walk(path_of_the_directory):|
|||for| |i ||in| |files:|
|||print||(os.path.join(root, i))|


--
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: Some questions on SYSCALL

[David Crayford]

On 30/06/2022 4:22 am, Bernd Oppolzer wrote:



This is an old OS/2 REXX program (from the 1990s, IIRC),
used to traverse a directory tree recursively and issue a command in 
every subdirectory found:



/* rexx */

arg command

call RxFuncAdd "SysLoadFuncs", "REXXUTIL", "SysLoadFuncs"
call SysLoadFuncs

dir = directory()
if right(dir,1) = "\" then
   dir = left(dir, length(dir) - 1)

call tree dir, command

x = directory(dir)

exit


tree: procedure

   arg dir, command

   say "*** Verzeichnis in Bearbeitung: "dir" ***"

   x = directory(dir)

   command

   rc = SysFileTree("*.*", verz, "D")
   do i = 1 to verz.0
  dir = word(verz.i, 5)
  call tree dir, command
   end

   return


you may notice the recursive call of the procedure "tree".

I don't see any justification for your REXX bashing;
it's just another flavor of scripting language, which allows to do 
great things,

once you manage to use it.


Sorry Brend, but I don't consider that snippet to be great! It's a 
perfect example of flabby, verbose REXX code. The only justification for 
using REXX is that you personally favor the language. Python is far more 
succinct.


|for| |root, dirs, files ||in| |os.walk(path_of_the_directory):|
|||for| |i ||in| |files:|
|||print||(os.path.join(root, i))|


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

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 11:07 pm, Rony G. Flatscher wrote:

Hi David,

On 29.06.2022 15:54, David Crayford wrote:
I know ooRexx. I ported it to z/OS 10 years ago but it was buggy and 
slow. 


Hmm, ten years ago? Over time there has been so much improvements in 
these and other areas including a testing framework with quite a 
comprehensive coverage of the ooRexx interpreter.


There is zero chance of IBM or a vendor wasting resources on REXX 
today as there is no market for it. 


Hmm, so you speak for IBM? The REXX infrastructure, the REXX experts, 
the ability to learn REXX (and ooRexx for that matter) in a short 
time, becoming empowered to solve mainframe based problems quickly and 
the like does not constitute a USP (uinque selling proposition on the 
market)?


I don't speak for IBM but we provide the SciPy libraries for the IBM 
AI/ML products.






Now we have Python on z/OS REXX is very much a legacy language. 
That's even more pertinent with the shift from TSO/ISPF to IDEs.


Hmm, so Python is the end of the world as it solves everything? No 
other language stands a chance anymore?


Python isn't my favorite language I just can't see any use for REXX 
outside of TSO/ISPF.





I could be wrong and I'm willing to be turned. I'm a big fan of Lua 
which I consider to be the most elegant language I know. 


Sure, Lua - like many other languages following different paradigms - 
is an interesting language, but it could not be used to teach Business 
administration students programming from scratch within four months to 
the extent that in the end they would be able to program Windows, MSO, 
create complex, portable GUIs etc. on their own. It can be done with 
ooRexx (and the BSF4ooRexx function library bridging ooRexx and Java), 
believe it or not. As a result it is cheaper to learn ooRexx, and the 
problem solving capacity one gains with it quickly is really quite 
unparalleled.


Having REXX/ooRexx one is able to easily orchestrate and control other 
software. If need be one can bridge REXX/ooRexx easily with 
specialized software like database management systems (who would write 
one in REXX or Python for that matter) and the like.


In today's world I would deploy Java everywhere and exploit Java class 
libraries as much as possible from other languages, if need be. For 
the latter to be feasible you need a flexible, dynamical and easy to 
use language which is proven, which can be said of ooRexx with the 
ooRexx-Java bridge.



It can easily be used to write DSLs for configuration or model 
development. How do I write a DSL in REXX?


Why would I want to? Why not: "How do I write a DSL in C++?"



https://leafo.net/guides/dsl-in-lua.html


REXX is such an easy programming language that one does not need to 
create yet another language to make it usable. ;)


If really needed one could create DSLs with ooRexx  as with any other 
programming language, of course.
Really? Lua supports closures which is why it can be used for DSLs. REXX 
does not. You would need to write a parser.


---rony




On 29/06/2022 9:41 pm, Rony G. Flatscher wrote:

Hi David,

On 29.06.2022 14:06, David Crayford wrote:

On 29/06/2022 6:37 pm, Seymour J Metz wrote:
Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on 
avoiding REXX pitfalls.


What's the point in managing something when you can just use a 
better language? It's a good time to be working on z/OS as we have 
an abundance of choice. That's not entirely obvious on this forum 
where every problem seems to be met with a ham-fisted REXX solution.


Yes, Crayford's bashing REXX again. I have some experience of using 
z/OS UNIX REXX services but I didn't find it productive. Maybe 
somebody with more knowledge than me could post a snippet that 
demonstrates how to recursively traverse a directory tree printing 
the entries.


The problem is that this is not constructive. Not sure why it is so 
important for you to bash REXX even if it makes you look bad at times.


REXX in the mainframe world (I learned REXX for the first time on a 
VM/CMS 370 system a few decades ago) is of course a great - and 
unmatched - productivity tool and as a result over the decades there 
has been an incredible amount of useful REXX inventory created.  
Best, REXX is easy to learn and easy to use like no other language 
of that power.


If you were to know ooRexx you would realize that porting it to the 
mainframe would even help yourself and everyone else to settle on a 
few important languages and not being forced to go astray with this 
language for solving this particular problem, that language for 
solving that particular problem, and then suggesting to use yet 
another language for ...


Porting ooRexx to the mainframe would allow for keeping the existing 
REXX programs running with ooRexx (th

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 10:48 pm, Seymour J Metz wrote:

Have you stopped beating your wife? There is no agreement of what is a better language, 
much less a description of the context in which to evaluate "better".
You really are a huge twat. Why don't you just bugger off. You won't be 
missed.



From: IBM Mainframe Discussion List  on behalf of David 
Crayford 
Sent: Wednesday, June 29, 2022 8:06 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 6:37 pm, Seymour J Metz wrote:

Sme, but manageable. The article Safe REXX at 
<http://secure-web.cisco.com/18tXxLjz2q-nDjE3Fk3aQsvRJpFcP22D9GKeoWSbitPmfcGAttYHjb-kP18U8Ikl-aTGx-pwraxaebV32MLF29JU1T5PHRSawvmtcOGrlNGx7qinsWE4REjw9lBM0v-qPHaExEKTjFI5whqyzgNqyyP8lJXknHgVjB9cG81on4LMjV-ujVAqpW3I-PSQoBgSx1-68Dt9t0tiiiZC2mDbYmhMIfA34222KIpNnr3jIWqO2GmhJvocQ6YsZ4LFzMypLVDsEzR1jq2yHlrf-j3yNYMBOBBgbawlGvlwTlhcDmyj5VUWQPczUZkWLHAwKtz8DidQWTRQb3gMsJzKiE-WSx1GWdm6Q0IiDjs2_Omg4xTOuCBtUymaNKzQUCYdHr65JzHggOCeIsQlhDwHMCl30Fku0q_ApFl2GTV8nFoXiCad0H0PKU9S6UZqHhGLy0ZqE/http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9812safe.html>
 and 
<http://secure-web.cisco.com/1YOkF0HmSXzgkUjFJmn8yFhg2L09HrpgS0qAPaRvAUGL9PH3DMRW9K45clWzrW3ewTanQwrdKON0NcKzVyqjLzs0d5niuN5Wj3Wz8MHU971Gj4znrgmAATcjrWFQuA1kJt6A09GQttX8NMkRBn485myf2jYTkMEdH4Wi8xuhHqRIh3-zivudzlZAe3urnn9HJS_dAirVPwjrWMdNZKY23K2d0i77HzCdFFa2Bomro21ICQV5LodBCmW7FVOYvTEK9Mt6MKlkVZxG9bwOvl_233vbJ1fMWIxmy9wqXSdyBfeiAbPJI3BDNK-pVkTQXi1u435aytEI2WvKF5emDChP3q5DKBhScFJ5oDZeN8lMrLcbd4hAcHY!

  
nrtSS_rhn5jeu2S3924pgQlUz_wRvRDI4Yo6x5c15qLVoxg18D_XjKAA_W9IwcaxWHhc_lIcXL81Pt/http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9901safe.html">
 has some tips on avoiding REXX pitfalls.

What's the point in managing something when you can just use a better
language? It's a good time to be working on z/OS as we have an abundance
of choice. That's not entirely obvious on this forum where every problem
seems to be met with a ham-fisted REXX solution.

Yes, Crayford's bashing REXX again. I have some experience of using z/OS
UNIX REXX services but I didn't find it productive. Maybe somebody with
more knowledge than me could post a snippet that demonstrates how to
recursively traverse a directory tree printing the entries.




--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Tuesday, June 28, 2022 11:31 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?

It's horribly inconsistent and unpleasant to use. The buffer HAS to be a
passed by reference (variable) as it could break REXX string length
limits or contain characters that REXX chokes on.
I can't help but think that you've made a rod for your back. REXX is
superficially simple but in my experience, which is 30 years of using
the language, it is anything but and has endless pitfalls.

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


--
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: Some questions on SYSCALL

[David Crayford]

Hi Rony,

I know ooRexx. I ported it to z/OS 10 years ago but it was buggy and 
slow. There is zero chance of IBM or a vendor wasting resources on REXX 
today as there is no market for it. Now we have Python on z/OS REXX is 
very much a legacy language. That's even more pertinent with the shift 
from TSO/ISPF to IDEs.


I could be wrong and I'm willing to be turned. I'm a big fan of Lua 
which I consider to be the most elegant language I know. It can easily 
be used to write DSLs for configuration or model development. How do I 
write a DSL in REXX?


https://leafo.net/guides/dsl-in-lua.html

On 29/06/2022 9:41 pm, Rony G. Flatscher wrote:

Hi David,

On 29.06.2022 14:06, David Crayford wrote:

On 29/06/2022 6:37 pm, Seymour J Metz wrote:
Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on 
avoiding REXX pitfalls.


What's the point in managing something when you can just use a better 
language? It's a good time to be working on z/OS as we have an 
abundance of choice. That's not entirely obvious on this forum where 
every problem seems to be met with a ham-fisted REXX solution.


Yes, Crayford's bashing REXX again. I have some experience of using 
z/OS UNIX REXX services but I didn't find it productive. Maybe 
somebody with more knowledge than me could post a snippet that 
demonstrates how to recursively traverse a directory tree printing 
the entries.


The problem is that this is not constructive. Not sure why it is so 
important for you to bash REXX even if it makes you look bad at times.


REXX in the mainframe world (I learned REXX for the first time on a 
VM/CMS 370 system a few decades ago) is of course a great - and 
unmatched - productivity tool and as a result over the decades there 
has been an incredible amount of useful REXX inventory created.  Best, 
REXX is easy to learn and easy to use like no other language of that 
power.


If you were to know ooRexx you would realize that porting it to the 
mainframe would even help yourself and everyone else to settle on a 
few important languages and not being forced to go astray with this 
language for solving this particular problem, that language for 
solving that particular problem, and then suggesting to use yet 
another language for ...


Porting ooRexx to the mainframe would allow for keeping the existing 
REXX programs running with ooRexx (the design of ooRexx - by demand of 
IBM's customers - is such that it is compatible with classic REXX). 
Therefore one can use ooRexx to run existing REXX programs and one 
could use ooRexx to create new classic REXX programs.


Only then would one become able to take advantage of the many new 
ooRexx features like becoming able to fetch e.g. stems by reference,  
or using ANSI REXX' "address...with" (e.g. redirecting input from 
stems or standard and error output to stems), being able to create 
public Rexx routines (can be directly called from another REXX 
program) and much more.


Doing so would be sensible as it allows for exploiting the already 
known programming language, its environment and existing REXX 
infrastructure; one would gain new abilities and options from then on.


Also the important property - being able to learn and understand the 
language quickly - remains intact with ooRexx, it just increases the 
problem solution capacity dramatically by embracing the 
object-oriented paradigm the way it does.


If Business administration students are able to learn ooRexx from 
scratch in just four months such that in the end they have become able 
to create programs for Windows and Microsoft Office (after only two 
months) and portable (running unchanged on Windows, Linux and MacOS) 
applications including OpenOffice/LibreOffice and even JavaFX (!) GUIs 
(after another two months, exploiting all of Java which gets 
camouflaged as the dynamically typed, caseless ooRexx, without having 
to learn a single line of Java; one only needs to be able to read and 
understand the JavaDocs).


So it is feasible and not expensive at all to teach newcomers to 
program in ooRexx. Putting ooRexx into the hands of REXXperts like the 
ones that can be found here, would be a real and important boon ...


As IBM has been successfully porting quite a few programming languages 
to the mainframe, it should be feasible to port ooRexx as well as 
ooRexx is purely implemented in C++ (it has in addition a very nice 
and powerful native API to the interpreter) making a modern and 
powerful incarnation of REXX available on the mainframe where REXX was 
born ...


---rony

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

Re: ... SYSCALL ... And Thanks!

[David Crayford]

On 29/06/2022 9:09 pm, Paul Gilmartin wrote:

On Jun 29, 2022, at 06:48:14, Bill Schoen wrote

  ...
re: write buffer is a variable name
This was done for a variety of reasons, but primarily, rexx has a limit to 
number of parameters that can be passed to an address environment.
I think TSO rexx limits it to 20.  If it took a string you would be limited to 
very few blank delimited words.
a number of syscall commands take variable/stem names to avoid issues with 
input or output rexx restrictions.
.

I thoughht it was exactly one: a command string.


Probably my last post before retirement tomorrow.
Bill Schoen


Thanks Bill, you're guidance has been much appreciated.

I wish the other retirees on this forum would follow your lead.

  

You have been enormously helpful.  Thank you!



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

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 9:20 pm, Paul Gilmartin wrote:

On Jun 29, 2022, at 07:02:39, David Crayford wrote:

 ...
That doesn't eliminate confusion at all. If you have a large loop and you don't 
understand your code then your code is crap. Any decent code editor will match 
blocks on key-press. ISPF doesn't meet that criteria!
   

The singular is "criterion".

Who cares? Nobody likes a nitpicker!

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

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 8:48 pm, Paul Gilmartin wrote:

On Jun 29, 2022, at 06:37:39, Lionel B. Dyck  wrote:

Some align the end with the do, others align the end with the code in the do 
structure.  The key is a consistent style for readability.

The REXXFORM results of my example are:

/* rexx */
x = bpxwunix('find /u/user/work/',,out.,err.)
do I = 1 to out.0
  say out.i
end


For any large loop, I cite the control variable on the "end" to eliminate 
confusion:
x = bpxwunix('find /u/user/work/',,out.,err.)
do I = 1 to out.0
  say out.i
  end I
That doesn't eliminate confusion at all. If you have a large loop and 
you don't understand your code then your code is crap. Any decent code 
editor will match blocks on key-press. ISPF doesn't meet that criteria!


At times I use an otherwise otiose control variable:
do ThisLoop = 1 until1
...
end ThisLoop

(I wish JCL would require that the name fields on IF, ELSE, and THEN match.)



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

Re: Some questions on SYSCALL

[David Crayford]

Thanks David, I learned something there that I didn't know.

Cheers

On 29/06/2022 8:50 pm, David Spiegel wrote:

Hi David,
The paragraphing style was used historically by PL/I.
Rexx syntactically is a PL/I derivative,

Regards,
David

On 2022-06-29 08:32, David Crayford wrote:

On 29/06/2022 8:27 pm, Lionel B. Dyck wrote:
The formatting was a quick and dirty - I typically use the REXXFORM 
edit macro to clean up alignments and keep things neat.


I'm not knocking your code Lionel. It's more the case that I don't 
like what has become common formatting of REXX code blocks where the 
end is indented at the end of the block. Is this REXX pretending to 
be Python by obscuring the "end"?


if/do/ ...
   ...
  end





You can find it at 
https://nam12.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Flbdyck%2Frexxform&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=cI7TAAxlEwrGdv0%2Fe1UpsovUWwTUmwz4t8Bu23vlU%2Bs%3D&reserved=0 
- I ported it from z/VM to work as an edit macro.


Yes - you could use SYSCALLS and get the same info but this was a 
quick and easy answer


Enjoy

Lionel B. Dyck <><
Website: 
https://nam12.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.lbdsoftware.com%2F&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=Gelj38NYPjDxFTVCMUlrezI6EsHtG%2FeSqi12EH5K%2BMw%3D&reserved=0
Github: 
https://nam12.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Flbdyck&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=onLvqMQf4nDO2IFcEuP7zNjXtuR9YkytAMwgam1NDdI%3D&reserved=0


“Worry more about your character than your reputation. Character is 
what you are, reputation merely what others think you are.” - - - 
John Wooden


-----Original Message-
From: IBM Mainframe Discussion List  On 
Behalf Of David Crayford

Sent: Wednesday, June 29, 2022 07:19 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

Thanks Lionel. If I want to get the directory entry I suppose I have 
to also execute bpxwunix("ls ") or use SYSCALLS?


BTW, I really wish the "end" scope terminater would match the "do"
column alignment. It's just another reason for me to hate on REXX 
when it's become common practice to uses bizarre formatting rules.


On 29/06/2022 8:12 pm, Lionel B. Dyck wrote:
Perhaps something like this will give you what you want to 
recursively traverse a directory:


x = bpxwunix('find /u/user/work/',,out.,err.) do I = 1 to out.0
 say out.i
 end


Lionel B. Dyck <><
Website: 
https://nam12.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.lbdsoftware.com%2F&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=Gelj38NYPjDxFTVCMUlrezI6EsHtG%2FeSqi12EH5K%2BMw%3D&reserved=0
Github: 
https://nam12.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Flbdyck&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=onLvqMQf4nDO2IFcEuP7zNjXtuR9YkytAMwgam1NDdI%3D&reserved=0


“Worry more about your character than your reputation. Character is 
what you are, reputation merely what others think you are.”   - - - 
John Wooden


-Original Message-
From: IBM Mainframe Discussion List  On 
Behalf Of David Crayford

Sent: Wednesday, June 29, 2022 07:07 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 6:37 pm, Seymour J Metz wrote:
Sme, but manageable. The article Safe REXX at 
<https://nam12.safelinks.protection.outlook.com/?url=http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9812safe.html&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59cb755a%7C84df9e7fe9f640afb435%7C1%7C0%7C637921027658728053%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=0WyZp%2BqUZZa1cXYzA8gaMa881zHH96lf2UbUhonNCuM%3D&reserved=0> 
and 
<https://nam12.safelinks.protection.outlook.com/?url=http%3A%2F%2Fwww.rexxla.org%2FNewsletter%2F9901safe.html&data=05%7C01%7C%7C5089dfbaebb94b75f35608da59

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 8:37 pm, Lionel B. Dyck wrote:

Some align the end with the do, others align the end with the code in the do 
structure.  The key is a consistent style for readability.

The REXXFORM results of my example are:

/* rexx */
  x = bpxwunix('find /u/user/work/',,out.,err.)
  do I = 1 to out.0
say out.i
  end


Your example returns the file path and you still need to parse the 
results and call additional code to get directory entry information. 
It's much easier to just use C++ which is at the same level of 
abstraction and orders of magnitude more powerful.


    for (auto& dirEntry: 
std::filesystem::recursive_directory_iterator(path)) {

    if (!dirEntry.is_regular_file()) {
    std::cout << "Directory: " << dirEntry.path() << std::endl;
    continue;
    }
    std::filesystem::path file = dirEntry.path();
    std::cout << "Filename: " << file.filename() << " extension: " 
<< file.extension() << std::endl;

    }




Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
David Crayford
Sent: Wednesday, June 29, 2022 07:32 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 8:27 pm, Lionel B. Dyck wrote:

The formatting was a quick and dirty - I typically use the REXXFORM edit macro 
to clean up alignments and keep things neat.

I'm not knocking your code Lionel. It's more the case that I don't like what has become 
common formatting of REXX code blocks where the end is indented at the end of the block. 
Is this REXX pretending to be Python by obscuring the "end"?

if/do/ ...
 ...
end




You can find it at https://github.com/lbdyck/rexxform - I ported it from z/VM 
to work as an edit macro.

Yes - you could use SYSCALLS and get the same info but this was a
quick and easy answer

Enjoy

Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-
From: IBM Mainframe Discussion List  On
Behalf Of David Crayford
Sent: Wednesday, June 29, 2022 07:19 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

Thanks Lionel. If I want to get the directory entry I suppose I have to also execute 
bpxwunix("ls ") or use SYSCALLS?

BTW, I really wish the "end" scope terminater would match the "do"
column alignment. It's just another reason for me to hate on REXX when it's 
become common practice to uses bizarre formatting rules.

On 29/06/2022 8:12 pm, Lionel B. Dyck wrote:

Perhaps something like this will give you what you want to recursively traverse 
a directory:

x = bpxwunix('find /u/user/work/',,out.,err.) do I = 1 to out.0
  say out.i
  end


Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-
From: IBM Mainframe Discussion List  On
Behalf Of David Crayford
Sent: Wednesday, June 29, 2022 07:07 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 6:37 pm, Seymour J Metz wrote:

Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on avoiding REXX 
pitfalls.

What's the point in managing something when you can just use a better language? 
It's a good time to be working on z/OS as we have an abundance of choice. 
That's not entirely obvious on this forum where every problem seems to be met 
with a ham-fisted REXX solution.

Yes, Crayford's bashing REXX again. I have some experience of using z/OS UNIX 
REXX services but I didn't find it productive. Maybe somebody with more 
knowledge than me could post a snippet that demonstrates how to recursively 
traverse a directory tree printing the entries.




--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on
behalf of David Crayford [dcrayf...@gmail.com]
Sent: Tuesday, June 28, 2022 11:31 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by v

Re: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 8:27 pm, Lionel B. Dyck wrote:

The formatting was a quick and dirty - I typically use the REXXFORM edit macro 
to clean up alignments and keep things neat.


I'm not knocking your code Lionel. It's more the case that I don't like 
what has become common formatting of REXX code blocks where the end is 
indented at the end of the block. Is this REXX pretending to be Python 
by obscuring the "end"?


if/do/ ...
   ...
  end





You can find it at https://github.com/lbdyck/rexxform - I ported it from z/VM 
to work as an edit macro.

Yes - you could use SYSCALLS and get the same info but this was a quick and 
easy answer

Enjoy

Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
David Crayford
Sent: Wednesday, June 29, 2022 07:19 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

Thanks Lionel. If I want to get the directory entry I suppose I have to also execute 
bpxwunix("ls ") or use SYSCALLS?

BTW, I really wish the "end" scope terminater would match the "do"
column alignment. It's just another reason for me to hate on REXX when it's 
become common practice to uses bizarre formatting rules.

On 29/06/2022 8:12 pm, Lionel B. Dyck wrote:

Perhaps something like this will give you what you want to recursively traverse 
a directory:

x = bpxwunix('find /u/user/work/',,out.,err.) do I = 1 to out.0
 say out.i
 end


Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-
From: IBM Mainframe Discussion List  On Behalf Of 
David Crayford
Sent: Wednesday, June 29, 2022 07:07 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 6:37 pm, Seymour J Metz wrote:

Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on avoiding REXX 
pitfalls.

What's the point in managing something when you can just use a better language? 
It's a good time to be working on z/OS as we have an abundance of choice. 
That's not entirely obvious on this forum where every problem seems to be met 
with a ham-fisted REXX solution.

Yes, Crayford's bashing REXX again. I have some experience of using z/OS UNIX 
REXX services but I didn't find it productive. Maybe somebody with more 
knowledge than me could post a snippet that demonstrates how to recursively 
traverse a directory tree printing the entries.




--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on
behalf of David Crayford [dcrayf...@gmail.com]
Sent: Tuesday, June 28, 2022 11:31 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?

It's horribly inconsistent and unpleasant to use. The buffer HAS to be
a passed by reference (variable) as it could break REXX string length
limits or contain characters that REXX chokes on.
I can't help but think that you've made a rod for your back. REXX is
superficially simple but in my experience, which is 30 years of using
the language, it is anything but and has endless pitfalls.

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

--
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: Some questions on SYSCALL

[David Crayford]

Thanks Lionel. If I want to get the directory entry I suppose I have to 
also execute bpxwunix("ls ") or use SYSCALLS?


BTW, I really wish the "end" scope terminater would match the "do" 
column alignment. It's just another reason for me to hate on REXX when 
it's become common practice to uses bizarre formatting rules.


On 29/06/2022 8:12 pm, Lionel B. Dyck wrote:

Perhaps something like this will give you what you want to recursively traverse 
a directory:

x = bpxwunix('find /u/user/work/',,out.,err.)
do I = 1 to out.0
say out.i
end


Lionel B. Dyck <><
Website: https://www.lbdsoftware.com
Github: https://github.com/lbdyck

“Worry more about your character than your reputation. Character is what you 
are, reputation merely what others think you are.”   - - - John Wooden

-Original Message-----
From: IBM Mainframe Discussion List  On Behalf Of 
David Crayford
Sent: Wednesday, June 29, 2022 07:07 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 6:37 pm, Seymour J Metz wrote:

Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on avoiding REXX 
pitfalls.

What's the point in managing something when you can just use a better language? 
It's a good time to be working on z/OS as we have an abundance of choice. 
That's not entirely obvious on this forum where every problem seems to be met 
with a ham-fisted REXX solution.

Yes, Crayford's bashing REXX again. I have some experience of using z/OS UNIX 
REXX services but I didn't find it productive. Maybe somebody with more 
knowledge than me could post a snippet that demonstrates how to recursively 
traverse a directory tree printing the entries.




--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3

____
From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on
behalf of David Crayford [dcrayf...@gmail.com]
Sent: Tuesday, June 28, 2022 11:31 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?

It's horribly inconsistent and unpleasant to use. The buffer HAS to be
a passed by reference (variable) as it could break REXX string length
limits or contain characters that REXX chokes on.
I can't help but think that you've made a rod for your back. REXX is
superficially simple but in my experience, which is 30 years of using
the language, it is anything but and has endless pitfalls.

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

--
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: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 6:37 pm, Seymour J Metz wrote:

Sme, but manageable. The article Safe REXX at 
<http://www.rexxla.org/Newsletter/9812safe.html> and 
<http://www.rexxla.org/Newsletter/9901safe.html";> has some tips on avoiding REXX 
pitfalls.


What's the point in managing something when you can just use a better 
language? It's a good time to be working on z/OS as we have an abundance 
of choice. That's not entirely obvious on this forum where every problem 
seems to be met with a ham-fisted REXX solution.


Yes, Crayford's bashing REXX again. I have some experience of using z/OS 
UNIX REXX services but I didn't find it productive. Maybe somebody with 
more knowledge than me could post a snippet that demonstrates how to 
recursively traverse a directory tree printing the entries.






--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Tuesday, June 28, 2022 11:31 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?

It's horribly inconsistent and unpleasant to use. The buffer HAS to be a
passed by reference (variable) as it could break REXX string length
limits or contain characters that REXX chokes on.
I can't help but think that you've made a rod for your back. REXX is
superficially simple but in my experience, which is 30 years of using
the language, it is anything but and has endless pitfalls.

--
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: Some questions on SYSCALL

[David Crayford]

On 29/06/2022 5:42 am, Charles Mills wrote:

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?


It's horribly inconsistent and unpleasant to use. The buffer HAS to be a 
passed by reference (variable) as it could break REXX string length 
limits or contain characters that REXX chokes on.
I can't help but think that you've made a rod for your back. REXX is 
superficially simple but in my experience, which is 30 years of using 
the language, it is anything but and has endless pitfalls.


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

Re: is there any documentation on using the new 64 bit instructions?

[David Crayford]

Fixed the typo!

__asm__(
  " LLGT 15,%[ep]\n"
  " LR 1,%[PARMS]\n"
  " LR 13,%[savearea]\n"
  " SAM31\n"
  " BALR 14,15\n"
  " SAM64\n"
  " ST 15,%[rc]\n"
  : [rc]"=m"(rc)
  : [ep]"m"(ep), [savearea]"r"(&mem31->savearea), 
[parms]"r"(&mem31->parms)

  : "r0", "r1", "r13", "r14", "r15"
);

On 29/06/2022 10:14 am, David Crayford wrote:
You need to use inline assembly with SAM31/SAM64 AMODE switching. All 
of our stuff is 64-bit so we do this a lot. Don't forget to allocate 
the savearea and parmlist/parms below the bar.


__asm__(
  " LLGT 15,%[ep]\n"
  " LR 1,%[PARMS]\n"
  " LR 13,%[savearea]\n"
  " SAM31\n"
  " BALR 14,15\n"
  " SAM64\n"
  " ST 15,%[rc]\n"
  : [rc]"=m"(rc)
  : [ep]"m"(ep), [savearea]"r"(&mem31->savearea), 
[parms]"r"(&mem31->parms)

  : "r0", "r1", "r13", "r14", "r15"
);

On 28/06/2022 10:12 pm, Colin Paice wrote:
I've been working on calling an (amode 31) assembler program from a 
64 bit
C program, and have been struggling.Is there is a good guide on how 
to use

these new instructions?
For example
1)
I've found you need to use a  LLGTR R1... instruction to clear the 
register

before using a L R1... because without it the high part of the register
will have some 64 bit rubbish in it

2)
I used

BAKR  R14,0
PR
But it kept returning in amode 24 bit mode.  It needs BSM 14,0  before
the  BAKR.__

The POP tells you all about the instructions - but not how to use 
it.  The

z/OS doc says use BACK/PR  without mentioning the  BSM, so this is not
completely trustworthy.
_
Is there a better place to ask?

Colin

--
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: is there any documentation on using the new 64 bit instructions?

[David Crayford]

You need to use inline assembly with SAM31/SAM64 AMODE switching. All of 
our stuff is 64-bit so we do this a lot. Don't forget to allocate the 
savearea and parmlist/parms below the bar.


__asm__(
  " LLGT 15,%[ep]\n"
  " LR 1,%[PARMS]\n"
  " LR 13,%[savearea]\n"
  " SAM31\n"
  " BALR 14,15\n"
  " SAM64\n"
  " ST 15,%[rc]\n"
  : [rc]"=m"(rc)
  : {ep"m"(ep), [savearea]"r"(&mem31->savearea), [parms]"r"(&mem31->parms)
  : "r0", "r1", "r13", "r14", "r15"
);

On 28/06/2022 10:12 pm, Colin Paice wrote:

I've been working on calling an (amode 31) assembler program from a 64 bit
C program, and have been struggling.Is there is a good guide on how to use
these new instructions?
For example
1)
I've found you need to use a  LLGTR R1... instruction to clear the register
before using a L R1... because without it the high part of the register
will have some 64 bit rubbish in it

2)
I used

BAKR  R14,0
PR
But it kept returning in amode 24 bit mode.  It needs BSM   14,0  before
the  BAKR.__

The POP tells you all about the instructions - but not how to use it.  The
z/OS doc says use BACK/PR  without mentioning the  BSM, so this is not
completely trustworthy.
_
Is there a better place to ask?

Colin

--
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: Some questions on SYSCALL

[David Crayford]

 REXX isn't so simple after all! You would have been better off 
writing your code in Java, or if you have installed the new Open XL 
C/C++ compiler/runtime you could use the C++17 filesystem library.


To me, just having to check return codes instead of relying on 
exceptions is a good enough reason to dodge REXX.


On 29/06/2022 6:32 am, Charles Mills wrote:

I think that for write you pass the buffer by name, not its Rexx value. Believe 
it or not.

That is what the example in the manual shows, and that is what is working in my 
code:

"write" Filefd "Record" Length(Record)

Is writing the contents of Record, not the literal "Record". Definitely 
counterintuitive. Definitely astonishing.

Maybe (Record) would work. I have not tried, and that is not what the examples 
show.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of Paul Gilmartin
Sent: Tuesday, June 28, 2022 3:01 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some questions on SYSCALL

On Tue, 28 Jun 2022 14:42:45 -0700, Charles Mills wrote:


I am still not quite understanding the usage of Rexx variables with SYSCALL.

If myFileName = "/u/myfile" then do I want to code

"SYSCALL open myFileName" or "SYSCALL open" myFileName  ?


address SYSCALL "open" myFileName  /* Rexx evaluates myFileName.  */


In other words, does myFileName get passed by value, or does SYSCALL do an 
IRXEXCOM to find its value from its name?


Not really.
 say myFileName  /* Rexx evaluates.  */


Ditto for SYSCALL write. The example on 
https://www.ibm.com/docs/en/zos/2.1.0?topic=scd-write shows

"write" fd "buf"

Which makes no sense to me at all. fd is passed by value but "buf" by name?


Both by value.
 string = "Hello world"ESC_N
 address SYSCALL "write 1 (string)"

Specifying a syscall command
 Specifying strings
 A variable name enclosed in parentheses.
 Strings that contain both the single quotation mark and
 double quotation mark characters must be stored in a variable,
 and you must use the variable name.



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

Re: Some UNIX file usage questions

[David Crayford]

On 27/06/2022 7:09 am, Andrew Rowley wrote:

On 24/06/2022 3:17 pm, David Crayford wrote:
There's a more complete example here 
https://github.com/zsystems/java-samples/blob/master/MvsConsoleInteraction.java. 



Using Object.wait()/notify() is a bit hairy. A more modern 
implementation would use Condition.await()/signal() but it's fine for 
this use case.


I cut as much as possible out of my example so there was less code to 
wade through to see the logic of the stop/modify etc.


There are some significant differences between the IBM example and mine:

- The IBM example does nothing until it receives the MODIFY command. 
My example does something (sleep), and responds to STOP and MODIFY 
commands.
In a real implementation the sleep would be replaced with the actual 
function of the STC. I think this is more realistic, most STCs have a 
function they perform until they are stopped - they don't just respond 
to modify commands.


That's ok for a simple single threaded server but won't fly if you use a 
framework. We use the Spring Boot application framework which implements 
multiple concurrent services. We spin up a ConsoleController thread that 
shuts down the Spring application context on a STOP command for a clean 
termination.
Our stuff can run on distributed systems so using a console listener is 
optional. Unless you REALLY need to run on z/OS (native code) you should 
strive to write Java applications that can run multi-platform.




- The IBM example returns true from handleStop which results in an 
immediate System.exit(0). I think this will result in an ugly abend if 
there is a dataset being processed at the time because it is not 
properly closed. My example is designed for a clean shutdown.


It's a simple sample. But it shows a useful model which is how we used 
it in more sophisticated environment.





Object.wait/notify is probably a reasonable approximation of an ECB. I 
would be more inclined to use higher level constructs.




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

Re: USS compare

[David Crayford]

I already provided a link to the doc in a previous post. 

> On 25 Jun 2022, at 8:59 am, Paul Gilmartin 
> <042bfe9c879d-dmarc-requ...@listserv.ua.edu> wrote:
> 
> On Sat, 25 Jun 2022 08:10:23 +0800, David Crayford wrote:
> 
>>> On 25/06/2022 7:43 am, Bhum Muth wrote:
>>> I want to compare the names and content of the files
>> 
>> diff -r dir1 dir2 > diff-results.txt
>> 
> That's at least an instance.  If the OP wants general proficiency, he should 
> consult:
> <https://www-40.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R3sa232279?OpenDocument>.
> 
> -- 
> 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: USS compare

[David Crayford]

On 25/06/2022 7:43 am, Bhum Muth wrote:

I want to compare the names and content of the files


diff -r dir1 dir2 > diff-results.txt




--
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: USS compare

[David Crayford]

diff  
https://www.ibm.com/docs/en/zos/2.4.0?topic=descriptions-diff-compare-two-text-files-show-differences

> On 25 Jun 2022, at 6:40 am, Bhum Muth  wrote:
> 
> Would like to know if any easy way to compare 2 USS files (say compare 2 
> versions of /etc).
> 
> Thanks,
> BM
> 
> --
> 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: Some UNIX file usage questions

[David Crayford]

There's a more complete example here 
https://github.com/zsystems/java-samples/blob/master/MvsConsoleInteraction.java. 



Using Object.wait()/notify() is a bit hairy. A more modern 
implementation would use Condition.await()/signal() but it's fine for 
this use case.


On 23/06/2022 12:16 pm, Andrew Rowley wrote:

On 23/06/2022 1:40 pm, Tony Harminc wrote:

[...]

  while (!stopped)
  {
  Thread.sleep(1000);
  }
  }

Does this actually always sleep for the entire time, or is it somehow
interrupted by the MODIFY command? In an ordinary MVS environment, one
would write a command handling subtask, and when the main (or a
worker) task waits for work, it waits on both the work ECB and the
command-has-been-issued one. Or a we-are-shutting-down one. In this
example it appears that the worker task/thread both waits for commands
and does the work (the report).


The main thread sleeps for the entire 1000 milliseconds.

The handleModify and handleStop methods are called on another thread 
from JZOS.


It is possible to interrupt waiting/sleeping threads, but that kind of 
inter-thread communication gets more complicated. I was just trying to 
illustrate the setup for receiving STOP and MODIFY commands.




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

Re: Some UNIX file usage questions

[David Crayford]

On 22/06/2022 8:17 pm, René Jansen wrote:

Hi David,

Thanks to the pointers about the Rocket Python page being obsolete,


On 22 Jun 2022, at 13:29, David Crayford  wrote:

I don't share you pessimism about the young girls and boys. All the young guys 
I work with are technically superb and extremely diligent.

Not pessimistic at all, but I see the accidents of letting people loose on 
environments they don’t know. Not knowing IMS has DB and DC, and 
‘rationalizing’ the compile proc. (That was quite something when it hit 
production.) Or my pet peeve at the moment, doing everything in WebSphere with 
timer beans because they don’t know Java also runs in batch, and then 
converting 30-minute COBOL batch jobs into 7 hour DB2 and Sysplex locking 
overhead dramas. Not knowing DB2 has a load utility and deleting everything 
with SQL. Not even knowing tables go in table spaces, The list goes on and on.


That's an interesting war story. Smacks of bad management letting it 
happen.





You cannot reduce everything that is done on z/OS to something your Raspberry 
Pi can run on Linux. Because if you do, people will not see the value of the 
mainframe. This will push the workloads to aws and azure and will cause the 
loss of the reliability and dependability of the platform, which is a cultural 
value and not a technical.

The ‘modernise the mainframe’ movement is just like the people who told us the 
last mainframe would be switched off in 1997, but having failed to do that, 
they are now targeting its software environment.
I am probably just as tired of this discussion as you are, but it is hard to 
see people pounce on Rexx every time it is mentioned. I wish companies like 
yours would work to enhance and modernise Rexx instead of porting every fad - 
you know that Python is at the top of the hype cycle at the moment, and will be 
replaced - just like PHP (for sysplex z/OS, did it even leave the lab?), Swift 
and the ones that came before.


Having Python on z/OS is important now that automation platforms like 
Red Hat Ansible are being ported to z/OS. Ansible is written in Python. 
You'll be pleased to know there is a shout out to REXX and JCL 
https://www.ansible.com/integrations/infrastructure/ibm-zos. We use 
Ansible at Rocket. A team of our young systems programmers devloped 
Ansible playbooks to provision sandbox z/OS VMs. I can use the Ansible 
Tower UI to choose what software I want installed (DB2, IMS, CICS, MQ 
etc) and in 5 minutes I have my own system and admin authority. Very 
handy when you're developing a piece of systems level code which could 
hose the system. This is a good example of why having z/OS systems 
programmers with Python skills is important on todays mainframes.





In any case, I promise not to discuss this again if you can promise you don’t 
needlessly attack people for how they use Rexx.


I'll try :) Charles knows I wasn't attacking him personally. We go back 
a few years and have collaborated off list a few times.





Best regards,

René.



--
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: Some UNIX file usage questions

[David Crayford]

Hi Rene,

Rocket's Python is dead. It was effectively killed as soon as IBM 
released IBM Open Enterprise SDK for Python. IBMs Python can be ordered 
on Shopz and installed as part of ServerPac or CBPDO. You can optionally 
install it using a pax file if you're kicking tires but almost everybody
will use SMP/E. IBM releases PTFs quite frequently, usually patching 
security vulnerabilities and keep the Python versions bang up to date. 
It's a supported product with an FMID 5655-PYT. It's a bit like Java so 
you can pre-req it as IBM do for their products that are dependent on 
Python.

You can throw Golang and Node.js into the mix as well

https://www.ibm.com/common/ssi/ShowDoc.wss?docURL=/common/ssi/rep_sm/t/760/ENUS5655-PYT/index.html&lang=en&request_locale=en

I don't share you pessimism about the young girls and boys. All the 
young guys I work with are technically superb and extremely diligent.


On 22/06/2022 5:52 pm, René Jansen wrote:

Hi David,

You did that to yourself; by going off into a discussion with Charles about his use 
of Rexx and assembler. Your company website says it best: "friendly for 
programmers who lack conventional mainframe language skills” 
(https://www.rocketsoftware.com/platforms/ibm-z/python-for-zos).

However interesting this modernising is, there is no standard python 
installation on our customers’ systems. There is an IBM port and a Rocket port, 
they are different and for most mainframe personnel installing something by 
themselves is a sure way to be fired from the job. There is an enormous 
installed base of older technology and it is not going away. All the disasters 
I witness, are caused by young boys and girls that have been let loose in an 
environment that they pretend to know, with tools that react slightly 
different. All of them are grateful when shown how it is done.

Best regards,

René.


On 21 Jun 2022, at 15:35, David Crayford  wrote:

I don't want to get into another ping pong debate over REXX. Everyone knows my 
opinion by now.


--
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: Some UNIX file usage questions

[David Crayford]

On 22/06/2022 7:03 am, Charles Mills wrote:

Can one write a Started Task in Java? What would the JCL look like (neglecting 
application-specific items)?


Yes, of course. For example, z/OSMF, WAS, z/OS Connect etc are all 
started tasks written in Java. The product I'm working on right now can 
run as an MVS started task or on distributed. We
have code that starts a console listener thread if running on z/OS which 
handles modify commands to refresh the server if the config changes. 
JZOS is awesome. The batch launcher handles STOP
commands under the covers. You can write a handler for STOP commands to 
run cleanup code. Here's the doc for setting up the server as a started 
task.


https://www.ibm.com/docs/en/om-im/5.6.0?topic=started-configuring-omegamon-data-connect

The JZOS Batch Launcher users guide 
https://public.dhe.ibm.com/software/Java/Java80/JZOS/jzos_users_guide_v8.pdf





I suppose I might ask the same question with regard to Python. Also is Python 
"standard" with z/OS or would I have to solve the download and install issues?


You can either order Python on Shopz or download a pax file and install 
it yourself from a shell. It has a PID so you can pre-req it for 
products. Python is the industry standard language for AI/ML. It uses 
highly efficient libraries written in
C/C++ such as NumPy, Torch, Tensorflow etc. You may have read that the 
z16 comes with on chip analytics accelerator for ML/AI. IBM have 
released details of the API, which is a 64-bit XPLINK C library. It's 
very similar to Tensorflow so it's almost certainly
going to be wrapped in Python. Python is strategic on z/OS. It's simple 
to extend using C/C++ and has a ginormous standard library and 
eco-system. It's very simple to learn which is all goodness.


https://github.com/IBM/zDNN/blob/main/README.md




Serious questions.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Tuesday, June 21, 2022 3:21 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 22/06/2022 3:01 am, Kirk Wolf wrote:

FYI - JZOS includes a wrapper for __console2() - class com.ibm.jzos.MvsConsole

Indeed. We use the JZOS console listener for handling modify commands.
If Charles had Java skills he could have used the rotating log library
and JZOS which provides MVS STOP commands implicitly instead of having
to write new code. Which is interesting as he cited choosing REXX as
it's quicker to develop in as he already knows the language. In the land
of the blind the one eyed man is king :)



Kirk Wolf
Dovetailed Technologies, LLC
http://coztoolkit.com

Note: Our website and domain name have changed from dovetail.com to 
coztoolkit.com


On Tue, Jun 21, 2022, at 11:54 AM, Charles Mills wrote:

_console2() does everything appropriate, including managing the CIB chain.

A batch job could, if appropriate, respond to STOP.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Seymour J Metz
Sent: Tuesday, June 21, 2022 9:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

Does _console2() delete the CIB in order to allow and additional MODIFY?

For a batch job, only the MODIFY CIB is an issue.


From: IBM Mainframe Discussion List  on behalf of
David Crayford 
Sent: Tuesday, June 21, 2022 9:17 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 21/06/2022 9:09 pm, Seymour J Metz wrote:

If all that you want to do is to check for STOP, then it should be trivial

to do it in C++. If you also want to enable and look for MODIFY text, then
you need to use QEDIT. At that point it's easier to do it in HLASM.

The __console2() C/C++ RTL function does everything you could want to do
with console services other than START, which I don't care about
https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.ibm.co
m%2Fdocs%2Fen%2Fzos%2F2.1.0%3Ftopic%3Dfunctions-console2-enhanced-console-co
mmunication-services&data=05%7C01%7Csmetz3%40gmu.edu%7C77d498419638409e4
ab608da53888b89%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637914143163123
218%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1h
aWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=DuHrRUBqMMJI%2BOuri59jghQ37N%2F
qWy189iFtag5qn1A%3D&reserved=0.

Maybe Charles will open up his code for inspection and (just for fun) we
can see if it's easier to implement in C++ or Java :)



I've used Assembler H and REXX in an environment where code and design

reviews were mandatory. And, yes, discussions included alternate ways of
doing things, some accepted, some not.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf

of Davi

Re: Some UNIX file usage questions

[David Crayford]

On 22/06/2022 3:01 am, Kirk Wolf wrote:

FYI - JZOS includes a wrapper for __console2() - class com.ibm.jzos.MvsConsole


Indeed. We use the JZOS console listener for handling modify commands. 
If Charles had Java skills he could have used the rotating log library 
and JZOS which provides MVS STOP commands implicitly instead of having 
to write new code. Which is interesting as he cited choosing REXX as 
it's quicker to develop in as he already knows the language. In the land 
of the blind the one eyed man is king :)




Kirk Wolf
Dovetailed Technologies, LLC
http://coztoolkit.com

Note: Our website and domain name have changed from dovetail.com to 
coztoolkit.com


On Tue, Jun 21, 2022, at 11:54 AM, Charles Mills wrote:

_console2() does everything appropriate, including managing the CIB chain.

A batch job could, if appropriate, respond to STOP.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On
Behalf Of Seymour J Metz
Sent: Tuesday, June 21, 2022 9:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

Does _console2() delete the CIB in order to allow and additional MODIFY?

For a batch job, only the MODIFY CIB is an issue.


From: IBM Mainframe Discussion List  on behalf of
David Crayford 
Sent: Tuesday, June 21, 2022 9:17 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 21/06/2022 9:09 pm, Seymour J Metz wrote:

If all that you want to do is to check for STOP, then it should be trivial

to do it in C++. If you also want to enable and look for MODIFY text, then
you need to use QEDIT. At that point it's easier to do it in HLASM.

The __console2() C/C++ RTL function does everything you could want to do
with console services other than START, which I don't care about
https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.ibm.co
m%2Fdocs%2Fen%2Fzos%2F2.1.0%3Ftopic%3Dfunctions-console2-enhanced-console-co
mmunication-services&data=05%7C01%7Csmetz3%40gmu.edu%7C77d498419638409e4
ab608da53888b89%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637914143163123
218%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1h
aWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=DuHrRUBqMMJI%2BOuri59jghQ37N%2F
qWy189iFtag5qn1A%3D&reserved=0.

Maybe Charles will open up his code for inspection and (just for fun) we
can see if it's easier to implement in C++ or Java :)



I've used Assembler H and REXX in an environment where code and design

reviews were mandatory. And, yes, discussions included alternate ways of
doing things, some accepted, some not.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf

of David Crayford [dcrayf...@gmail.com]

Sent: Monday, June 20, 2022 1:34 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I could care less about Python. What is disconcerting is why you would
choose REXX/Assembler when you could write the same thing with less code
and complexity using C++ which you already know. Maybe you're just
having fun and there is nothing wrong with that. There is nobody to
review your code and ask for changes like where I work.

On 21/06/2022 1:31 am, Charles Mills wrote:

I am not the client. I guess the client makes its decisions based on a

variety of factors. I have many skills that are valuable to the client, and
I would guess that "best language for the application in the opinion of a
guy on IBMMAIN" (as opposed to "demonstrably adequate language") is not high
on the client's list of factors.

I think you are engaging in "engineer-ism" (there may be a better word?).

Python may well be the best language for the job, for some values of best.
Rexx is a perfectly adequate language for the job. "Integrating a new
developer" would be for the client what "implementing a new language
environment" would be for me.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On

Behalf Of David Crayford

Sent: Monday, June 20, 2022 9:58 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I take it you must be the client? I can't fathom any client who would be
stupid enough to allow a vendor to write code in their language of
choice due to their personal skill set. That's technical debt.

On 20/06/2022 11:34 pm, Charles Mills wrote:

Aww David, I respect you more than that reply.

Of course I could learn to write Hello World in Python more quickly than

I can write this sentence. But what I alluded to is that past experience
teaches me that getting from Hello World to a working system on z/OS is many
days of agony.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mail

Re: Some UNIX file usage questions

[David Crayford]

Hi Rony,

Much respect for spending so much time to scribe such a response. We've 
already flogged this horse within an inch of it's life already and we 
will just have to agree to disagree. REXX is still an important language 
on z/OS for TSO scripting, NetView and System REXX is quite cool. As a 
general purpose
scripting language it's moribund. Given the other options available 
nobody other than enthusiasts or language bigots want to use it (I have 
no time for language bigotry in the workplace, it's unprofessional). IBM 
are porting languages to try to keep the mainframe modern and accessible 
to new hires.


I'm not sure why I would every want to use NetRexx. Coding standard Java 
is easier not to mention Groovy and Kotlin. 15 years ago IBM were 
shipping z/OS WAS scripts written in Jython. IMHO. NetRexx is a solution 
looking for a problem and I can find no significant products that use it.


I don't want to get into another ping pong debate over REXX. Everyone 
knows my opinion by now.


On 21/06/2022 6:12 pm, Rony G. Flatscher wrote:

On 20.06.2022 19:26, David Crayford wrote:

On 21/06/2022 1:07 am, Paul Gilmartin wrote:

On Mon, 20 Jun 2022 08:47:49 -0700, Charles Mills wrote:

    ...
The assembler routine will take as input a delay time in hundredths 
of a second (because of STIMER), do a WAIT ECBLIST, and return one of


'T' -- the time expired
'P' -- the operator entered STOP
'F modify command operand' -- the operator entered MODIFY

What happens if the operator enters STOP during the (relatively 
minuscule)

fraction of time that Rexx, not Assembler is active?


In that case the EXTRACT ECB will be posted and the routine will stop 
when it is re-entered and the ECB is tested. I've written something 
similar myself for Lua. The differnce is Lua is object oriented and 
holds state where REXX is not so it's a Frankenstien monster to 
create a reusable context.
It's hard to justify why anybody would do it for REXX when you can 
just code a C++ program using __console() and a std::thread.


This is a question of philosophy in general.

"Name dropping" of computer programming languages does not 
substantiate assessment of a problem and then thinking of the "best" 
solution for it. One criterium might be performance, another needed 
resources,  another one is to solve a problem quickly (saving human 
time), another one is legibility to improve understanding, 
maintainability, reduce errors, and many more.


One important criterium is definitely standardisation: this makes sure 
that in certain environments basic programming skills can be relied on 
like in the mainframe world REXX or Java or Assembler. If one is able 
to jump between different programming languages like Assembler, REXX, 
Lua, C++, Python, Java, JavaScript, Perl, Ruby, ..., and the programs 
should be maintainable by others, preferably by the shops where they 
get deployed, then one should not "jump around" languages, just 
because some person is able to do so as the resulting code might 
lock-in the shops, make them dependent on the authors/sellers.


---

Seeing that you sometimes stress the importance of object-orientness 
for various reasons (like above) pointing at REXX incapability in that 
context, then seeing that you like to frame REXX with all bad and 
negative emotions ("it's a Frankenstein monster") one wonders what is 
the agenda of such a person.


Clearly, if it was possible to build on REXX skills and making it easy 
to e.g. exploit object-oriented features, most notably the ability to 
define data structures with functions/methods to maintain/interact 
with them ( a.k.a. "types","classes"), why not use the language IBM 
has originally built as an object-oriented successor to REXX i.e. 
ooRexx? ooRexx is able to run Rexx programs and allows optionally to 
define your own data structures/classes/types, plus it adds a wealth 
of useful new features in an easy to learn and easy to use manner.


There are mainframe shops that use ooRexx as a mainframe port to the 
Linux subsystem has been existing.


---

Now if someone were to try out/explore ooRexx it may be interesting to 
extend ooRexx such that REXX programmers who got accustomed to ooRexx 
may become able to interact with/exploit Java, noticing how 
predominant Java is and how well it gets supported by IBM. (Heck, IBM 
even has an OpenJDK distribution of its own! And not only IBM, even 
Microsoft, believe it or not, and Amazon, and Bellsoft, and ...)


The interesting thing is, if the user, the programmer is in the center 
of endeavors like enhancing REXX with object-oriented abilities such 
that the language remains easy, and then extends the abilities to 
encompass all of Java, but using a dynamically typed, caseless 
programming language like REXX or ooRexx, then it is likely that 
"normal" REXX programmers beco

Re: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 9:09 pm, Seymour J Metz wrote:

If all that you want to do is to check for STOP, then it should be trivial to 
do it in C++. If you also want to enable and look for MODIFY text, then you 
need to use QEDIT. At that point it's easier to do it in HLASM.


The __console2() C/C++ RTL function does everything you could want to do 
with console services other than START, which I don't care about 
https://www.ibm.com/docs/en/zos/2.1.0?topic=functions-console2-enhanced-console-communication-services. 

Maybe Charles will open up his code for inspection and (just for fun) we 
can see if it's easier to implement in C++ or Java :)





I've used Assembler H and REXX in an environment where code and design reviews 
were mandatory. And, yes, discussions included alternate ways of doing things, 
some accepted, some not.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Monday, June 20, 2022 1:34 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I could care less about Python. What is disconcerting is why you would
choose REXX/Assembler when you could write the same thing with less code
and complexity using C++ which you already know. Maybe you're just
having fun and there is nothing wrong with that. There is nobody to
review your code and ask for changes like where I work.

On 21/06/2022 1:31 am, Charles Mills wrote:

I am not the client. I guess the client makes its decisions based on a variety of factors. I have 
many skills that are valuable to the client, and I would guess that "best language for the 
application in the opinion of a guy on IBMMAIN" (as opposed to "demonstrably adequate 
language") is not high on the client's list of factors.

I think you are engaging in "engineer-ism" (there may be a better word?). Python may well be the 
best language for the job, for some values of best. Rexx is a perfectly adequate language for the job. 
"Integrating a new developer" would be for the client what "implementing a new language 
environment" would be for me.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Monday, June 20, 2022 9:58 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I take it you must be the client? I can't fathom any client who would be
stupid enough to allow a vendor to write code in their language of
choice due to their personal skill set. That's technical debt.

On 20/06/2022 11:34 pm, Charles Mills wrote:

Aww David, I respect you more than that reply.

Of course I could learn to write Hello World in Python more quickly than I can 
write this sentence. But what I alluded to is that past experience teaches me 
that getting from Hello World to a working system on z/OS is many days of agony.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Sunday, June 19, 2022 9:32 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

You could have learned Python in the time it took you to write this email.

On 20/06/2022 1:15 am, Charles Mills wrote:

Why not use Python? Good question.

1. I can undoubtedly do it perfectly satisfactorily, and almost certainly more 
quickly, in Rexx (because of the learning curve). I would have trouble 
justifying billing the client for my Python learning time when there is little 
benefit (that I know of -- correct me if I am wrong) for the client who is 
paying the bills.

Why not, then, learn Python on my own time? Don't I want to learn Python? Yes I 
do, but there are only so many hours in a day, and there are other things I 
want to learn more than I do Python. For example, I would rather spend the time 
learning to make the Roman-Jewish fried artichokes that are in the current 
Cooks Illustrated. Learning Python is just not very high on my bucket list. 
It's there, but probably not high enough to ever rise to the top.

2. I know exactly how to execute a Started Task written in Rexx, and I know most of the 
gotchas. In my experience, THAT is the problem with the "new tools" on z/OS. 
What would I have to do to execute a Started Task written in Python? What are the 
gotchas? Heck, what do I have to do to set up any Python environment at all? That is the 
time-consuming issue, and it holds about zero personal gratification for me. I could 
probably learn the Python language pretty readily, and it would be one more notch in my 
belt. Solving the probable gotchas of getting Python to actually do productive work on 
z/OS -- not so much.

Not for me, and probably not for the "report" (I am flattering the requirement

Re: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 12:53 pm, Charles Mills wrote:

No! 96 24-byte *records* per day.

My current vision is to use a UNIX file, write the records every 15 minutes as 
they are produced, and do the close/rename/start over once per *month*, on the 
first write after midnight on the 1st of every month.


I implemented something similar for our product to create CSV files to 
be loaded into DB2/IDAA. Much higher volumes. Our stuff is in Java and I 
found a really nifty rotating log library by one of the Apache 
developers https://github.com/vy/rotating-fos. It's policy based so can 
be configured in a YAML file.





There are two basic reports, a daily report for yesterday and a monthly report 
for last month. The daily report will find the right day within the current 
month's file by spinning to the right record. Worst case that is ~3000 reads. 
The monthly report will process all of a month's records.

Everything in the post you quote is about the internal loop logic. It does not 
address the file strategy one way or the other.

I am good. I think I have a design. I know of no open problems. Now I just have 
to actually get to work.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of kekronbekron
Sent: Monday, June 20, 2022 8:05 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

Hey Charles,

Does the 96-files a day solution not work?
You could cat *-mmdd.txt > mmdd.txt at 00.05 and then delete the 96 
files.
You wouldn't have to worry about losing out data in memory if it's written to a 
file every 15 min.
It appears to be a pretty basic & simple solution?

- KB

--- Original Message ---
On Tuesday, June 21st, 2022 at 3:09 AM, Charles Mills  wrote:



Nay! Rexx passes everything by value, both to internal and to external functions. So 
passing  will give the assembler code 200 zero bytes to play with but 
it will go away on return.


And it is unnecessary. I know of no need for persistent storage. Perhaps it is worth persisting the 
STIMER MF=L and friends. (I have not yet done detail design. If indicated I will use name/token to 
do the persisting. There is also a persistent "user" pointer in the "environment 
block" that Rexx maintains and passes, so that is perhaps a better alternative. I have some 
detail design work to do.)

The pseudocode is otherwise on target. I would add (watch the line wrap!)

When Left(Res, 1) = 'T'
/* Rexx PARSE command from Res /
/ Re-parametize or whatever is indicated by the command /
Iterate
end
end
/ Close files, clean up and terminate */

The ECB is in MVS-managed storage but it is apparently user-key.

I won't "persist" the STIMER; I will cancel it when I get an F or a P. F should 
be infrequent enough that there is little wasted overhead in cancelling the STIMER and 
presumably re-starting it. If the caller wants to resume the remaining interval it can 
readily enough keep the absolute wakeup time desired and do the necessary arithmetic. 
OTOH I guess F could return the remaining interval but that neglects any time spent 
processing the F. For P of course the remaining interval is irrelevant.

Whoever mentioned Rexx variables moving around was on target. Rexx's internal storage 
management is a black box. It may well move stuff around from time to time. As I say, 
everything is passed by value. And there is no C ampersand operator. I know of no way to 
get the address of a Rexx variable. Actually, now that I think about it, I have used 
IRXEXCOM which returns Rexx variable data "in bulk" to an assembler routine, 
but I do not recall the details. It may pass the actual address, not a copy of the value 
-- I don't recall.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Monday, June 20, 2022 11:10 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I think I understand what Charles is doing.

context = copies('00'x,200) <-- state for HLASM program
wait_time = 30

do forever
res = console(context, wait_time)
select
when res = 'T' then iterate
when res = 'P' then leave
otherwise ...
end
end


On 21/06/2022 1:58 am, Paul Gilmartin wrote:


I'll correct my earlier misstatement. You did not say you were the client;
merely "-n-house".

On Mon, 20 Jun 2022 10:41:25 -0700, Charles Mills wrote:


The ECB is not in the Rexx. It is in MVS-owned storage IIRC.

I believe ECBs routinely occupy user-owned storage.


-Original Message-


...
... Well, the actual parameter passed by the Rexx is continuously accessible to 
the Assembler. It is of course possible to access any Rexx variable from 
assembler, but I see no need. If I understand your question, the answer is No.

I took "continuously accessibl

Re: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 5:39 am, Charles Mills wrote:

Nay! Rexx passes everything by value, both to internal and to external functions. So 
passing  will give the assembler code 200 zero bytes to play with but 
it will go away on return.


Pass by value doesn't matter. I've done this before and just checked the 
code. From 1993, a lifetime ago when I still used REXX. Here's the man 
page that get's printed to the terminal if you call it as a TSO command. 
It's a KSDS I/O function
which passes back the address of the ACB on open which is then passed 
back as a context handle.


The vsamio program can be called as a function from a REXX
 EXEC to allow access to VSAM KSDS datasets or invoked from TSO
 with no parameters for Help information.
 Format;
 acb    = vsamio(O,ddname)    /* Open for read */
 acb    = vsamio(U,ddname)    /* Open for update   */
 acb    = vsamio(X,ddname)    /* Open for Alt. Index   */
 retcod = vsamio(C,acb)   /* Close */
 record = vsamio(R,acb,key)   /* Read with key */
 record = vsamio(G,acb,key)   /* Read with generic key */
 record = vsamio(N,acb,oa_rpl)    /* Read next */
 record = vsamio(P,acb,oa_rpl)    /* Read previous */
 retcod = vsamio(W,acb,record)    /* Write record  */
 retcod = vsamio(E,acb,key)   /* Erase record  */
 REXX variables set by function;
 oa_rc  - VSAM return code (R15 value) or vsamio error code
 oa_ec  - VSAM error code (R0 value)
 oa_rpl - Set following Read Key for Read Next
 if oa_rc = 0 then ..  /* Check completion  */



And it is unnecessary. I know of no need for persistent storage. Perhaps it is worth persisting the 
STIMER MF=L and friends. (I have not yet done detail design. If indicated I will use name/token to 
do the persisting. There is also a persistent "user" pointer in the "environment 
block" that Rexx maintains and passes, so that is perhaps a better alternative. I have some 
detail design work to do.)

The pseudocode is otherwise on target. I would add (watch the line wrap!)

   When Left(Res, 1) = 'T'
 /* Rexx PARSE command from Res */
 /* Re-parametize or whatever is indicated by the command */
 Iterate
 end
end
/* Close files, clean up and terminate */

The ECB is in MVS-managed storage but it is apparently user-key.

I won't "persist" the STIMER; I will cancel it when I get an F or a P. F should 
be infrequent enough that there is little wasted overhead in cancelling the STIMER and 
presumably re-starting it. If the caller wants to resume the remaining interval it can 
readily enough keep the absolute wakeup time desired and do the necessary arithmetic. 
OTOH I guess F could return the remaining interval but that neglects any time spent 
processing the F. For P of course the remaining interval is irrelevant.

Whoever mentioned Rexx variables moving around was on target. Rexx's internal storage 
management is a black box. It may well move stuff around from time to time. As I say, 
everything is passed by value. And there is no C ampersand operator. I know of no way to 
get the address of a Rexx variable. Actually, now that I think about it, I have used 
IRXEXCOM which returns Rexx variable data "in bulk" to an assembler routine, 
but I do not recall the details. It may pass the actual address, not a copy of the value 
-- I don't recall.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Monday, June 20, 2022 11:10 AM
To:IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I think I understand what Charles is doing.

context = copies('00'x,200) <-- state for HLASM program
wait_time = 30

do forever
  res = console(context, wait_time)
  select
when res = 'T' then iterate
when res = 'P' then leave
otherwise ...
 end
end


On 21/06/2022 1:58 am, Paul Gilmartin wrote:

I'll correct my earlier misstatement.  You did not say you were the client;
merely "-n-house".

On Mon, 20 Jun 2022 10:41:25 -0700, Charles Mills wrote:


The ECB is not in the Rexx. It is in MVS-owned storage IIRC.


I believe ECBs routinely occupy user-owned storage.


-Original Message-

 ...
... Well, the actual parameter passed by the Rexx is continuously accessible to 
the Assembler. It is of course possible to access any Rexx variable from 
assembler, but I see no need. If I understand your question, the answer is No.
   

I took "continuously accessible" to mean accessible by concurrent tasks even 
after
the Assembler returns to Rexx.


That depends on the AFAIK undocumented behavior of Rexx storage
management.  What happens if Rexx compacts variable storage, thereby
moving an ECB?  Rexx spurns concurrency.

Re: Some UNIX file usage questions

[David Crayford]

I think I understand what Charles is doing.

context = copies('00'x,200) <-- state for HLASM program
wait_time = 30

do forever
    res = console(context, wait_time)
    select
  when res = 'T' then iterate
      when res = 'P' then leave
  otherwise ...
   end
end


On 21/06/2022 1:58 am, Paul Gilmartin wrote:

I'll correct my earlier misstatement.  You did not say you were the client;
merely "-n-house".

On Mon, 20 Jun 2022 10:41:25 -0700, Charles Mills wrote:


The ECB is not in the Rexx. It is in MVS-owned storage IIRC.


I believe ECBs routinely occupy user-owned storage.


-Original Message-

...
... Well, the actual parameter passed by the Rexx is continuously accessible to 
the Assembler. It is of course possible to access any Rexx variable from 
assembler, but I see no need. If I understand your question, the answer is No.
  

I took "continuously accessible" to mean accessible by concurrent tasks even 
after
the Assembler returns to Rexx.


That depends on the AFAIK undocumented behavior of Rexx storage
management.  What happens if Rexx compacts variable storage, thereby
moving an ECB?  Rexx spurns concurrency.


"ECB" for example.  The Devil's advocate was envisioning using the parameter
passed by Rexx as working storage.  Which is OK until returning to Rexx.



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

Re: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 1:47 am, Tony Harminc wrote:

On Mon, 20 Jun 2022 at 13:34, David Crayford  wrote:

I could care less about Python.

Could you care a lot less, or just a little bit less? There is surely
quite a range of caring.
Here's a little chart that may help you express how much you care
about Python or anything else.

https://incompetech.com/gallimaufry/care_less.html


How much do you care about people caring?




Tony H.

--
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: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 1:47 am, Charles Mills wrote:
As I said in response to an earlier question, I am the master of this 
universe.  


Good luck to you and have fun :)



Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Monday, June 20, 2022 10:34 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I could care less about Python. What is disconcerting is why you would
choose REXX/Assembler when you could write the same thing with less code
and complexity using C++ which you already know. Maybe you're just
having fun and there is nothing wrong with that. There is nobody to
review your code and ask for changes like where I work.

--
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: Some UNIX file usage questions

[David Crayford]

I could care less about Python. What is disconcerting is why you would 
choose REXX/Assembler when you could write the same thing with less code 
and complexity using C++ which you already know. Maybe you're just 
having fun and there is nothing wrong with that. There is nobody to 
review your code and ask for changes like where I work.


On 21/06/2022 1:31 am, Charles Mills wrote:

I am not the client. I guess the client makes its decisions based on a variety of factors. I have 
many skills that are valuable to the client, and I would guess that "best language for the 
application in the opinion of a guy on IBMMAIN" (as opposed to "demonstrably adequate 
language") is not high on the client's list of factors.

I think you are engaging in "engineer-ism" (there may be a better word?). Python may well be the 
best language for the job, for some values of best. Rexx is a perfectly adequate language for the job. 
"Integrating a new developer" would be for the client what "implementing a new language 
environment" would be for me.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Monday, June 20, 2022 9:58 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

I take it you must be the client? I can't fathom any client who would be
stupid enough to allow a vendor to write code in their language of
choice due to their personal skill set. That's technical debt.

On 20/06/2022 11:34 pm, Charles Mills wrote:

Aww David, I respect you more than that reply.

Of course I could learn to write Hello World in Python more quickly than I can 
write this sentence. But what I alluded to is that past experience teaches me 
that getting from Hello World to a working system on z/OS is many days of agony.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Sunday, June 19, 2022 9:32 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

You could have learned Python in the time it took you to write this email.

On 20/06/2022 1:15 am, Charles Mills wrote:

Why not use Python? Good question.

1. I can undoubtedly do it perfectly satisfactorily, and almost certainly more 
quickly, in Rexx (because of the learning curve). I would have trouble 
justifying billing the client for my Python learning time when there is little 
benefit (that I know of -- correct me if I am wrong) for the client who is 
paying the bills.

Why not, then, learn Python on my own time? Don't I want to learn Python? Yes I 
do, but there are only so many hours in a day, and there are other things I 
want to learn more than I do Python. For example, I would rather spend the time 
learning to make the Roman-Jewish fried artichokes that are in the current 
Cooks Illustrated. Learning Python is just not very high on my bucket list. 
It's there, but probably not high enough to ever rise to the top.

2. I know exactly how to execute a Started Task written in Rexx, and I know most of the 
gotchas. In my experience, THAT is the problem with the "new tools" on z/OS. 
What would I have to do to execute a Started Task written in Python? What are the 
gotchas? Heck, what do I have to do to set up any Python environment at all? That is the 
time-consuming issue, and it holds about zero personal gratification for me. I could 
probably learn the Python language pretty readily, and it would be one more notch in my 
belt. Solving the probable gotchas of getting Python to actually do productive work on 
z/OS -- not so much.

Not for me, and probably not for the "report" (I am flattering the requirement calling it 
a report -- maybe call it an "alert") that the client wants. And again, a learning curve 
that is difficult to justify.

So I think I will write it in Rexx, with perhaps a little bit of Assembler.

Does your client REALLY want to maintain assembler code? Our company
policy is not to use assembler for new code due to lack of available
skills which will only get worse.



Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Saturday, June 18, 2022 11:43 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 19/06/2022 1:33 am, Paul Gilmartin wrote:

On Sat, 18 Jun 2022 09:51:45 -0700, Charles Mills wrote:

   ...
I picture writing the started task in Rexx, so I would have to write to a DD
name allocated to the UNIX file (either dynamically or with JCL), not with
"native" C fopen(), fwrite(), etc. Does that change any of the answers?


Why?  In Rexx you can "address SYASCALL write ..." instead.

Why REXX? Is it a case of knowing the banjo so you play Stairway to
Heaven in the style of Earl Schruggs?

Re: Some UNIX file usage questions

[David Crayford]

On 21/06/2022 1:07 am, Paul Gilmartin wrote:

On Mon, 20 Jun 2022 08:47:49 -0700, Charles Mills wrote:

...
The assembler routine will take as input a delay time in hundredths of a second 
(because of STIMER), do a WAIT ECBLIST, and return one of

'T' -- the time expired
'P' -- the operator entered STOP
'F modify command operand' -- the operator entered MODIFY


What happens if the operator enters STOP during the (relatively minuscule)
fraction of time that Rexx, not Assembler is active?


In that case the EXTRACT ECB will be posted and the routine will stop 
when it is re-entered and the ECB is tested. I've written something 
similar myself for Lua. The differnce is Lua is object oriented and 
holds state where REXX is not so it's a Frankenstien monster to create a 
reusable context.
It's hard to justify why anybody would do it for REXX when you can just 
code a C++ program using __console() and a std::thread.





Is there a need for persistent storage accessible by both Rexx and Assembler?

Is there a way for the operator to send SIGINT (Unix "Modify")?  Can Rexx
catch it?



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

Re: Some UNIX file usage questions

[David Crayford]

I take it you must be the client? I can't fathom any client who would be 
stupid enough to allow a vendor to write code in their language of 
choice due to their personal skill set. That's technical debt.


On 20/06/2022 11:34 pm, Charles Mills wrote:

Aww David, I respect you more than that reply.

Of course I could learn to write Hello World in Python more quickly than I can 
write this sentence. But what I alluded to is that past experience teaches me 
that getting from Hello World to a working system on z/OS is many days of agony.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Sunday, June 19, 2022 9:32 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

You could have learned Python in the time it took you to write this email.

On 20/06/2022 1:15 am, Charles Mills wrote:

Why not use Python? Good question.

1. I can undoubtedly do it perfectly satisfactorily, and almost certainly more 
quickly, in Rexx (because of the learning curve). I would have trouble 
justifying billing the client for my Python learning time when there is little 
benefit (that I know of -- correct me if I am wrong) for the client who is 
paying the bills.

Why not, then, learn Python on my own time? Don't I want to learn Python? Yes I 
do, but there are only so many hours in a day, and there are other things I 
want to learn more than I do Python. For example, I would rather spend the time 
learning to make the Roman-Jewish fried artichokes that are in the current 
Cooks Illustrated. Learning Python is just not very high on my bucket list. 
It's there, but probably not high enough to ever rise to the top.

2. I know exactly how to execute a Started Task written in Rexx, and I know most of the 
gotchas. In my experience, THAT is the problem with the "new tools" on z/OS. 
What would I have to do to execute a Started Task written in Python? What are the 
gotchas? Heck, what do I have to do to set up any Python environment at all? That is the 
time-consuming issue, and it holds about zero personal gratification for me. I could 
probably learn the Python language pretty readily, and it would be one more notch in my 
belt. Solving the probable gotchas of getting Python to actually do productive work on 
z/OS -- not so much.

Not for me, and probably not for the "report" (I am flattering the requirement calling it 
a report -- maybe call it an "alert") that the client wants. And again, a learning curve 
that is difficult to justify.

So I think I will write it in Rexx, with perhaps a little bit of Assembler.

Does your client REALLY want to maintain assembler code? Our company
policy is not to use assembler for new code due to lack of available
skills which will only get worse.



Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Saturday, June 18, 2022 11:43 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 19/06/2022 1:33 am, Paul Gilmartin wrote:

On Sat, 18 Jun 2022 09:51:45 -0700, Charles Mills wrote:

  ...
I picture writing the started task in Rexx, so I would have to write to a DD
name allocated to the UNIX file (either dynamically or with JCL), not with
"native" C fopen(), fwrite(), etc. Does that change any of the answers?


Why?  In Rexx you can "address SYASCALL write ..." instead.

Why REXX? Is it a case of knowing the banjo so you play Stairway to
Heaven in the style of Earl Schruggs?

Why not use IBMs z/OS Python? You can then use SQLite instead of a file
which will significantly simplify writing reports. In fact, it would
trivial to serve those
reports as a REST API and put a nice WebUI on top using a simple
template that supports data tables.

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


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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

I've used both MQ and Kafka so I'll give a brief overview of the 
differences and capabilities.


Kafka is distributed system. It's designed to be scaled horizontally for 
both fail-over and throughput. It uses a consensus algorithm similar to 
RAFT to elect a leader both initially and in the event of a broker 
failure when it needs to re-balance the cluster. MQ is a traditional 
message broker where Kafka is more of a streaming platform that you can 
think of a distributed log. The Kafka unit of scale is a partition which 
is a file in the file system,  distributed either randomly using keys or 
round robin. MQ is push based with a local transaction log where Kafka 
is pull based using commits to keep the offset into the log per 
consumer. The benefit of this is that you can take a service down for 
upgrade and then restart from the last commit point. Unlike MQ Kafka 
keeps doesn't delete records when they are consumed so you can bring new 
services online that start from the earliest position in the log. Data 
retention is managed using policies such as time and size limits.


Kafka works in a sysplex as it boils down to a TCP based protocol and is 
platform agnostic. In fact you could build a cluster with some brokers 
on z/OS and some on x86 Linux if you wanted to. It runs well on z/OS, 
although it was broken until last year as z/OS UNIX mmap was limited to 
31-bit address spaces. IBM fixed the issue as Kafka is strategic for 
analytics products (including ours). There is some doc 
https://www.ibm.com/docs/en/z-logdata-analytics/5.1.0?topic=configuring-setting-up-apache-kafka-z.


Where the two really start to differ is the eco-system. Kafka is much 
more then just a broker. There is a stream API and other abstractions to 
layer on top such as ksqlDB which a SQL interface to live data streams. 
You write a query which can aggregate/group data from a stream based 
upon a time window and then emit results to an output topic. For 
example, you can stream SMF 110 CICS CMF records, aggregate them into a 
5 minute hopping window with AVG, MIN, MAX functions etc and then 
publish them to Elasticsearch, Splunk or a data lake. 
https://docs.ksqldb.io/en/latest/concepts/time-and-windows-in-ksqldb-queries/


MQ is the clear winner for traditional mainframe transactions, Kafka is 
the goto for real time streaming of events.


On 20/06/2022 9:53 pm, Colin Paice wrote:

On the MQ front, I >think< there are customers who are using QREP to do DB2
to DB2 using MQ as the transport, over 1000 KM and getting about 100MB+ of
data a second - with a few second or subsecond response time.  So to the
end user it looks like a single system rather than replicated.
The limits are the rate at which you can log to disk - about 200 MB a
second last time I was involved, and the capacity of the network.
I dont know abou Kafta, if it supports sysplex, and what it's throughput is
in similar scenarios.
If you want more throughput you create another queue manager, and get more
network capacity.
Colin

On Mon, 20 Jun 2022 at 14:38, Gerhard Adam  wrote:


Perhaps no one has :grokked" the difference is because either there isn't
one or because it is so poorly explained and discussed as to be
non-existent.   This sounds like more marketing hype perpetrated by
individuals that know buzzwords and little else.



-Original Message-
From: IBM Mainframe Discussion List  On Behalf
Of David Crayford
Sent: Monday, June 20, 2022 6:12 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM
and AWS

Thanks. I’ve seen something similar on the ACM
https://dl.acm.org/doi/pdf/10.1145/1476793.1476796


On 20 Jun 2022, at 8:51 pm, Joe Monk  wrote:

https://ntrs.nasa.gov/citations/1969381

Joe


On Mon, Jun 20, 2022 at 7:00 AM David Crayford 

wrote:

And yet still nobody seems to have grokked the fundamental
differences between online systems and event-driven architectures.
This is obviously not the forum for discussions on contemporary
software architectures. It always deteriorates into a deluge of
boring and undiscerningposts about how it's nothing new and was
already done back in the day on a S360 with 4K ram and a paper-taper

reader held together with gaffer tape.

https://en.wikipedia.org/wiki/Event-driven_architecture


On 20/06/2022 7:40 pm, Seymour J Metz wrote:
Before MQ there were QTAM and TCAM.



There have been mainframes running real time applications since the

1960s. Air traffic control. Airline reservations. Controlling traffic
lights (UNIVAC, not IBM.) These may not be the best examples, but
they were the first to come to mind, and used off the shelf mainframes.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on

behalf of René Jansen [rene.vincent.jan...@gmail.com]

Sent: Monday, June 20, 2022 5:50 AM
To:IBM-MAIN@LI

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

Isn’t buzzword a buzzword? There’s some irony there. 

> On 20 Jun 2022, at 9:38 pm, Gerhard Adam  wrote:
> 
> discussed as to be non-existent.   This sounds like more marketing hype 
> perpetrated

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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

Thanks. I’ve seen something similar on the ACM 
https://dl.acm.org/doi/pdf/10.1145/1476793.1476796

> On 20 Jun 2022, at 8:51 pm, Joe Monk  wrote:
> 
> https://ntrs.nasa.gov/citations/1969381
> 
> Joe
> 
>> On Mon, Jun 20, 2022 at 7:00 AM David Crayford  wrote:
>> 
>> And yet still nobody seems to have grokked the fundamental differences
>> between online systems and event-driven architectures. This is obviously
>> not the forum for discussions on contemporary software architectures. It
>> always deteriorates into a deluge of boring and undiscerningposts about
>> how it's nothing new and was already done back in the day on a S360 with
>> 4K ram and a paper-taper reader held together with gaffer tape.
>> 
>> https://en.wikipedia.org/wiki/Event-driven_architecture
>> 
>>> On 20/06/2022 7:40 pm, Seymour J Metz wrote:
>>> Before MQ there were QTAM and TCAM.
>> 
>>> 
>>> There have been mainframes running real time applications since the
>> 1960s. Air traffic control. Airline reservations. Controlling traffic
>> lights (UNIVAC, not IBM.) These may not be the best examples, but they were
>> the first to come to mind, and used off the shelf mainframes.
>>> 
>>> 
>>> --
>>> Shmuel (Seymour J.) Metz
>>> http://mason.gmu.edu/~smetz3
>>> 
>>> 
>>> From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on
>> behalf of René Jansen [rene.vincent.jan...@gmail.com]
>>> Sent: Monday, June 20, 2022 5:50 AM
>>> To:IBM-MAIN@LISTSERV.UA.EDU
>>> Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM
>> and AWS
>>> 
>>> You can make that 'about 30 years ago' - time flies while we’re having
>> fun.
>>> 
>>> René.
>>> 
>>>> On 20 Jun 2022, at 09:51, Colin Paice  wrote:
>>>> 
>>>> MQ from IBM developed about 20+ years ago helped get from Batch to real
>>>> time.   You put messages to a queue, and it can run IMS transactions
>>>> (including OTMA),  CICS transactions, or even batch!.  You can put on
>> one
>>>> member in a sysplex and get in another member.
>>>> It has single put, and also publish/subscribe capability.
>>>> 
>>>> Colin
>>>> 
>>> --
>>> For IBM-MAIN subscribe / signoff / archive access instructions,
>>> send email tolists...@listserv.ua.edu  with the message: INFO IBM-MAIN
>>> 
>>> --
>>> For IBM-MAIN subscribe / signoff / archive access instructions,
>>> send email tolists...@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

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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

And yet still nobody seems to have grokked the fundamental differences 
between online systems and event-driven architectures. This is obviously 
not the forum for discussions on contemporary software architectures. It 
always deteriorates into a deluge of boring and undiscerningposts about 
how it's nothing new and was already done back in the day on a S360 with 
4K ram and a paper-taper reader held together with gaffer tape.


https://en.wikipedia.org/wiki/Event-driven_architecture

On 20/06/2022 7:40 pm, Seymour J Metz wrote:

Before MQ there were QTAM and TCAM.




There have been mainframes running real time applications since the 1960s. Air 
traffic control. Airline reservations. Controlling traffic lights (UNIVAC, not 
IBM.) These may not be the best examples, but they were the first to come to 
mind, and used off the shelf mainframes.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
René Jansen [rene.vincent.jan...@gmail.com]
Sent: Monday, June 20, 2022 5:50 AM
To:IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

You can make that 'about 30 years ago' - time flies while we’re having fun.

René.


On 20 Jun 2022, at 09:51, Colin Paice  wrote:

MQ from IBM developed about 20+ years ago helped get from Batch to real
time.   You put messages to a queue, and it can run IMS transactions
(including OTMA),  CICS transactions, or even batch!.  You can put on one
member in a sysplex and get in another member.
It has single put, and also publish/subscribe capability.

Colin


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

--
For IBM-MAIN subscribe / signoff / archive access instructions,
send email tolists...@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: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 7:10 pm, Seymour J Metz wrote:

Whoosh!


Is that the tick shaped thing that goes on the side of Nike sneekers?



There is no "traditional transaction processing"; transaction processing is an 
open ended paradigm. CICS may have it's limitation, but the fact that it has been around 
for half a century should be enough to demolish the belief that mainframe=batch.

The availability of, e.g., REST, on z/OS is not exactly breaking news.


Speaking from experience?



The reference to IFL is because the author of the article seems to believe that 
Linux and mainframe are mutually exclusive, despite the lengthy availability of 
Linux on Z and the lengthy availability of specialty engines to reduce the cost.


Do you have experience with IFL's?





--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 3:24 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 20/06/2022 2:53 am, Seymour J Metz wrote:

Systems like CICS *are* real-time, straight-through, although they can certainly create 
data for later batch processing. The point is that for half a century 
"mainframe" has included a wealth of applications that were not batch, and that 
the point of transactional subsytems was to get away from batch. There may be many valid 
reasons for getting away from a mainframe, but the belief that you need to do so in order 
to get away from batch is insane

You're still missing the point. CICS is a transaction monitor. I'm
talking about real-time, continuous data feeds using middleware like
Kafka as the central nervous system. This is a new concept and very
different to traditional transaction processing + batch. Watch
https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dx_rYEpRrdrA&data=05%7C01%7Csmetz3%40gmu.edu%7C1e7929130b7f4b268fad08da52295fed%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637912635333981942%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=VgGuc7QO%2Bra6fWz851FIGf50geCCSsd3Jw3Jf1raxbs%3D&reserved=0
 which is a microcosm of what
many mainframe sites are doing. Almost every bank that I know of who run
mainframes are doing something similar.



Similarly, the desire to use new APIs that are already available on the 
mainframe does not explain the desire to leave.

What APIs are you referring to?



--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:02 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 20/06/2022 12:38 am, Seymour J Metz wrote:

Keep in mind that the mainframe can only do batch processing, with input from 
cards. It doesn't support anything like CICS, IMS or Sabre..

What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight. In the
case of banking transactions that require inter-bank settlements this
can cause delays of several days. In Australia the government mandated
the NPP (New Payments Platform) which facilities instant payments using
payids, which can be an email address, cellphone numbers etc. The API is
a simple REST API using HTTP
https://secure-web.cisco.com/1sBq5wh7NBIBtcLlnoe7mev6AZm4hzTAbw1IPjJa9kH6InoJ3U_Zwg7o9Mx_hc9VvcqSkO2GzjUCct8uA5cgnRrFTDuTMQtKKkcfMvJDb1lG83vYcBEiuvMNdKd-AF1d2oturWYl8cZaHKzA-Pdj-pyq3tHgfdJ5klsvrizH8LlkD_HYXieEshsP0famNedXtmoeOw5Urs-J_juVmfWlBLkL5DnxoSvjxKXs3irUVXLx3kIeGvCnSoZwaEeOhIw9o54Tm07SLXThtFfQSMhbhzK-GX34THADQG95_2Wf5Wm7VVHzxBSLvNCP4OVR5cUH1Blor-f81GcfMVs_XxpJ2-Z4_b4kClC7HDOWZLKqZGtSoXtnAaIXHkAeq2Pb3Q-S86UNOkXncePZm3DFQsAVpYKVN1zSAt5Hr9wo_ll03r2pE-zuCf5lLvXbyW6SSnZG_/https%3A%2F%2Fnppa.com.au%2Fwp-content%2Fuploads%2F2020%2F10%2FNPP-API-Framework-v4.0-Final.pdf.
It's my understanding that no bank implemented NPP on the mainframe.
   From the presentations I've seen they used CDC to capture writes and
then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.
Back in the day straight-through processing was a pipe dream which is
why we have overnight batch. It's a relic of applications written
decades ago for very different hardware platforms.



It's much better to run Linux than to get an IFL, which can only run batch.

I have no idea what you mean?


Cynical? Moi?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3

_

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 3:51 pm, Colin Paice wrote:

MQ from IBM developed about 20+ years ago helped get from Batch to real
time.   You put messages to a queue, and it can run IMS transactions
(including OTMA),  CICS transactions, or even batch!.  You can put on one
member in a sysplex and get in another member.
It has single put, and also publish/subscribe capability.


Great post. For the use case I'm discussing, which is real-time data 
replication, Kafka will be orders of magnitude more efficient then MQ as 
it uses a pull model while maintaining equivalent HA durability. MQ is 
awesome for mainframe applications that require edge triggered events 
such as CICS transactions. I'm not sure if I would use it in a batch job 
as the middleware for a data mover.  I stumbled across an interesting 
paper from IBM with performance metrics running MQ with zCX as the 
concentrator.  Seems that there may be serious money to be saved with 
this deployment using zCX. I like these sensible, real world scenarios 
as opposed to the usual fluff about running large distributed systems on 
zCX containers.


https://ibm-messaging.github.io/mqperf/MQ%20with%20zCX.pdf



Colin

On Sun, 19 Jun 2022 at 22:27, Joe Monk  wrote:


"What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight."

If you think CICS and IMS are transactional only, youre stuck in the '80s.
As an example, ICCF on VSE uses CICS as the TP Monitor. Tell me that
writing code, storing it in a library, compiling, etc. are not "real-time".

Joe

On Sun, Jun 19, 2022 at 1:03 PM David Crayford
wrote:


On 20/06/2022 12:38 am, Seymour J Metz wrote:

Keep in mind that the mainframe can only do batch processing, with

input

from cards. It doesn't support anything like CICS, IMS or Sabre..

What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight. In the
case of banking transactions that require inter-bank settlements this
can cause delays of several days. In Australia the government mandated
the NPP (New Payments Platform) which facilities instant payments using
payids, which can be an email address, cellphone numbers etc. The API is
a simple REST API using HTTP



https://nppa.com.au/wp-content/uploads/2020/10/NPP-API-Framework-v4.0-Final.pdf
.

It's my understanding that no bank implemented NPP on the mainframe.
  From the presentations I've seen they used CDC to capture writes and
then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.
Back in the day straight-through processing was a pipe dream which is
why we have overnight batch. It's a relic of applications written
decades ago for very different hardware platforms.



It's much better to run Linux than to get an IFL, which can only run

batch.

I have no idea what you mean?


Cynical? Moi?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on

behalf of David Crayford [dcrayf...@gmail.com]

Sent: Sunday, June 19, 2022 2:36 AM
To:IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM

and AWS

On 19/06/2022 5:23 am, Enzo D'Amato wrote:

I also agree, but as a non-insider, I wanted to know what others were

thinking. I also belive that in most cases, the effort spent trying to

get

off the mainframe would be better spent actually fixing the code running

on

it in the first place. Moving around broken code doesn't automatically

fix

it.

It's not just about fixing broken code. If you read the ING CIO's
remarks about why they wanted off the mainframe it's not about the
platform. Nobody denies that mainframes are insanely brilliant hardware
platforms. ING wanted to get rid of batch and move towards an event
driven architecture using pub/sub where they can easily deploy loosely
coupled micro-services to provide cutting edge products. The technology
stacks are built on open source such as Kafka, MongoDB, Cassandra,

NiFi,

Avro etc.  The retail banking industry has been disrupted by fintechs

so

waiting for an overnight batch schedule for settlements is a

competitive

disadvantage.  Cracking open and modernizing 50-60 year old COBOL batch
applications is a VERY heavy lift.



https://secure-web.cisco.com/1GoiNO6FBPSWW0D9FZYVYixer1jsPeSd_xH-wmi6jMOC-onAkZQ4Pkf3c1UMGWbQeEprnkSWa1xGxz4vvn-LF0jVrCFlVVFZKQJ4Jti8nbQ7QchsOxhwNiwluJrdKkQP2nXXHQH2Ut2NNa9VChfVBIDR7Akw4ud6_pIXLAFXO5l73Sv-iLZFNU1MWWnLapWhhCKvytdzs7EJTvNZ2qbU8xwCdBEl1UkUuL-jHHZLk6xJPxAadVRWP1nuLz8i5AZrfvDI8u8rZ0V0DT77_Uvu8klHLbL9xe2qaYi1P6a6mc8r9Aj2joth

Re: Some UNIX file usage questions

[David Crayford]

Python closes files at the end of a with statement scope. It will also 
close the file cleanly if an exception is thrown.  That's what I call KISS!


with open('file_path', 'w') as file:
    file.write('hello world !')


On 20/06/2022 1:47 pm, Peter Sylvester wrote:

Hi,

I remember I did that 25 years ago something like (was actually in 
perl on windows):


  open(path/prefix-current_day_or_so, |O_WRONLY|O_APPEND|)"
  write(..)
  cliose(..)
  fsync(...)

(error treating TDB).

KISS  ?

( If you are paranoiac, use three copies, or else  :-)

Peter
peter.sylvester (a) could


On 19/06/2022 22:35, Farley, Peter x23353 wrote:

Agreed; I did not spell out all the details, silly me.

close(old)
rename(old)
open(new)

Peter




--
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: Some UNIX file usage questions

[David Crayford]

On 20/06/2022 12:08 pm, kekronbekron wrote:

Hey Charles,


I know exactly how to execute a Started Task written in Rexx, and I know most 
of the gotchas.

Could you expand a bit on this please.
I have this compiled REXX called MON3B from IBM, from 2016.
https://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/s390/zos/wlm/MonitorIIIBatch-v1.10.pdf

Is cancelling it the only way to stop it, if the source for the REXX isn't 
available to modify?


If it's written in REXX I very much doubt it's handling operator 
commands. That would require a console handler thread which is waaayyy 
outside the limits of the language. I'm not familar with this product 
and RMF is one of our products.





  - KB

--- Original Message ---
On Sunday, June 19th, 2022 at 10:45 PM, Charles Mills  wrote:



Why not use Python? Good question.


1. I can undoubtedly do it perfectly satisfactorily, and almost certainly more 
quickly, in Rexx (because of the learning curve). I would have trouble 
justifying billing the client for my Python learning time when there is little 
benefit (that I know of -- correct me if I am wrong) for the client who is 
paying the bills.

Why not, then, learn Python on my own time? Don't I want to learn Python? Yes I 
do, but there are only so many hours in a day, and there are other things I 
want to learn more than I do Python. For example, I would rather spend the time 
learning to make the Roman-Jewish fried artichokes that are in the current 
Cooks Illustrated. Learning Python is just not very high on my bucket list. 
It's there, but probably not high enough to ever rise to the top.

2. I know exactly how to execute a Started Task written in Rexx, and I know most of the 
gotchas. In my experience, THAT is the problem with the "new tools" on z/OS. 
What would I have to do to execute a Started Task written in Python? What are the 
gotchas? Heck, what do I have to do to set up any Python environment at all? That is the 
time-consuming issue, and it holds about zero personal gratification for me. I could 
probably learn the Python language pretty readily, and it would be one more notch in my 
belt. Solving the probable gotchas of getting Python to actually do productive work on 
z/OS -- not so much.


it would trivial to serve those reports as a REST API


Neat, but that is not what the client (who is paying the bills) wants. He wants a 
trivial-to-read-on-his-iPhone email in his inbox every morning. Again, it would be nice to have 
"how to write a REST API" in my toolkit, but not nice enough for me to learn it on my own 
time. Frankly, I am in an "I wish I had less work on my plate" mode and I would probably 
rather learn that artichoke recipe than learn to write REST APIs even if I were getting paid for 
the learning time.


use SQLite instead of a file which will significantly simplify writing reports


Not for me, and probably not for the "report" (I am flattering the requirement calling it 
a report -- maybe call it an "alert") that the client wants. And again, a learning curve 
that is difficult to justify.

So I think I will write it in Rexx, with perhaps a little bit of Assembler.

Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Saturday, June 18, 2022 11:43 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 19/06/2022 1:33 am, Paul Gilmartin wrote:


On Sat, 18 Jun 2022 09:51:45 -0700, Charles Mills wrote:


...
I picture writing the started task in Rexx, so I would have to write to a DD
name allocated to the UNIX file (either dynamically or with JCL), not with
"native" C fopen(), fwrite(), etc. Does that change any of the answers?

Why? In Rexx you can "address SYASCALL write ..." instead.


Why REXX? Is it a case of knowing the banjo so you play Stairway to
Heaven in the style of Earl Schruggs?

Why not use IBMs z/OS Python? You can then use SQLite instead of a file
which will significantly simplify writing reports. In fact, it would
trivial to serve those
reports as a REST API and put a nice WebUI on top using a simple
template that supports data tables.

--
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: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 12:10 pm, kekronbekron wrote:

  From the presentations I've seen they used CDC to capture writes and

then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.

Any chance it's available for the public?
I've seen a similar session by Confluent & Nationwide.
Knowing others' implementation stories is super useful.


WestPac (There's 4 in the series)

https://videos.confluent.io/watch/P5up2YQX9QdVMhmYfsXy7Q

Commonwealth Bank. CommBank own Bank West which has a similar 
architecture. I had an interesting chat with one of their architects at 
z meetup and he told me they use Oracle Golden Gate for CDC and Apache 
Cassandra. They also moved some DB2 SQL queries to distributed 
connecting via DDA which can be offloaded to a zIIP, removing a CICS 
transaction. 70% of all CICS transactions were reads which they now 
offload saving big . Mobile banking was killing them!


https://www.confluent.io/kafka-summit-sf18/kafka-in-the-enterprise/

NAB

https://business.nab.com.au/wp-content/uploads/2020/06/new-payments-platform-two-years-on.pdf

Another interesting read is project atom which is a partnership between 
CBA, NAB, WestPac, IBM and the RBA for interoperability of settlements 
using blockchain. Did you know that IBMs motivation to port golang to 
z/OS was so they could port HyperLedger which is written in Go?


https://www.rba.gov.au/payments-and-infrastructure/central-bank-digital-currency/pdf/project-atom-report_2021-12.pdf

I could go on and on. We had a meeting with Confluent and they pretty 
much have to financial services industry wrapped up. One of my team used 
to work for Barclays in the UK and they implemented an EBA almost 10 
years ago. Same with the big US banks.




- KB

--- Original Message ---
On Sunday, June 19th, 2022 at 11:32 PM, David Crayford  
wrote:



On 20/06/2022 12:38 am, Seymour J Metz wrote:


Keep in mind that the mainframe can only do batch processing, with input from 
cards. It doesn't support anything like CICS, IMS or Sabre..


What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight. In the
case of banking transactions that require inter-bank settlements this
can cause delays of several days. In Australia the government mandated
the NPP (New Payments Platform) which facilities instant payments using
payids, which can be an email address, cellphone numbers etc. The API is
a simple REST API using HTTP
https://nppa.com.au/wp-content/uploads/2020/10/NPP-API-Framework-v4.0-Final.pdf.
It's my understanding that no bank implemented NPP on the mainframe.
 From the presentations I've seen they used CDC to capture writes and
then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.
Back in the day straight-through processing was a pipe dream which is
why we have overnight batch. It's a relic of applications written
decades ago for very different hardware platforms.


It's much better to run Linux than to get an IFL, which can only run batch.


I have no idea what you mean?


Cynical? Moi?

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 19/06/2022 5:23 am, Enzo D'Amato wrote:


I also agree, but as a non-insider, I wanted to know what others were thinking. 
I also belive that in most cases, the effort spent trying to get off the 
mainframe would be better spent actually fixing the code running on it in the 
first place. Moving around broken code doesn't automatically fix it.
It's not just about fixing broken code. If you read the ING CIO's
remarks about why they wanted off the mainframe it's not about the
platform. Nobody denies that mainframes are insanely brilliant hardware
platforms. ING wanted to get rid of batch and move towards an event
driven architecture using pub/sub where they can easily deploy loosely
coupled micro-services to provide cutting edge products. The technology
stacks are built on open source such as Kafka, MongoDB, Cassandra, NiFi,
Avro etc. The retail banking industry has been disrupted by fintechs so
waiting for an overnight batch schedule for settlements is a competitive
disadvantage. Cracking open and modernizing 50-60 year old COBOL batch
applications is a VERY heavy lift.

https://secure-web.cisco.com/1GoiNO6FBPSWW0D9FZYVYixer1jsPeSd_xH-wmi6jMOC-onAkZQ4Pkf3c1UMGWbQeEprnkSWa1xGxz4vvn-LF0jVrCFlVVFZKQJ4Jti8nbQ7QchsOxhwNiwluJrdKkQP2nXXHQH2Ut2NNa9VChf

Re: Some UNIX file usage questions

[David Crayford]

You could have learned Python in the time it took you to write this email.

On 20/06/2022 1:15 am, Charles Mills wrote:

Why not use Python? Good question.

1. I can undoubtedly do it perfectly satisfactorily, and almost certainly more 
quickly, in Rexx (because of the learning curve). I would have trouble 
justifying billing the client for my Python learning time when there is little 
benefit (that I know of -- correct me if I am wrong) for the client who is 
paying the bills.

Why not, then, learn Python on my own time? Don't I want to learn Python? Yes I 
do, but there are only so many hours in a day, and there are other things I 
want to learn more than I do Python. For example, I would rather spend the time 
learning to make the Roman-Jewish fried artichokes that are in the current 
Cooks Illustrated. Learning Python is just not very high on my bucket list. 
It's there, but probably not high enough to ever rise to the top.

2. I know exactly how to execute a Started Task written in Rexx, and I know most of the 
gotchas. In my experience, THAT is the problem with the "new tools" on z/OS. 
What would I have to do to execute a Started Task written in Python? What are the 
gotchas? Heck, what do I have to do to set up any Python environment at all? That is the 
time-consuming issue, and it holds about zero personal gratification for me. I could 
probably learn the Python language pretty readily, and it would be one more notch in my 
belt. Solving the probable gotchas of getting Python to actually do productive work on 
z/OS -- not so much.

Not for me, and probably not for the "report" (I am flattering the requirement calling it 
a report -- maybe call it an "alert") that the client wants. And again, a learning curve 
that is difficult to justify.

So I think I will write it in Rexx, with perhaps a little bit of Assembler.


Does your client REALLY want to maintain assembler code? Our company 
policy is not to use assembler for new code due to lack of available 
skills which will only get worse.





Charles


-Original Message-
From: IBM Mainframe Discussion List [mailto:IBM-MAIN@LISTSERV.UA.EDU] On Behalf 
Of David Crayford
Sent: Saturday, June 18, 2022 11:43 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Some UNIX file usage questions

On 19/06/2022 1:33 am, Paul Gilmartin wrote:

On Sat, 18 Jun 2022 09:51:45 -0700, Charles Mills wrote:

 ...
I picture writing the started task in Rexx, so I would have to write to a DD
name allocated to the UNIX file (either dynamically or with JCL), not with
"native" C fopen(), fwrite(), etc. Does that change any of the answers?


Why?  In Rexx you can "address SYASCALL write ..." instead.

Why REXX? Is it a case of knowing the banjo so you play Stairway to
Heaven in the style of Earl Schruggs?

Why not use IBMs z/OS Python? You can then use SQLite instead of a file
which will significantly simplify writing reports. In fact, it would
trivial to serve those
reports as a REST API and put a nice WebUI on top using a simple
template that supports data tables.

--
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: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

Did he say that are are you putting words into his mouth? Either way I don’t 
care. He’s been retired for years so his knowledge of the mainframe is frozen 
in time. If you’re not at the coalface you loose touch. 

> On 20 Jun 2022, at 8:19 am, Bill Johnson 
> <0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:
> 
> Aren’t you the guy who thought Pharmacies weren’t open 24 by 7? Metz is 
> right, if you think the mainframe is a batch machine, you’ve got zero 
> credibility.
> 
> 
> Sent from Yahoo Mail for iPhone
> 
> 
> On Sunday, June 19, 2022, 4:51 PM, David Crayford  wrote:
> 
>> On 20/06/2022 4:21 am, Bill Johnson wrote:
>> Most mainframes store transactions and process in batch? Are you the same 
>> guy who didn’t know pharmacies are open 24 by 7?
> 
> Go and have a nap Bill. And don't forget to take your meds when you wake up.
> 
> 
>> 
>> Sent from Yahoo Mail for iPhone
>> 
>> 
>> On Sunday, June 19, 2022, 2:03 PM, David Crayford  
>> wrote:
>> 
>> On 20/06/2022 12:38 am, Seymour J Metz wrote:
>>> Keep in mind that the mainframe can only do batch processing, with input 
>>> from cards. It doesn't support anything like CICS, IMS or Sabre..
>> What have transactional systems like CICS or IMS got to do with
>> real-time, straight-through processing? Most mainframe transactions
>> store data that is later processed by batch, typically overnight. In the
>> case of banking transactions that require inter-bank settlements this
>> can cause delays of several days. In Australia the government mandated
>> the NPP (New Payments Platform) which facilities instant payments using
>> payids, which can be an email address, cellphone numbers etc. The API is
>> a simple REST API using HTTP
>> https://nppa.com.au/wp-content/uploads/2020/10/NPP-API-Framework-v4.0-Final.pdf.
>> It's my understanding that no bank implemented NPP on the mainframe.
>>   From the presentations I've seen they used CDC to capture writes and
>> then published events to Kafka, which was fanned out to different
>> micro-services to do fraud detection, payments, push notifications etc.
>> Back in the day straight-through processing was a pipe dream which is
>> why we have overnight batch. It's a relic of applications written
>> decades ago for very different hardware platforms.
>> 
>> 
>>> It's much better to run Linux than to get an IFL, which can only run batch.
>> I have no idea what you mean?
>> 
>>> Cynical? Moi?
>>> 
>>> 
>>> --
>>> Shmuel (Seymour J.) Metz
>>> http://mason.gmu.edu/~smetz3
>>> 
>>> 
>>> From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
>>> David Crayford [dcrayf...@gmail.com]
>>> Sent: Sunday, June 19, 2022 2:36 AM
>>> To: IBM-MAIN@LISTSERV.UA.EDU
>>> Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and 
>>> AWS
>>> 
>>> On 19/06/2022 5:23 am, Enzo D'Amato wrote:
>>>> I also agree, but as a non-insider, I wanted to know what others were 
>>>> thinking. I also belive that in most cases, the effort spent trying to get 
>>>> off the mainframe would be better spent actually fixing the code running 
>>>> on it in the first place. Moving around broken code doesn't automatically 
>>>> fix it.
>>> It's not just about fixing broken code. If you read the ING CIO's
>>> remarks about why they wanted off the mainframe it's not about the
>>> platform. Nobody denies that mainframes are insanely brilliant hardware
>>> platforms. ING wanted to get rid of batch and move towards an event
>>> driven architecture using pub/sub where they can easily deploy loosely
>>> coupled micro-services to provide cutting edge products. The technology
>>> stacks are built on open source such as Kafka, MongoDB, Cassandra, NiFi,
>>> Avro etc.  The retail banking industry has been disrupted by fintechs so
>>> waiting for an overnight batch schedule for settlements is a competitive
>>> disadvantage.  Cracking open and modernizing 50-60 year old COBOL batch
>>> applications is a VERY heavy lift.
>>> 
>>> https://secure-web.cisco.com/1GoiNO6FBPSWW0D9FZYVYixer1jsPeSd_xH-wmi6jMOC-onAkZQ4Pkf3c1UMGWbQeEprnkSWa1xGxz4vvn-LF0jVrCFlVVFZKQJ4Jti8nbQ7QchsOxhwNiwluJrdKkQP2nXXHQH2Ut2NNa9VChfVBIDR7Akw4ud6_pIXLAFXO5l73Sv-iLZFNU1MWWnLapWhhCKvytdzs7EJTvNZ2qbU8xwCdBEl1UkUuL-jHHZLk6xJPxAadVRWP1nuLz8i5AZrfvDI8u8rZ0V0DT77_Uvu8klHLbL9xe2qaYi1P6a6mc8r9Aj2jot

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 5:47 am, Joe Monk wrote:

"Please elaborate how IMS TM is anything more than a message queue that
processes transactions."

Youre quibbling about form over substance.


I'm asking you to back up your statement.



As an example, NASA uses message queue processing for spacecraft telemetry.


NASA doesn't use IMS.



Joe



On Sun, Jun 19, 2022 at 4:39 PM David Crayford  wrote:


On 20/06/2022 5:27 am, Joe Monk wrote:

"What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight."

If you think CICS and IMS are transactional only, youre stuck in the

'80s.

I've spent the last 20+ years working on ISV products for IMS and CICS.
Please elaborate how IMS TM is anything more than a message queue that
processes
transactions. If you want to throw IMS Connect into the mix then please
comment as I have in depth knowledge of the architecture as I was on dev
on the
IMS Connect Extensions product.


As an example, ICCF on VSE uses CICS as the TP Monitor. Tell me that
writing code, storing it in a library, compiling, etc. are not

"real-time".
Awesome :/

--
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: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 5:27 am, Joe Monk wrote:

"What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight."

If you think CICS and IMS are transactional only, youre stuck in the '80s.


I've spent the last 20+ years working on ISV products for IMS and CICS. 
Please elaborate how IMS TM is anything more than a message queue that 
processes
transactions. If you want to throw IMS Connect into the mix then please 
comment as I have in depth knowledge of the architecture as I was on dev 
on the

IMS Connect Extensions product.


As an example, ICCF on VSE uses CICS as the TP Monitor. Tell me that
writing code, storing it in a library, compiling, etc. are not "real-time".

Awesome :/

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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 4:21 am, Bill Johnson wrote:

Most mainframes store transactions and process in batch? Are you the same guy 
who didn’t know pharmacies are open 24 by 7?


Go and have a nap Bill. And don't forget to take your meds when you wake up.




Sent from Yahoo Mail for iPhone


On Sunday, June 19, 2022, 2:03 PM, David Crayford  wrote:

On 20/06/2022 12:38 am, Seymour J Metz wrote:

Keep in mind that the mainframe can only do batch processing, with input from 
cards. It doesn't support anything like CICS, IMS or Sabre..

What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight. In the
case of banking transactions that require inter-bank settlements this
can cause delays of several days. In Australia the government mandated
the NPP (New Payments Platform) which facilities instant payments using
payids, which can be an email address, cellphone numbers etc. The API is
a simple REST API using HTTP
https://nppa.com.au/wp-content/uploads/2020/10/NPP-API-Framework-v4.0-Final.pdf.
It's my understanding that no bank implemented NPP on the mainframe.
  From the presentations I've seen they used CDC to capture writes and
then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.
Back in the day straight-through processing was a pipe dream which is
why we have overnight batch. It's a relic of applications written
decades ago for very different hardware platforms.



It's much better to run Linux than to get an IFL, which can only run batch.

I have no idea what you mean?


Cynical? Moi?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 19/06/2022 5:23 am, Enzo D'Amato wrote:

I also agree, but as a non-insider, I wanted to know what others were thinking. 
I also belive that in most cases, the effort spent trying to get off the 
mainframe would be better spent actually fixing the code running on it in the 
first place. Moving around broken code doesn't automatically fix it.

It's not just about fixing broken code. If you read the ING CIO's
remarks about why they wanted off the mainframe it's not about the
platform. Nobody denies that mainframes are insanely brilliant hardware
platforms. ING wanted to get rid of batch and move towards an event
driven architecture using pub/sub where they can easily deploy loosely
coupled micro-services to provide cutting edge products. The technology
stacks are built on open source such as Kafka, MongoDB, Cassandra, NiFi,
Avro etc.  The retail banking industry has been disrupted by fintechs so
waiting for an overnight batch schedule for settlements is a competitive
disadvantage.  Cracking open and modernizing 50-60 year old COBOL batch
applications is a VERY heavy lift.

https://secure-web.cisco.com/1GoiNO6FBPSWW0D9FZYVYixer1jsPeSd_xH-wmi6jMOC-onAkZQ4Pkf3c1UMGWbQeEprnkSWa1xGxz4vvn-LF0jVrCFlVVFZKQJ4Jti8nbQ7QchsOxhwNiwluJrdKkQP2nXXHQH2Ut2NNa9VChfVBIDR7Akw4ud6_pIXLAFXO5l73Sv-iLZFNU1MWWnLapWhhCKvytdzs7EJTvNZ2qbU8xwCdBEl1UkUuL-jHHZLk6xJPxAadVRWP1nuLz8i5AZrfvDI8u8rZ0V0DT77_Uvu8klHLbL9xe2qaYi1P6a6mc8r9Aj2jothGC-CR9cbCgb-JVXupgin9UctH5C_iVMyn_T-9jzZjtNyZDETxb8hXMU-BOuUz89MGu1nniZJ2tvSSN8yh5A6K-_It8fA10UFCfSBhOB0NVkwKL5M8A2BxZ9_e111GnxGK_PAbj0wh5fvU/https%3A%2F%2Fwww.theregister.com%2F2016%2F07%2F01%2Fing_mainframe_strategy%2F
 <- read
the comments section. It's hilarious :)

The doubly whammy is there's a skills crisis slowly unraveling. In the
last year we've had 3 key resources move to 3 day weeks with a view to
retiring. Replacing highly skilled assembler programmers with deep
subsystem knowledge is proving to be difficult. Young people don't want
to learn HLASM as they consider it a dead-end. Their position is "why
invest 3-4 years learning a language that is useless if you move to
another industry?" I can't comment about COBOL application developers.

In 10 years time I expect the mainframe to be alive and kicking and
significantly modernized. The small/medium shops will probably be all
gone. When I first moved to my current town in 1998 there were 25-30
mainframe sites. Now there are 3 and 1 is on life support. One of our
customers re-platformed their CICS/COBOL/Batch applications from a z9 to
a single blade server. It doesn't make any sense financially for a small
site to run a mainframe.
https://secure-web.cisco.com/1-2iTgedz9DPApFopeywjfCeLAkb4kS8D5gFCEDU1FxvGiDWA4ou6pqJyb1d_hBAvGUBtcA89RrAylX3opaG2YEyDaGkIhp

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 2:53 am, Seymour J Metz wrote:

Systems like CICS *are* real-time, straight-through, although they can certainly create 
data for later batch processing. The point is that for half a century 
"mainframe" has included a wealth of applications that were not batch, and that 
the point of transactional subsytems was to get away from batch. There may be many valid 
reasons for getting away from a mainframe, but the belief that you need to do so in order 
to get away from batch is insane


You're still missing the point. CICS is a transaction monitor. I'm 
talking about real-time, continuous data feeds using middleware like 
Kafka as the central nervous system. This is a new concept and very 
different to traditional transaction processing + batch. Watch 
https://www.youtube.com/watch?v=x_rYEpRrdrA which is a microcosm of what 
many mainframe sites are doing. Almost every bank that I know of who run 
mainframes are doing something similar.





Similarly, the desire to use new APIs that are already available on the 
mainframe does not explain the desire to leave.


What APIs are you referring to?




--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:02 PM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 20/06/2022 12:38 am, Seymour J Metz wrote:

Keep in mind that the mainframe can only do batch processing, with input from 
cards. It doesn't support anything like CICS, IMS or Sabre..

What have transactional systems like CICS or IMS got to do with
real-time, straight-through processing? Most mainframe transactions
store data that is later processed by batch, typically overnight. In the
case of banking transactions that require inter-bank settlements this
can cause delays of several days. In Australia the government mandated
the NPP (New Payments Platform) which facilities instant payments using
payids, which can be an email address, cellphone numbers etc. The API is
a simple REST API using HTTP
https://secure-web.cisco.com/1sBq5wh7NBIBtcLlnoe7mev6AZm4hzTAbw1IPjJa9kH6InoJ3U_Zwg7o9Mx_hc9VvcqSkO2GzjUCct8uA5cgnRrFTDuTMQtKKkcfMvJDb1lG83vYcBEiuvMNdKd-AF1d2oturWYl8cZaHKzA-Pdj-pyq3tHgfdJ5klsvrizH8LlkD_HYXieEshsP0famNedXtmoeOw5Urs-J_juVmfWlBLkL5DnxoSvjxKXs3irUVXLx3kIeGvCnSoZwaEeOhIw9o54Tm07SLXThtFfQSMhbhzK-GX34THADQG95_2Wf5Wm7VVHzxBSLvNCP4OVR5cUH1Blor-f81GcfMVs_XxpJ2-Z4_b4kClC7HDOWZLKqZGtSoXtnAaIXHkAeq2Pb3Q-S86UNOkXncePZm3DFQsAVpYKVN1zSAt5Hr9wo_ll03r2pE-zuCf5lLvXbyW6SSnZG_/https%3A%2F%2Fnppa.com.au%2Fwp-content%2Fuploads%2F2020%2F10%2FNPP-API-Framework-v4.0-Final.pdf.
It's my understanding that no bank implemented NPP on the mainframe.
  From the presentations I've seen they used CDC to capture writes and
then published events to Kafka, which was fanned out to different
micro-services to do fraud detection, payments, push notifications etc.
Back in the day straight-through processing was a pipe dream which is
why we have overnight batch. It's a relic of applications written
decades ago for very different hardware platforms.



It's much better to run Linux than to get an IFL, which can only run batch.

I have no idea what you mean?


Cynical? Moi?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 19/06/2022 5:23 am, Enzo D'Amato wrote:

I also agree, but as a non-insider, I wanted to know what others were thinking. 
I also belive that in most cases, the effort spent trying to get off the 
mainframe would be better spent actually fixing the code running on it in the 
first place. Moving around broken code doesn't automatically fix it.

It's not just about fixing broken code. If you read the ING CIO's
remarks about why they wanted off the mainframe it's not about the
platform. Nobody denies that mainframes are insanely brilliant hardware
platforms. ING wanted to get rid of batch and move towards an event
driven architecture using pub/sub where they can easily deploy loosely
coupled micro-services to provide cutting edge products. The technology
stacks are built on open source such as Kafka, MongoDB, Cassandra, NiFi,
Avro etc.  The retail banking industry has been disrupted by fintechs so
waiting for an overnight batch schedule for settlements is a competitive
disadvantage.  Cracking open and modernizing 50-60 year old COBOL batch
applications is a VERY heavy lift.

https://secure-web.cisco.com/1GoiNO6FBPSW

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 20/06/2022 12:38 am, Seymour J Metz wrote:

Keep in mind that the mainframe can only do batch processing, with input from 
cards. It doesn't support anything like CICS, IMS or Sabre..


What have transactional systems like CICS or IMS got to do with 
real-time, straight-through processing? Most mainframe transactions 
store data that is later processed by batch, typically overnight. In the 
case of banking transactions that require inter-bank settlements this 
can cause delays of several days. In Australia the government mandated 
the NPP (New Payments Platform) which facilities instant payments using 
payids, which can be an email address, cellphone numbers etc. The API is 
a simple REST API using HTTP 
https://nppa.com.au/wp-content/uploads/2020/10/NPP-API-Framework-v4.0-Final.pdf. 
It's my understanding that no bank implemented NPP on the mainframe. 
From the presentations I've seen they used CDC to capture writes and 
then published events to Kafka, which was fanned out to different 
micro-services to do fraud detection, payments, push notifications etc. 
Back in the day straight-through processing was a pipe dream which is 
why we have overnight batch. It's a relic of applications written 
decades ago for very different hardware platforms.




It's much better to run Linux than to get an IFL, which can only run batch.


I have no idea what you mean?



Cynical? Moi?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of 
David Crayford [dcrayf...@gmail.com]
Sent: Sunday, June 19, 2022 2:36 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

On 19/06/2022 5:23 am, Enzo D'Amato wrote:

I also agree, but as a non-insider, I wanted to know what others were thinking. 
I also belive that in most cases, the effort spent trying to get off the 
mainframe would be better spent actually fixing the code running on it in the 
first place. Moving around broken code doesn't automatically fix it.

It's not just about fixing broken code. If you read the ING CIO's
remarks about why they wanted off the mainframe it's not about the
platform. Nobody denies that mainframes are insanely brilliant hardware
platforms. ING wanted to get rid of batch and move towards an event
driven architecture using pub/sub where they can easily deploy loosely
coupled micro-services to provide cutting edge products. The technology
stacks are built on open source such as Kafka, MongoDB, Cassandra, NiFi,
Avro etc.  The retail banking industry has been disrupted by fintechs so
waiting for an overnight batch schedule for settlements is a competitive
disadvantage.  Cracking open and modernizing 50-60 year old COBOL batch
applications is a VERY heavy lift.

https://secure-web.cisco.com/1GoiNO6FBPSWW0D9FZYVYixer1jsPeSd_xH-wmi6jMOC-onAkZQ4Pkf3c1UMGWbQeEprnkSWa1xGxz4vvn-LF0jVrCFlVVFZKQJ4Jti8nbQ7QchsOxhwNiwluJrdKkQP2nXXHQH2Ut2NNa9VChfVBIDR7Akw4ud6_pIXLAFXO5l73Sv-iLZFNU1MWWnLapWhhCKvytdzs7EJTvNZ2qbU8xwCdBEl1UkUuL-jHHZLk6xJPxAadVRWP1nuLz8i5AZrfvDI8u8rZ0V0DT77_Uvu8klHLbL9xe2qaYi1P6a6mc8r9Aj2jothGC-CR9cbCgb-JVXupgin9UctH5C_iVMyn_T-9jzZjtNyZDETxb8hXMU-BOuUz89MGu1nniZJ2tvSSN8yh5A6K-_It8fA10UFCfSBhOB0NVkwKL5M8A2BxZ9_e111GnxGK_PAbj0wh5fvU/https%3A%2F%2Fwww.theregister.com%2F2016%2F07%2F01%2Fing_mainframe_strategy%2F
 <- read
the comments section. It's hilarious :)

The doubly whammy is there's a skills crisis slowly unraveling. In the
last year we've had 3 key resources move to 3 day weeks with a view to
retiring. Replacing highly skilled assembler programmers with deep
subsystem knowledge is proving to be difficult. Young people don't want
to learn HLASM as they consider it a dead-end. Their position is "why
invest 3-4 years learning a language that is useless if you move to
another industry?" I can't comment about COBOL application developers.

In 10 years time I expect the mainframe to be alive and kicking and
significantly modernized. The small/medium shops will probably be all
gone. When I first moved to my current town in 1998 there were 25-30
mainframe sites. Now there are 3 and 1 is on life support. One of our
customers re-platformed their CICS/COBOL/Batch applications from a z9 to
a single blade server. It doesn't make any sense financially for a small
site to run a mainframe.
https://secure-web.cisco.com/1-2iTgedz9DPApFopeywjfCeLAkb4kS8D5gFCEDU1FxvGiDWA4ou6pqJyb1d_hBAvGUBtcA89RrAylX3opaG2YEyDaGkIhptpRdukdHvdGOJNKn5bruFlKlnigitV6PrV4n-6zInQkhkJJdSriM40VeYiNOpB8Pg3nTa5E6k6TTIOXSfdaiQOGk1Y6EXL4Xtu-wkeXJmwaPEZljVo3KuwR0K75lrsX8fDe2f2CjcjvfrM3ruLG4na4zrAU_pR4DViMh7bKBhJ35a94VHU7GR4Vh_mXKaYwtbhwnRJWR8gVkvYjmB2CjTOIxJE52bNN1-82_fpYopX-kZQntDkR4OKjvj-b1AV9yXlGQ3A-eGFbtuCb0_1t2R9tgZ5MqgMbzxGQKIf78I2U_xq8a9qYywx3_OgfQwbeMgd8fiatdC5CbUSlphDlQfSDw9sOErejC7z/https%3A%2F%2Fwww.itn

Re: Some UNIX file usage questions

[David Crayford]

On 19/06/2022 1:33 am, Paul Gilmartin wrote:

On Sat, 18 Jun 2022 09:51:45 -0700, Charles Mills wrote:

...
I picture writing the started task in Rexx, so I would have to write to a DD
name allocated to the UNIX file (either dynamically or with JCL), not with
"native" C fopen(), fwrite(), etc. Does that change any of the answers?


Why?  In Rexx you can "address SYASCALL write ..." instead.


Why REXX? Is it a case of knowing the banjo so you play Stairway to 
Heaven in the style of Earl Schruggs?


Why not use IBMs z/OS Python? You can then use SQLite instead of a file 
which will significantly simplify writing reports. In fact, it would 
trivial to serve those
reports as a REST API and put a nice WebUI on top using a simple 
template that supports data tables.




There seems to be a convention where the reporting process rename()s the
log file. The logging process (daemon?) (task?!) continues to write to the
open descriptor until it closes it, conventionally by a SIGHUP(!?) from the
reporting process.  The logger then open( ,O_CREAT + O_APPEND)s a
new instance and the reporting process reports from the renamed one.
No data drops through a timing window
.

o When I wear my MVS hat, I can't grok fork().
o When I wear my UNIX hat, I can't grok ENQ.
o If I put on both hats, my brain overheats.



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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

#x27;s cars are like
cars from 50 years ago. The mainframe is more advanced than any other
platforms. Billions of dollars of investment and patented technologies have
guaranteed its place for decades to come.

  Sure, AWS, Azure, Oracle cloud & numerous others are creating cheap,
unsecured, unreliable, platforms for small businesses, picture storage,
emails, instant messaging, and many other tasks that aren't show stoppers if
they're hacked or down for one of many reasons. As Capital One found out and
lost almost 200 million for the pleasure.

  I enjoy the glee that many of you exude when IBM has what might be
perceived as negative news. I saw the same glee when in the 90's some idiot
said the mainframe would be history circa 2000.


  Sent from Yahoo Mail for iPhone


  On Friday, June 17, 2022, 9:06 AM, zMan  wrote:

  On Fri, Jun 17, 2022 at 5:50 AM David Crayford 
wrote:

  Maybe it's the case that customers don't want to use IBMs cloud. Where I
  live in Australia the big four banks are moving significant chunks of
  their infrastructure to public cloud and have government legislation to
  do so. NAB in particular have been quite aggressive, although like most
  sensible enterprises they have gone down the multi-cloud route with
  Microsoft Azure so they don't have all their eggs in one basket.

  It will be interesting to see if IBM can close the cloud gap. Playing
  catch-up is difficult when competing with behemoths with a decade+ head
  start.


  Indeed. Word from insiders is that since IBM "management" have decided
  cloud is The Answer, folks have started playing games, like attributing
all
  CICS-related revenue as "cloud". Q4 2020, IBM claimed $6.2B in cloud
  revenue on total revenue of $16B. Given that nobody EVER says"cloud" and
  "IBM" in the same sentence in the real world, those numbers are quite
  difficult to believe without this kind of gameplaying.



  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



--
Mike A Schwab, Springfield IL USA
Where do Forest Rangers go to get away from it all?



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

--
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: Some UNIX file usage questions

[David Crayford]

On 19/06/2022 10:18 am, kekronbekron wrote:

Would using DISP=SHR,DSN=xx,FREE=CLOSE in the 15-min writer STC work?
Or just YOLO it like the object storage people, i.e., 1 file for 15 minutes in 
USS.

Or, if you're willing to explore a little, check out NATS.
It's a light-weird 'MQ' of the modern age. NATS CLI should save you from most 
of the setup trouble.
Don't know if it'll work in USS; but since it's Go, you may be able to get it 
going with Open Enterprise SDK for Go.


Yeah, good luck with that. My experience of trying to build Prometheus 
on z/OS was underwhelming. The syscall API is very different to Linux so 
you end up
with a rather large porting effort no dissimilar to C/C++. I abandoned 
it. Stick to the JVM, notwithstanding JNA (which I believe is being 
ported by IBM)


For a lightweight MQ (or Kafka) you can use Redis, which is used as a 
message broker, has pub/sub fanouts and streams similar to Kafka. I 
ported it a a decade ago and it
was made public a couple of years back by one of our Zowe devs when it 
was going to be used for the caching layer in Zowe. I patched it for 
both EBCDIC and enhanced
ASCII and added some z/OS specific features like an MVS STOP command 
handler.


[1] https://github.com/lchudinov/redis


- KB

--- Original Message ---
On Sunday, June 19th, 2022 at 2:35 AM, Paul Gilmartin 
<042bfe9c879d-dmarc-requ...@listserv.ua.edu> wrote:



On Sat, 18 Jun 2022 12:18:12 -0700, Charles Mills wrote:


That's a thought. I had not thought of that. I am REAL familiar with SMF 
including user SMF records. APF authorization is not a problem -- I am the 
master of this universe.

I suspect that mixing MVS and UNIX technologies might embody the worst
characteristics of both. Try doing repeated fwrite() of small records to a
data set with large BLKSIZE while doing "tail -f" from another job.

The KSDS method sounds promising. I'm entirely VSAM-naive.

Thinking further on the idea of a Rexx logger, I don't know that there's a
good way to handle the SIGHUP. And there's still the hazarrd that the
SIGHUP arrives right during the write(). Serialization required. That's
a job for semaphores. I see no Rexx SYSCALL semaphore support.

But the logger itself could rotate the log files itself, daily. And thee 
reporter
could run a few minutes later by crontab; verify that the log has ben
renamed (error handling?) and generate the report. Or the logger itself
could generate the report once daily.

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


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

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 18/06/2022 2:20 am, Bill Johnson wrote:

Here you go. Mainframe jobs you can apply for with JPM.


LOLZ! What's that got to do with anything?



https://www.linkedin.com/jobs/jpmorgan-chase-mainframe-jobs

Be careful however because LinkedIn has some serious scam issues. Likely 
because it’s on the cloud.


If you fear the cloud so much then stop using Yahoo mail, your bank 
cards, entertainment services such as Netflix. Stock up on rations and 
batton down the hatches and bunker down ;)


Do you worry that using a cloud based service like Yahoo mail may 
compromise your cellphone?




https://www.nbcnews.com/news/amp-video/mmvo142340677837






Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:47 PM, David Crayford  wrote:

You may want to change banks

  
https://www.paymentsjournal.com/go-big-or-go-home-jpm-will-spend-up-to-12b-to-get-to-the-cloud/amp/


On 18 Jun 2022, at 01:43, Bill Johnson 
<0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:

What’s the difference between JPM’s mainframe and Capital One’s AWS? Other 
than one is fast, reliable, and secure and the other is not. Both can be 
located anywhere in the world and accessed from anywhere via all kinds of 
devices. Explain the difference. What makes one a cloud and not the other?


Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:36 PM, zMan  wrote:

OK...that was the commonality. Either that or you were suggesting that
"banking transactions" implies cloud.

I saw no "cloud" in anything you listed other than that one bank was
running their stuff in AWS. Viewed through that lens, the question doesn't
even make sense: "Is this thing that IS in the cloud different from this
other thing that's not in the cloud?" Well, yes.


On Fri, Jun 17, 2022 at 1:30 PM Bill Johnson <
0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:

I never said APP = Cloud. I can get my banking transactions anywhere in
the world from JPM wherever their mainframe is located. The exact same
thing I can do with Capital One via AWS. The APPS are just the front end
query mechanism.


Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:22 PM, zMan  wrote:

Correct. App <> cloud.

On Fri, Jun 17, 2022 at 1:04 PM Bill Johnson <
0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:


So if I get my banking transactions by Capital One APP via AWS, that’s
cloud, but if I get those same banking transactions via JP Morgan APP

which

acquires the records via CICS transaction from DB2 that’s not cloud?


Sent from Yahoo Mail for iPhone



On Friday, June 17, 2022, 12:56 PM, zMan  wrote:

I'm highly suspicious of cloud in general, don't get me wrong. But IBM
can't just call CICS "cloud" and expect it to mean anything. Calling a

tail

a leg doesn't make it one: when the rest of the industry says "cloud"

these

days, they don't just mean outsourcing, and definitely don't mean CICS.

And

CICS isn't a synonym for outsourcing in any case.

Actually, if you think of cloud services in terms of HTTPS transactions,
CICS isn't that far off in some ways--but it still isn't the same thing,
more an older, pre-Internet version of something similar. Yes, CICS can
serve web pages; that doesn't make CICS = cloud!

"Mainframe modernization" is a pretty bogus term, nicely loaded: "Hmm, if
mainframe modernization exists, mainframes must be
old-fashioned/obsolete/behind". Wrong, as we know. "Mainframe emulation"

is

closer, only that tends to make us think zPDT, Hercules, et al.; "z/OS
emulation" seems more accurate to me, but isn't the term that folks use,

so

it doesn't help at this point. It's a mess.

But none of this discussion, interesting as it is, relates to the fact

that

IBM claims to have a cloud presence BUT has chosen to host their offering
in AWS. Those two items are pretty hard to reconcile.

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



--
zMan -- "I've got a mainframe and I'm not afraid to use it"

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



--
zMan -- "I've got a mainframe and I&#

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 18/06/2022 2:02 am, Bill Johnson wrote:

Don’t really care. I’ll be retired soon. The first time it gets hacked, and it 
will, Jamie will be facing lawsuits that will make the Capital One payout look 
like pocket change.


JP Morgan Chase already run significant workloads on multi-cloud (AWS, 
Azure and GCP). All banks do. It's where they do fraud detection, 
analytics and providing caching layers for online transactions.




  Oh, and I’ve got dozens of stories about planned “upgrades” that went awry 
over the years.


All platforms suffer outages, Bill. We've flogged this to death already. 
https://lmgtfy.app/?q=mainframe+outagehttps://lmgtfy.app/?q=mainframe+outagehttps://lmgtfy.app/?q=mainframe+outagehttps://lmgtfy.app/?q=mainframe+outagehttps://lmgtfy.app/?q=mainframe+outagehttps://lmgtfy.app/?q=mainframe+outage




I’d bet JPM still runs on a mainframe 10, 20 or more years from now.


I certainly hope so as they're one of our customers! It won't stop them 
trying to get off though. I heard that ING has moved off. It's always 
depressing when a financial services giant leaves the platform.






Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:47 PM, David Crayford  wrote:

You may want to change banks

  
https://www.paymentsjournal.com/go-big-or-go-home-jpm-will-spend-up-to-12b-to-get-to-the-cloud/amp/


On 18 Jun 2022, at 01:43, Bill 
Johnson<0047540adefe-dmarc-requ...@listserv.ua.edu>  wrote:

What’s the difference between JPM’s mainframe and Capital One’s AWS? Other 
than one is fast, reliable, and secure and the other is not. Both can be 
located anywhere in the world and accessed from anywhere via all kinds of 
devices. Explain the difference. What makes one a cloud and not the other?


Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:36 PM, zMan  wrote:

OK...that was the commonality. Either that or you were suggesting that
"banking transactions" implies cloud.

I saw no "cloud" in anything you listed other than that one bank was
running their stuff in AWS. Viewed through that lens, the question doesn't
even make sense: "Is this thing that IS in the cloud different from this
other thing that's not in the cloud?" Well, yes.


On Fri, Jun 17, 2022 at 1:30 PM Bill Johnson <
0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:

I never said APP = Cloud. I can get my banking transactions anywhere in
the world from JPM wherever their mainframe is located. The exact same
thing I can do with Capital One via AWS. The APPS are just the front end
query mechanism.


Sent from Yahoo Mail for iPhone


On Friday, June 17, 2022, 1:22 PM, zMan  wrote:

Correct. App <> cloud.

On Fri, Jun 17, 2022 at 1:04 PM Bill Johnson <
0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:


So if I get my banking transactions by Capital One APP via AWS, that’s
cloud, but if I get those same banking transactions via JP Morgan APP

which

acquires the records via CICS transaction from DB2 that’s not cloud?


Sent from Yahoo Mail for iPhone



On Friday, June 17, 2022, 12:56 PM, zMan  wrote:

I'm highly suspicious of cloud in general, don't get me wrong. But IBM
can't just call CICS "cloud" and expect it to mean anything. Calling a

tail

a leg doesn't make it one: when the rest of the industry says "cloud"

these

days, they don't just mean outsourcing, and definitely don't mean CICS.

And

CICS isn't a synonym for outsourcing in any case.

Actually, if you think of cloud services in terms of HTTPS transactions,
CICS isn't that far off in some ways--but it still isn't the same thing,
more an older, pre-Internet version of something similar. Yes, CICS can
serve web pages; that doesn't make CICS = cloud!

"Mainframe modernization" is a pretty bogus term, nicely loaded: "Hmm, if
mainframe modernization exists, mainframes must be
old-fashioned/obsolete/behind". Wrong, as we know. "Mainframe emulation"

is

closer, only that tends to make us think zPDT, Hercules, et al.; "z/OS
emulation" seems more accurate to me, but isn't the term that folks use,

so

it doesn't help at this point. It's a mess.

But none of this discussion, interesting as it is, relates to the fact

that

IBM claims to have a cloud presence BUT has chosen to host their offering
in AWS. Those two items are pretty hard to reconcile.

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




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



--
zMan -- "I've got a mainframe and I'm

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

You may want to change banks

 
https://www.paymentsjournal.com/go-big-or-go-home-jpm-will-spend-up-to-12b-to-get-to-the-cloud/amp/

> On 18 Jun 2022, at 01:43, Bill Johnson 
> <0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:
> 
> What’s the difference between JPM’s mainframe and Capital One’s AWS? Other 
> than one is fast, reliable, and secure and the other is not. Both can be 
> located anywhere in the world and accessed from anywhere via all kinds of 
> devices. Explain the difference. What makes one a cloud and not the other?
> 
> 
> Sent from Yahoo Mail for iPhone
> 
> 
> On Friday, June 17, 2022, 1:36 PM, zMan  wrote:
> 
> OK...that was the commonality. Either that or you were suggesting that
> "banking transactions" implies cloud.
> 
> I saw no "cloud" in anything you listed other than that one bank was
> running their stuff in AWS. Viewed through that lens, the question doesn't
> even make sense: "Is this thing that IS in the cloud different from this
> other thing that's not in the cloud?" Well, yes.
> 
>> On Fri, Jun 17, 2022 at 1:30 PM Bill Johnson <
>> 0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:
>> 
>> I never said APP = Cloud. I can get my banking transactions anywhere in
>> the world from JPM wherever their mainframe is located. The exact same
>> thing I can do with Capital One via AWS. The APPS are just the front end
>> query mechanism.
>> 
>> 
>> Sent from Yahoo Mail for iPhone
>> 
>> 
>> On Friday, June 17, 2022, 1:22 PM, zMan  wrote:
>> 
>> Correct. App <> cloud.
>> 
>> On Fri, Jun 17, 2022 at 1:04 PM Bill Johnson <
>> 0047540adefe-dmarc-requ...@listserv.ua.edu> wrote:
>> 
>>> So if I get my banking transactions by Capital One APP via AWS, that’s
>>> cloud, but if I get those same banking transactions via JP Morgan APP
>> which
>>> acquires the records via CICS transaction from DB2 that’s not cloud?
>>> 
>>> 
>>> Sent from Yahoo Mail for iPhone
>>> 
>>> 
 On Friday, June 17, 2022, 12:56 PM, zMan  wrote:
>>> 
>>> I'm highly suspicious of cloud in general, don't get me wrong. But IBM
>>> can't just call CICS "cloud" and expect it to mean anything. Calling a
>> tail
>>> a leg doesn't make it one: when the rest of the industry says "cloud"
>> these
>>> days, they don't just mean outsourcing, and definitely don't mean CICS.
>> And
>>> CICS isn't a synonym for outsourcing in any case.
>>> 
>>> Actually, if you think of cloud services in terms of HTTPS transactions,
>>> CICS isn't that far off in some ways--but it still isn't the same thing,
>>> more an older, pre-Internet version of something similar. Yes, CICS can
>>> serve web pages; that doesn't make CICS = cloud!
>>> 
>>> "Mainframe modernization" is a pretty bogus term, nicely loaded: "Hmm, if
>>> mainframe modernization exists, mainframes must be
>>> old-fashioned/obsolete/behind". Wrong, as we know. "Mainframe emulation"
>> is
>>> closer, only that tends to make us think zPDT, Hercules, et al.; "z/OS
>>> emulation" seems more accurate to me, but isn't the term that folks use,
>> so
>>> it doesn't help at this point. It's a mess.
>>> 
>>> But none of this discussion, interesting as it is, relates to the fact
>> that
>>> IBM claims to have a cloud presence BUT has chosen to host their offering
>>> in AWS. Those two items are pretty hard to reconcile.
>>> 
>>> --
>>> 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
>>> 
>> 
>> 
>> --
>> zMan -- "I've got a mainframe and I'm not afraid to use it"
>> 
>> --
>> 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
>> 
> 
> 
> -- 
> zMan -- "I've got a mainframe and I'm not afraid to use it"
> 
> --
> 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 

Re: Modernize Mainframe Applications for Hybrid Cloud with IBM and AWS

[David Crayford]

On 17/06/2022 9:05 pm, zMan wrote:

On Fri, Jun 17, 2022 at 5:50 AM David Crayford  wrote:


Maybe it's the case that customers don't want to use IBMs cloud. Where I
live in Australia the big four banks are moving significant chunks of
their infrastructure to public cloud and have government legislation to
do so. NAB in particular have been quite aggressive, although like most
sensible enterprises they have gone down the multi-cloud route with
Microsoft Azure so they don't have all their eggs in one basket.

It will be interesting to see if IBM can close the cloud gap. Playing
catch-up is difficult when competing with behemoths with a decade+ head
start.


Indeed. Word from insiders is that since IBM "management" have decided
cloud is The Answer, folks have started playing games, like attributing all
CICS-related revenue as "cloud". Q4 2020, IBM claimed $6.2B in cloud
revenue on total revenue of $16B. Given that nobody EVER says"cloud" and
"IBM" in the same sentence in the real world, those numbers are quite
difficult to believe without this kind of gameplaying.


IBM can't compete in the public cloud space. They want to be a player in 
hybrid cloud which is why they acquired Red Hat. OpenShift is a great 
platform for on-prem cloud deployments. The fact that IBM
have ported OpenShift to z/OS is proof of where their mainframe 
resources are being concentrated. It's the tail wagging the dog, a 
containers game now.




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