Do you remember...

I know that most here are years younger than I, but I also know there are a few grey beards here to. How many remember:

an IBM Green Card (nothing to do with immigration) the System/360 reference card, although in later years they were yellow but everybody still called them Green Cards,

Getting a “Core Dump”, and actually being able to interpret it and find the problem.

a SOC7 - data exception.

writing code on coding sheets and giving them to a keypunch operator to punch into 80 column cards.

Feeling lucky when you got more than a couple of test runs each day.

things have changed a little bit…

an IBM Green Card (nothing to do with immigration) the System/360 reference card, although in later years they were yellow but everybody still called them Green Cards,
---- YES

Getting a “Core Dump”, and actually being able to interpret it and find the problem.
---- YES

a SOC7 - data exception.
---- OH YES

writing code on coding sheets and giving them to a keypunch operator to punch into 80 column cards.
---- Uh No,… I had to punch them myself… and hope you didn’t mis-type or start the card over

Feeling lucky when you got more than a couple of test runs each day.
— a Couple? I felt lucky to get ONE!

Talking with my dad recently, he emphasized the point of “BATCH” computing: the lower level scientists would submit their “batch jobs” and if they crashed, get a report the next morning which they could take back to their labs and try to figure out, and resubmit the edited punch cards to the computer center in the next day (if they were lucky).

My dad was one of the folks that worked with the mainframe 24/7 and could submit their jobs and get the crash report, edit, and re-submit their batch jobs within an hour.

This was in the mid/late 1960s.

I was a bit later… mid 1970’s here …
A couple of us would hang around with the night-shift computer operator (the guy that submitted all those jobs). One night I asked one of the group to teach me FORTRAN… He handed me an 8" thick manual and said do it yourself… So I did. The very first FORTRAN program I wrote actually played Chess… It wasn’t very good (it figured the possible legal moves and choose one, not always the best one). The problem was, in addition to the cards that made up the program, each run required 65 “data” cards. 64 described the current state of the board, and one was “my” move. The output was the state of the board AFTER the computer move, and its move (the output cards were used as the input for the next run). Needless to say it took hours to play one game, and boxes of cards… I think we ran one game, and I won… cards were not “cheap”

This is the only one I can say yes to, strings was my friend.

Otherwise, I was coding just after punch cards etc (although working with those that had used them and wish they hadn’t), and was mainly using DEC or Sun boxes rather than IBM.

Yes: http://www.cmas-net.org.uk/vintage/Ref-Cards/IBM-System360-Ref-Data.pdf

Yes: http://www.cmas-net.org.uk/vintage/CodingForms/FortranCodingForm-1965.pdf

…though I never actually used this process as we had a couple of these card punches…

Yes

Just a little :slight_smile:

In the early '70s I was working in the Data Control section of the Computer Department. They had an IBM/360 but I wasn’t involved with the operations much but I can add one more group of equipment to remember. I was actually wiring plugboards for card sorters, collators, and punches.

an IBM Green Card (nothing to do with immigration) the System/360 reference card, although in later years they were yellow but everybody still called them Green Cards,
No

Getting a “Core Dump”
I was programming by the late '70s but on Univac systems. Actually found a few OS bugs going through core dumps

a SOC7 - data exception.
No

writing code on coding sheets and giving them to a keypunch operator to punch into 80 column cards.
For a few months. Our terminals for the Univac system took a long time to come in.
Small department so it was easier to get multiple runs.

Age test 40+:

And YES, my 1st personal computer had a datasette built in.

Much less than 40 and I know what to do with a pencil and a cassette tape :stuck_out_tongue:

at my age, I know I used these things, but just can’t remember what they were used for.

The beauty of getting old… Once you forget, everything is new again.

I still have 2 of the old green cards, well one is actually yellow as well as the 2311 DASD reference card that helped you calculate block size and access times.

For you young whipper-snappers, DASD is Direct Assess Storage Device - a disc drive.

The IBM 2311 was a whopping 7.25 Megabytes…

I remember the first “mini-computer” I used… a Wang 2200B… it had a dual platter hard disk (1 platter was removable). It used BOTH sides of each platter… the disk was like 18" in diameter… and it held a TOTAL (all 4 surfaces combined) of ONE (1) megabyte.
But when compared to the 4K (yes K) of RAM, we were in heaven.

FYI… SC07 was basically a “datatype mismatch” error… non numerical characters in a numerical storage location

Everyone talking about DASD, and mainframe error codes like they are history, but I still deal with them today.

[quote=329861:@Robert Lawrence]Everyone talking about DASD, and mainframe error codes like they are history, but I still deal with them today.

[/quote]
Ah the old 3270… knew it well… at one time I was an expert in TSO/JCL/Rexx (is Rexx still alive?)

I worked on one of the earliest Datapoint computers (mid-late 70s). It was really an ingenious design. I liked it so much I bought shares in the company which was a BIG deal for me then. My wife and I were young and didn’t have any money to spare.

About a year later, it came out that they were cooking the books on the sales figures. The stock tanked and they eventually went out of business.

an IBM Green Card (nothing to do with immigration) the System/360 reference card, although in later years they were yellow but everybody still called them Green Cards,
---- Still have my last one in a filing cabinet in my computer room here at home

Getting a “Core Dump”, and actually being able to interpret it and find the problem.
---- Used core dumps on a project that I did off the books for work. We had an IBM VM mainframe running our in-house time sharing system with a programming language called CPS (Converstional Programming System) . Each department had their own library where their files that they wrote were stored. Unfortunately IBM allowed a user to only print out a single program at a time. Being the main support person for the system I decided to try and write a program in PL/I that could open a given library, find each program and convert the reverse Polish notation format the programs were stored in back to the readable code that you would see when sitting at the 3270 working on the program. This would allow printing out all of the programs with one run. Since this was off the books I did all the development at home. I created a testing library. During the day I would write a simple program consisting of all variations of a single command and then take a core dump of that library home with me that night and figure out how those statements were stored in to the library. Took me 9 months but it was worth it. One of the most challenging programs I ever worked on, and one of the most fun and most rewarding. The System/360 reference card came in very handy at the start of this. Also helped me to really get a good grasp of features in PL/I that I had not used previously. A big one was overlay defining of memory.

a SOC7 - data exception.
---- Can’t remember this one for sure but most likely did somewhere along the line

writing code on coding sheets and giving them to a keypunch operator to punch into 80 column cards.
----Yup, and learned early on to be sure to fill in the sort field punches for those times where you dropped the deck and did not have a rubber band around it to keep the cards from going every which way.

Feeling lucky when you got more than a couple of test runs each day.
— Yup, in those early days you were a happy camper if you got more than one run a day. Then along came TSO and testing was so much faster for many projects

OK; so it’s a pissing contest…
My first experience with computing (I’m 67) was with Fortran (was a student)
My program (on punch cards with rubber bands) was not compiling
How comes you’re making this kind of mistake a friend told me!
Then I understood and became a programmer (kind of)
Then AppleSoft on Apple ][ with some asm for too slow subroutines
Some programing on TRS-80 (Radio-Shack); good BASIC
But the DEC-10 BASIC was better
Then Pascal on brand new Macintosh 128K (Inside Mac) then Mac SE30 then MacIIcx then MacIIci (first 32bit) then PowerMac G4
MacPascal then Symantec Think Pascal
Then Apple decided that Pascal was not good enough
Then 68000 or 68030 then PowerPC then Intel
Then came C then C++ then Objective C then What’s the name again… Swift?
Forget all you knew before (change your machine, your development environment (CodeWarrior), your minded
My Psycho sister call that “psycho-rigidity”… Am I sick Doctor?
Sigh!
Switch to VB for a while
Still on mac (Mac mini); Next machine, not sure
Current environment: xojo (of course; I was a RealBasic registered developer 10 years ago); gcc; SQLite; Oracle Spatial (Locator actually (it’s free))
oh… Remember those unreadable anymore Dynatek RMD-45;
By chance, I made a copy on a HD (and on CD and on a USB key); should I trust the cloud?
jjc_Mtl

an IBM Green Card (nothing to do with immigration) the System/360 reference card, although in later years they were yellow but everybody still called them Green Cards,
Yes

Getting a “Core Dump”, and actually being able to interpret it and find the problem.
a SOC7 - data exception.

No and No

High school fortran class.
I don’t remember the machine, but all we got were reports
with pages of success results or compile errors.

writing code on coding sheets and giving them to a keypunch operator to punch into 80 column cards.
Punched them all myself.

Feeling lucky when you got more than a couple of test runs each day.
Being generous (sneaky) I volunteered to take to cards to the local community college each evening,
so I could re-punch any of my errors on-site and re-run until success.
I would also separate each of the students reports and wrap them around their cards for the next class.
Waiting for my re-run, I would sometimes highlight any obvious mistakes on their report for them.
They re-punched their own cards.

Over 100 runs, I never dropped the card box.

Speaking of dropping punched cards, did anyone else here work with the BLEEP 96-column cards for a System/3? When you hold a handful of 80col there’s only one way for them to go - outward. with the square 96col the could go outward, leftward or rightward.

I HATED those things…