Sharing new stuff?

[Ron Hudson]

Hi mainframe people,

I have been working on a non-full screen Fortran "Simple Star Trek"
program...

It is almost done.

What is the best/accepted/common way to publish a large body of code?

Many things seem to come as JCL file and tape image.

Currently I am compiling from my own fortran PDS to my own loadlib (.load)
pds.


Ron.

[kerravon86]

Post by Ron Hudson
What is the best/accepted/common way to publish a
large body of code?

If you wish to distribute a large/involved product,
then XMIT is the normal method (and used by SHARE).
GCCMVS is an example of that too.

For what you have, I would be more likely to just
zip up the source code and compile JCL and leave
it at that. People can compile it themselves if
they want, and if there is sufficient demand, it
could be added to TK. (I would do this as ASCII).

Or I would create an M4 file in order to produce a
single JCL deck with the code inline, and distribute
the JCL file. (ASCII too)

Another option would be the same thing that was
used for initobj - use .rvl for the load module.
(ASCII zip file, but the rvl is a binary file)

For a huge distribution, DFDSS is a possibility
too. That's what I used for SEASIK. (DFDSS dump
is EBCDIC, but zipped up with an ASCII readme).
We have a DFDSS clone - DSSDUMP.

BFN. Paul.

[Ron Hudson]

Post by kerravon86

Post by Ron Hudson
What is the best/accepted/common way to publish a
large body of code?

If you wish to distribute a large/involved product,
then XMIT is the normal method (and used by SHARE).
GCCMVS is an example of that too.

I guess XMIT is something I have to install.

Post by kerravon86
For what you have, I would be more likely to just
zip up the source code and compile JCL and leave
it at that. People can compile it themselves if
they want, and if there is sufficient demand, it
could be added to TK. (I would do this as ASCII).

Actually it's a single fortran source file, I even included
the random number generator as a bunch of comments
for those who aren't set up with a SYS2.FORTLIB

: ^ )

How do I create a tape with just that source on it?
Or dump it to "Cards"?

Right now I can "Print" it, I have the JCL to take
a random FB80 member of a PDS to the printer.

Post by kerravon86
Or I would create an M4 file in order to produce a
single JCL deck with the code inline, and distribute
the JCL file. (ASCII too)
huh? what is this M4 you speak of?

(The linux pre-processsor?)

Post by kerravon86
Another option would be the same thing that was
used for initobj - use .rvl for the load module.
(ASCII zip file, but the rvl is a binary file)
For a huge distribution, DFDSS is a possibility
too. That's what I used for SEASIK. (DFDSS dump
is EBCDIC, but zipped up with an ASCII readme).
We have a DFDSS clone - DSSDUMP.
BFN. Paul.

[Gerhard Postpischil]

Post by Ron Hudson
What is the best/accepted/common way to publish a large body of code?

How large?

For moderate sized source distributions, use IND$FILE to
transfer the module to the PC (in binary mode), zip it up, and
upload that. Note that the archive may contain multiple files,
e.g., you might include a README.TXT ASCII file informing the
user what to do with the rest of the package.

For larger distributions, one frequent method is to create a
tape with multiple files, one an IEBCOPY unload for the source
PDS, another for the load module PDS. The tape should be in AWS
or HET format, then zipped. The zip won't gain much space, if
any, but will flag most transmission errors on an unzip. User
must allocate space for the libraries and run IEBCOPY to restore
them (sample JCL in your README helps).

Another method is to use ADRDSSU to dump files to tape, but that
has some drawbacks. Another method, if your libraries are on a
separate pack, is just to zip up the PC file of that Hercules
volume and ship that.

Gerhard Postpischil
Bradford, VT

[Ron Hudson]

Post by Gerhard Postpischil

Post by Ron Hudson
What is the best/accepted/common way to publish a large body of code?

How large?
Perhaps this is not big by some standards - I wouldn't want to re-type it..

667 lines of Fortran code (But there are many comments)
and I have not finished yet I can think of another 20 - 35 lines to
add, there is a help command.

[Andreas F. Geissbuehler]

... one frequent method is to create a tape with multiple files,
one an IEBCOPY unload for the source PDS, another for the
load module PDS.

I'd like to add: If your source library is a PDS with RECFM=FB
LRECL=80 BLKSIZE=3120 then you can add all (sample-)JCL,
a $README and all other 'data' which isn't FB-80 format to it.
Otherwise create a new 'RON.GAME.DATA' FB/80/3120 PDS
and add all else to it as if it where 'source code'. Lastly you XMIT
or IEBCOPY-Unload just that one PDS containing card-image,
load modules and all other 'data' which isn't FB-80.

The trick is to IEBCOPY-Unload or XMIT the LOADLIB directly
into your 'RON.GAME.DATA' distribution library / PDS, e.g. have
IEBCOPY or XMIT write the unloaded LOADLIB to:
//OUT DD DSN=RON.GAME.DATA(#LOADLI B),DISP=OLD

I did this about a year ago on a client's z/OS 1.9 system and believe
I did the same a very long time ago on some earlier MVS.

Andreas F. Geissbuehler
AFG Consultants Inc.
http://www.afgc-inc.com/

[Rick Fochtman]

--------------------------------<snip>-----------------------------

Post by Ron Hudson
Hi mainframe people,
I have been working on a non-full screen Fortran "Simple Star Trek"
program...
It is almost done.
What is the best/accepted/common way to publish a large body of code?
Many things seem to come as JCL file and tape image.
Currently I am compiling from my own fortran PDS to my own loadlib
(.load) pds.
Ron.

------------------------------<unsnip>------------------------------
Ron, without XMIT/RECEIVE capabilities, here's what I'd do:

1. Point the Hercules 00D unit at a PC file.

2. Use IEBGENER to send your source and JCL to SYSOUT=B

3. Issue the Operator command "$spun1" to "punch" the source into the PC
file designated by 00D. When complete, issue the command "$ppun1".

4. On your PC, build a README.TXT file that describes this process.

5. ZIP the file from 00D and insert the README.TXT file into the archive
as well.

Did you get the JCL file(s) I sent you previously? I sent directions for
you to load those files into MVS and those directions should be included
in the README.TXT file as well.

You can use this same methodology for any card-image file. IND$FILE is a
fairly old mechanism but it works REASONABLY well. But it olny handles a
sequential file, not a PDS. To find out if you have it, on the TSO
command prompt, type "IND$FILE" and hit enter. You'll get either a NOT
FOUND message, meaning you don't have it, or some other form of error
message, indicating that it's present but that you improperly invoked
it. Most tn3270 clients have facilities for doing the file transfer if
IND$FILE is present.

Rick <mailto:hudson.ra-***@public.gmane.org?subject=Sharing%20new%20stuff?>
<mailto:turnkey-mvs-***@public.gmane.org?subject=Sharing%20new%20stuff?>

[e.sorichetti]

Post by Rick Fochtman
--------------------------------<snip>-----------------------------

Post by Ron Hudson
Hi mainframe people,
I have been working on a non-full screen Fortran "Simple Star Trek"
program...
It is almost done.
What is the best/accepted/common way to publish a large body of code?
Many things seem to come as JCL file and tape image.
Currently I am compiling from my own fortran PDS to my own loadlib
(.load) pds.
Ron.

OR ....
dasdpdsu for PDS
dasdcat for PS

regards
enrico