Posted
by
Unknown Lameron Wednesday April 30, 2014 @12:22PM
from the could-have-had-a-lisp-machine dept.

theodp (442580) writes "Simon Allardice takes a stroll down coding memory lane, recalling that when he got started in programming in 1983, hand-writing one's programs with pencil on IBM coding sheets was still considered good enough for British government work (COBOL, Assembler forms). Allardice writes, 'And when you were finished handwriting a section of code — perhaps a full program, perhaps a subroutine — you'd gather these sheets together (carefully numbered in sequence, of course) and send them along to the folks in the data entry department. They'd type it in. And the next day you'd get a report to find out if it compiled or not. Let me say that again: the next day you could find out if your code compiled or not.' So, does anyone have 'fond' memories of computer programming in the punched card era? And for you young'uns, what do you suppose your C++ or Java development times would be like if you got one compile a day?"
The other way you could program in 1983.

We started with two languages. One was APL\360 which was interactive and fast for debugging. The other was FORTRAN IV on punched cards, which was an overnight batch sort of thing. I still think APL was far better, once you could wrap your head around the mathematical details it entailed. With APL, it was always better and faster (in programmer time and processor time) to work in parallel with array operations than to break them into loops of scalar operations like you'd have to do with FORTRAN..

The punched card era ended for me in 1975, when I started working on Data General Nova minicomputers at Computervision. But I spend more than a decade before that with cards and keypunch machines. I never let anyone else punch in my programs, as I usually found some errors when I typed them in myself. Card decks weren't dropped often and it wasn't that big a deal. Dropping a deck is not an effective way to shuffle it. I'm more nervous about my online source files being munged by accident. The overnight or 24 hour turnaround was common, but possible to work around. I spend many nights after mid-night at the MIT computer center in the late 1960s, when hour or even half hour turnarounds were possible. One spent the time waiting socializing or helping others find their bugs. During summer jobs at NASA MSC, I found a Honeywell 316 that wasn't being used much and could get time on it all to myself when needed. In the early 1970s my employer had an IBM 1130 and we took turns using it, so turnaround was not an issue there, though it could be when software was to be installed at a client. Finding ways to get around obstacles in your path was a valuable skill then as now.

Actually, Data General had a line of card punch and reader machines (I think they were OEM'ed, though) in the late 70s. I know because I was DG Field Engineer and had to work on those during election cycles. That's why I knew what "hanging-chad" was very early in the 2000 election fru-fru.

I took a Fortran class at Virginia Tech in 1983 that used punch cards. And you couldn't run your own jobs, so it was literally the same as "one compile a day" described in the article. Drop off your deck and come back the next morning to find you had a syntax error on card 2...

It was especially depressing since I'd been writing BASIC on an Apple ][ for years. It was probably one of the last classes that used punch cards.

Hey, I took that class! The professor graded you on how many runs it took you to make your program work, which he could do as all your runs had to go through him: One or two runs an A, three runs a B, four runs a C...

Me too. But that was the 1970s, not the 80s. Using punch cards in 1983 was idiotic.

Similar story here too, but my experience was not idiotic at all. We only had to use punch cards for the first homework project in the Intro to CS class. The instructor said it would help us understand why many things are the way they are, and we would have a ready supply of bookmarks for years to come. Do I need to mention that bookmarks were once pieces of paper that one stuck in a paper book?:-)

Me too. But that was the 1970s, not the 80s. Using punch cards in 1983 was idiotic.

It was about 1983 that we first began to get terminals and go to online text editing, although I'd worked on a TTY-based minicomputer in college. Before that, 3 compiles a day was a VERY good day. Even after, printouts were only dumped in the bins every couple of hours and since those 3270 terminals were expensive you had to sign up for one.

One of the largest shops in town had union keypunchers, so programmers there couldn't actually keyboard anything. I don't know how long it took for them to go interactiv

1979-1980. Punched cards. CDC 7600. If one was lucky one could get time on one of the Decwriters and work interactively. Getting paper before someone stole your seat was another story. Pair programming became popular for that reason.

I was going to say this too.. though it might be more accurate to call it the twilight of punched cards. The transition to using DTE was pretty close to complete though availability of terminals in some cases would see fall back to cards. Cards continued to be used for data in the business world a bit longer.

And that Brit example does sound a bit elitist. Certainly academically you could punch up your code and toss it to the operators as much as you wanted and it would be run as other jobs permitted.

Depends on location and means. I took some programming classes at a NC public university in 1983 where we used punch cards for FORTRAN 77 programs which were batched and sent to the mainframe in Chapel Hiill for overnight processing. One job/run per day was normal. It paid to be a careful programmer.

Nope. I was Computer Science in the School of Science and we used terminals, except for the first homework assignment in the Intro to CS class. They wanted us to have used punched cards once to help us better understand why some things are the way they are. However in the Computer Information Systems program in the School of Business they were still using punch cards for regular classwork in most classes. They only got to use terminals in some upper division classes.

Punch cards were still being used as late as 1984...probably not much longer.

I grew up in the era of punch-cards (1970's). My mother was a key-punch operator and was responsible for translating the handwritten code from the programmers as well as customer data into punched card format. It was also how and when I learned to program - I was in 4th grade and had an interest in computers. A programmer (and, department head) took interest in helping me learn. He would spend a little time with me each week t

True. But things were still pretty basic in the 1980's. On PCs compiling and linking (memory overlays anyone?) could take forever. There was a "conspiracy theory" that compiler/linker suppliers were secretly owned by coffee companies!:-)

We still used them in 83 where I was. We had to code by hand on coding forms, then we had to make our own punch cards on IBM Model 29s. The target system, an IBM 360, had a tempermental card reader that would sometimes spew the cards all over the place. Gathering them up and resorting them was a real treat. But we did get to see if it compiled on the spot. Whether it gave the desired output, well that was another matter.

There was a day at the end of the term when the students in a chemical engineering course (10.something) coming back over the Harvard Bridge would take the rubber bands off the stacks and stacks of punch cards accumulated while writing FORTRAN programs for the course and toss them off the bridge. There was usually a stiff breeze and the results were satisfying.

I took an introductory version of that course. Punch a hundred cards out on the big old typewriter workstation thing. Take the stack to the computer window. Come back next day for the wide printout. Unfold and see all the fucking errors. Repeat. Repeat. Repeat. All failures separated by a day or a weekend.

I was at UMASS/Amherst in the 70s. I did the card deck thing for the first couple of assignments. Then I realized that the Teletype terminal in my room (yes, I was a true nerd...had my own Teletype) was connected to the very same computer that the cards were fed into. Why, I thought, couldn't I type the card images into a file from my terminal, then submit *that* as a job? Yup. Worked perfectly. I never punched another card.

Not that long ago, back in the 90's I worked on a project for Macintosh (not called MacOS yet) that had a minimal compile time of 12 minutes on the highest end Mac at the time (a Quadra something or other loaded to the max with RAM) and that's assuming you change one or two source files and not touch headers. Touching a header file forced a full compile and that would be 45 minutes. We ended up scheduling our compiles so that we could all play fooseball or something. Coming back to a failed compile sucked h

If that was a header that everything else did in fact need then things were no different on PCs. I did cross platform work targeting PCs and Macs in the 90s. Macs usually had a slight advantage for disk based activities since they had SCSI drives at that time.

I worked on a DEC20 (god rest its blessed soul) in the early 80s and while we were all terminaled out, I would from time to time send my code to the card punch or paper tape just to annoy the operators who were still busy handling cards for the CDC Cyber.

Another downside I think is that when you had to use cards (or the code base was large and compiles were very slow) you put a bit more thought into the code you were submitting and probably checked it a bit more thoroughly before trying to run it.

When waiting for a compile, we had to make proper flowcharts for operations manual, maintenance manual, and also the prammers manual, the latter having the source code. When there was a change to any program, all needed to be updated and approved before the change was put into place. Although a compile a day seemed leisurely, there was more time for code review and complaince. I think biggest issue is the lack of code review needed. Now, people are more interested in their train of thought to correct errors

A build a day isn't so bad when everything you are using is fully and truly documented (with source). Nowadays, a lot of debugging involves figuring out what the libraries (and sometimes the OS) are actually doing that isn't documented so you can work around them.

When waiting for a compile, we had to make proper flowcharts for operations manual, maintenance manual, and also the prammers manual, the latter having the source code. When there was a change to any program, all needed to be updated and approved before the change was put into place. Although a compile a day seemed leisurely, there was more time for code review and complaince. I think biggest issue is the lack of code review needed. Now, people are more interested in their train of thought to correct errors from compiler that they do not slow down and think about what they are coding. Code reason why there are so many bugs and security holes. People need to slow down and do all the other required steps to ensure quality code.

Agreed. Instant Gratification killed a lot of the quality-adding aspects of programming and what it didn't kill, the Ctrl-Alt-Delete method of problem solving did. At the time, resources were expensive and the cost of manpower was relatively cheap, so the programmers were allowed to be "inefficient". Now, the developers are the most expensive part of the system, we no longer work 40-hour 5-day weeks, and pre-compile code reviews, documentation and other "time-wasters" are not generally tolerated. After all,

I remember my first assembly class when we toggled in our initial few programs directly at the front panel of a PDP-11. (Not even really assembly at that point but direct machine instructions.) The paddle switches were in colored groups of three leading to the only really use for octal I have ever encountered: you could get very fast at reading octal and setting the switches with your index/middle/ring fingers.

Of course, the vast majority of people doing programming in 1983 didn't do any of this. If you count everyone who was entering any code (from "Hello World" on up), the vast majority of programmers were working on 8-bit microcomputers that didn't require jumping through any such hoops. If you had a Commodore 64, you could get a basic test program working in less than a minute:

10 PRINT"HELLO WORLD"20 GOTO 10RUN

Then once you figured that out you could learn about variables, figure out how to write to the screen RAM, and eventually figure out sprites. And then once you figured out that interpreted BASIC at 1 MHz wasn't fast enough to do a decent arcade game, you'd move on to assembly. I'd wager a majority of the people programming today learned in an environment like this. Edsger Dijkstra and other academic computer scientists hated BASIC, which they thought taught bad habits and caused brain damage, but they were wrong. It was this kind of hacker culture that created the flourishing IT industry we have today, not the dead-end bureaucracy represented by Thatcherite Britain.

I started with basic way back when I was a kid (I'm 30 now; some would say I'm still a child, but now I'm a child with arthritis and acid reflux:P), probably around 8 years old, plugging in BASIC games that I found in 321 Contact magazines. While I look at BASIC now and think, "Ugh, who would use that language", it did at least help me learn the basics of math and variables when it comes to programming, and by the time I hit college I already covered the Intro to C++ course myself quite some time before.

Yeah, and I ran across part of the explanation in an earlier form that's really similar: In high school, I took several years of German and French. The teachers all commented that most of the students wrote and (occasionally;-) spoke those languages with English word order, and were obviously doing word-at-a-time translation; I was one of the few who quickly adopted non-English phrasing from these languages and sounded more like a native speaker.

the new generation of hobbyists were working on 8-bit microcomputers that didn't require jumping through any such hoops.

FTFY.

While I agree that the PC revolution was indeed a revolution that led to todays' environment, it certainly was not a "vast majority" in 1983. You didn't run a company's accounting or payroll, or design integrated chips, or CAD-CAM, or you-name-it on 8-bit computers in '83. Took a little longer than that.

There's a reason that today's Windows kernel is designed after VMS, and that Linux, Mac OSX, iOS, and Android are all based on Unix designs. It's because that is the world the big kids programmed in,

Of course, the vast majority of people doing programming in 1983 didn't do any of this. If you count everyone who was entering any code (from "Hello World" on up), the vast majority of programmers were working on 8-bit microcomputers that didn't require jumping through any such hoops. If you had a Commodore 64, you could get a basic test program working in less than a minute:

10 PRINT"HELLO WORLD"20 GOTO 10RUN

Then once you figured that out you could learn about variables, figure out how to write to the screen RAM, and eventually figure out sprites. And then once you figured out that interpreted BASIC at 1 MHz wasn't fast enough to do a decent arcade game, you'd move on to assembly. I'd wager a majority of the people programming today learned in an environment like this. Edsger Dijkstra and other academic computer scientists hated BASIC, which they thought taught bad habits and caused brain damage, but they were wrong. It was this kind of hacker culture that created the flourishing IT industry we have today, not the dead-end bureaucracy represented by Thatcherite Britain.

Quoting another post to get past the damn filter.

Then once you figured that out you could learn about variables, figure out how to write to the screen RAM, and eventually figure out sprites. And then once you figured out that interpreted BASIC at 1 MHz wasn't fast enough to do a decent arcade game, you'd move on to assembly. I'd wager a majority of the people programming today learned in an environment like this. Edsger Dijkstra and other academic computer scientists hated BASIC, which they thought taught b

Two days? TWO? We would submit our cards and then wait for the lesson THE NEXT WEEK to find out if the program had compiled. To be fair, it did encourage one to try be a very, very careful programmer. The rest of you are all whippersnappers by the way.

Every Sunday, we had to get up at 11 oclock at night, half an hour before we went to bed,Hike it down to the quarry. Mine rock slabs with our bare hands,then break our backs chiselling marks of 1s and 0s in the stone,Drag the stone cards down to the beach before sunrise, where an endless sea of tiny sand crabs would scuttle over the tablets, some of them settling into the depressions of the marks.Then one of us on each side of the beach would wave our arms up and down and startle the crabs in just such a wa

In 1972 at Adelaide University, we got 4-hour turn-around on our card decks. Half the time (at least), we got a print-out from the line printer which had two pages of octal dump centred on the location where the program bombed. So we could edit the cards and re-submit them a few times a day. We got 2-hour turn-around if we were on good terms with the girl who loaded the card batches into the reader. One good thing about the old 80-column IBM hollerith cards is that they were the best book-marks in the world

My first programs were on punched cards at U.C. Berkeley in 1968. As a student I punched the cards myself. The serious programmers, like me, would stay up all night so we could get our results back in only an hour or two. Results came as 11 by 14 blue striped paper wrapped around the original deck of cards.

Ah, I miss punched cards! They were the perfect size to fit into your breast pocket. One side was blank to write notes on; the other side had column numbers and digit numbers: columns 1-80, digits 0-9. T

Though I was primarily a SYSOP for our internal mini mainframe, I also coded for other sections. To do so we connected using dumb terminals via 300baud to a Boeing datacenter and paid for connection as well as processor time. While it was government work, Reagan was just starting to take money away from the agencies, so we were encouraged to compile and run as little as possible.

Meanwhile, by 1983 there were a couple of COBOL packages for the Atari 800, a machine I happened to have at home. So I'd code on that, allowing me to compile, link, and execute, all in real time!! Every bit of my submitted code was fully tested. The downside was that I had to print it out and then type it back into those fucking dumb terminals where the occasional typo might slip in.

Prior to that I had the misfortune of batch programming on punchcards, dropping off decks of cards to pick up a day or two later with greenbar printouts full of the most obnoxious fatal errors.

I won't run down the whole story, but my last company had a completely horrible, 100% custom, python based build system for a very large product that contained hundreds of subparts. Despite that - or perhaps because of it - I was able to easily get all the active code running from an eclipse instance, meaning that testing a code change usually required no more than republishing to an eclipse tomcat instance. You could pull the previous day's changes from all the other devs and in about a minute or two, ha

That was my first computer in 1979 (British Government). Not only was coding (COBOL) done on coding sheets, but you hand drew flow diagrams first before you started coding. When complete you sent the code off to be punched (onto cards) and compiled. Frustratingly the source code was only stored once one got one's first 'clean' compile. Before then one got the listing back (with compiler errors) along with the punched cards, and one had to replace the incorrect punch cards by hand. If I remember rightly, the

School, circa 1974. Sending off your sheets and hoping that the keypunch operators didn't get 0's and O's confused. O's were slashed, or perhaps it was the other way round. Getting your job back on music ruled paper the next week

University. There were teletypes that you could use to get access to the ICL mainframe, but for exams you had to use punched cards, and only got 3 goes to compile and run your program. There were always queues for the big punch machines, so if you just needed one card doing, you cou

My first gig out of college was for the same University I graduated from, and I worked on a mainframe doing COBOL programming, and some scripting in a proprietary language called NATURAL which I've never seen used anywhere else, ever.

One project I was handed was to update the 1098-T form. It's basically the IRS tax form for tuition writeoffs. Every year we had to produce a 1098-T form for every student which basically detailed what they paid in tuition. Every year the form was a little different (of course)

My college, in 1980, was running a Honeywell Level 2 GCOS mainframe. It had 208k of memory, and could run up to four concurrent tasks. The workstation I'm writing this post on has about 82,000 times the memory as that old beast, which physically approximated a large fridge laying on its side. The removable disk drives were sized like washing machines, had five 14-inch platters, and held 80k.

I took some Cobol courses, using keypunch machines and Hollerith punch cards. When assignments were due, you'd oft

When I moved into programming, I was allowed into the datacenter after 5PM after bosses and coworkers were no longer around to complain and could submit my own decks and retreive my own reports.
Two finger keypunching the code revisions was also de rigeur. I sure miss the steel forms ruler I was given after helping out after hours one night. Thankfully I still have my Green card (it is yellow) carefully re-inforeced with scotch tape (this was before duct tape became wildly popular amongst the geek set).
Eye

The system required a blue "ticket card" to do anything other than list your card deck. We were issued a supply of
ticket cards, and could (and did) buy more at the campus bookstore.
We punched our cards ourselves. We were very careful to write everything out, to walk through our programs to make sure the program was
syntactically correct and might have a chance of doing what it was supposed to do before spending a ticket card to find out

I am pretty sure I was at the same institution as you 3 years later, and the blue "computer money" card system was still in place. We figured out a couple of hacks to it, however. One was you could re-use the computer money punch card on the faculty/administrative mainframe after using it on the student mainframe, so you could double your money (CPU time used) if you happened to know a student who'd had a summer job using the other system, not that any of us knew anyone like that of course.

You keypunched, submitted, and picked up yourself. Rates were like 1/3 during night hours, so you got more bang for your buck working overnight. They'd give you like $500 funny money for class homeowrk or a research project. This might be 2 day hours or 6 night hours. A compile and small test run might consume five computer minutes. The final project runs would use most of the time.

We got a lab mini-computer with CRT terminals around 1976 and ended this pain.

Sometimes your printout came back a hundred pages thick when you were expecting ten. IBM computers would print the contents of all registers and core memory when "ABnormal END" occurred. You could sometimes diagnose your problem from this. I think you bypass this with a proper JCL/DDL command.

that took 36 hours to compile. We alwaya ran it on mondayd.SO:Arrive: 8:00Meeting 8:15 to 8:30Start compile 8:35Take long lunches, and have long nerd discussions.Weds. Morning, review log.Thurs-Fri Make fixes.

We could have had another system and done other work for 3k a pop, but no. It was too expensive.

I started in 1968 at Michigan State with punch cards on a CDC 6000 mainframe, a big one, all of 65K words of memory (60 bits per word but still, that was considered big back then). As a student I was guaranteed 1 run per day and yes, even after eyeballing my programs carefully I lost many days of work due to missplaced punctuation. It's amazing what you can get used to when you have no choice.

I remember my excitement when I was able to move to a research account from a student one. Research accounts could get as many runs as the system could turn around, typically around 4-5 per day - nirvanna! Of course, the research runs weren't guranteed so when the system got backed up (some physics professor tying up the machine for hours or down time due to HW failures) the student jobs got priority and your research job came back whenever they could get to it. I waited 2-3 days for a job more than once.

Back to punch cards, my favorite technique was something I saw one of the FORTRAN programmers do. The technique used the fact that you could put a line number on any card and it was possible to put multiple statements on the same card. This guy ended every single card with a goto statement to the next card in the deck. As he said, the operators could drop his deck, shuffle the cards and his program would still work properly. (We really didn't like or trust the operators back then.)

The summer of 1978, I spend some time to convert a large Fortran program in the IBM dialect to Fortran on a Cyber mainframe. The program consisted of about 1500 punch cards. At first I would load the whole deck every time. After some time, I discovered it was possible to store the program on disk and edit them by-line using a program called Update. This still requires typing punch cards. Everytime, I checked the cards many times to make sure, I did not make any mistakes. And then it was waiting before the m

I did Intro Computing CS 301 under Prof Mahabala in IBM 350/155 using punch cards, in 1980. Very few of the punching machines had working ribbons and working print modules. So most of our cards did not have the line printed on the top. They can only be read by a machine, some of us learned to decode the holes pencil in the character on top. We get one run a day. Undergrads are limited to six pages of 132 char fan fold computer paper per job.

When I was a grad student at Bell Labs in 1983, a senior programmer told me about how she first programmed, when the labs were in New York City. She would write her program VERY carefully, punch the cards, put them in her briefcase, and fly to Washington, D.C. where she had access to a computer. She would give the deck to the attendant, wait a few minutes, receive her output, go back to the airport, and fly back to New York.

Wow. You do know that terminals and PCs where common in 1983. Great way to make work.

Yes, '83 was well into the "time share" era (remember "computer terminals"?), with minicomputers and Personal Computers also around, but the PC not yet ubiquitous (in '83, that would have been the IBM 5150-- still sold, back then, mostly to homes, not businesses). If the British Government was still doing hand-written code punched in by "data entry" workers, it's because of inertia, not because that was state of the art.

Yes but they were expensive.A B&W Dumb Terminal could cost about a grand, A PC would be about 2 grand.When a company bought a computer back then, they didn't plan for a 4 year life cycle, but because these systems cost millions of dollars, they planed for 10+ years of usage out of it.

Secondly there wasn't much trust in the computer, and most programs were not meant to be fancy UI but straight number crunching. So a lot of the work was done by had as to have a paper backup.That said these old programs were smaller, and had less flaws, because they were so carefully done.

In 1979 I worked at a Fortune 200 company with a couple of IBM 370s. In our computer programming department, about 20 programmers shared 2 3270 terminals. You could hand-write coding sheets to have it keypunched, but turn-around was a day or two. Dumps & snapsdumps were common debugging tools.

You might be underestimating the cost of a PC. I bought my first PC in 1982 and it came out to almost exactly $3000. That *was* upgraded a bit -- it had *two* floppy drives and they were double sided. *And* I upgraded the memory to 256K, and got a CGA card and an amber monitor.

I was still using punch cards in school (FORTRAN and PASCAL) as of 1978, but turnaround was much faster than overnight. It seldom took more than two or three hours to run my several hundred millisecond program.

I started as a freshman in Computer Science in 1981 and we had to use punched cards for the first semester. We had an IBM 4341 and started off in Watfive (the successor to Watfor, Waterloo Fortran). They had IBM 3277s and later 3278 terminals, but the intro class didn't get to use them until the next year; I was right at the tail end. Once again, when I got my first job in 1986 I had to use punched cards for 6 months until my Secret clearance came in because until I was cleared I couldn't log on. My boss ju

The IBM PC was introduced in 1981. You couldn't do much with it, certainly not much related to mainframe programming. They were very expensive for what they did. Minicomputers existed, but they also didn't cross over mainframe territory.

People with heavy data processing requirements were mostly using DOS/VSE on S/370 and 4300 mainframes. No timesharing in DOS. It was still extremely common in industry to have people sitting with coding forms that were then passed to data preparation teams for punching. I've sat with teams painstakingly writing DOS JCL onto coding sheets.

If you were a larger user that could justify the investment in MVS, you could potentially use the Time Sharing Option, an interactive environment with a reputation for being cumbersome and inefficient - you'd only extend the "luxury "of using it to a comparatively few select people.

Computer time was also extremely expensive. Cambridge University wrote their own version of timesharing (http://en.wikipedia.org/wiki/Phoenix_%28computer%29) for their (early) S/370 in order to support a larger number of users and time on it was still so restricted that usage was "priced" to reflect demand at different times of day and CS students would either have to work at 3am or make extensive use of cards or other offline data entry to get their projects completed within the allocated budget.

Whereas there were minicomputers and early personal computers around, they were scarcely to be seen in what was still the predominant environment of the computer industry - the (IBM) mainframe shop.

Actually, the British government tended to prefer homegrown procurement and more of its staff were likely to be working with George 3 (http://en.wikipedia.org/wiki/GEORGE_%28operating_system%29), which had a far better interactive environment than IBM offered.

You needed enough "cheap" memory to hold 5x7 raster character set in permanent memory (ROM). That would be five bytes per printing character or 360 bytes at minimum. Thats three 1K ROM chips. New memory generations started at $50 - $100 per chip, then falling to about $5 once they became commodity. So terminals became "commercial" at about $1000 where a third of that was memory. This would be about $5000 in 2014 prices.

I remember one of the clever thing about the Apple II three years after that was u

People with heavy data processing requirements were mostly using DOS/VSE on S/370 and 4300 mainframes. No timesharing in DOS. It was still extremely common in industry to have people sitting with coding forms that were then passed to data preparation teams for punching. I've sat with teams painstakingly writing DOS JCL onto coding sheets.

If you were a larger user that could justify the investment in MVS, you could potentially use the Time Sharing Option, an interactive environment with a reputation for being cumbersome and inefficient - you'd only extend the "luxury "of using it to a comparatively few select people.

You didn't need MVS to do time sharing. 4300 series IBM mainframes ran VM/CMS which wasn't as hefty as MVS, true, but it could support many users.

Wow. You do know that terminals and PCs where common in 1983. Great way to make work....

Yeah, outside of government and corporate environments they were becoming common. I think the main point of this story is that in those environments, access to computers was still done via paper, with the DP department's priesthood the only only ones allowed to actually touch the computing equipment.

In 1982, I had some interesting experiences as a computer "consultant" to a big American company that I won't name (because they considered themselves among the highest of high-tech at the time). Their comp

In 1987, university budgets and aged professors made for an experience that was not much faster. PCs were a precious resource. Grad students got PC AT clones (286s) and undergrads sometimes got the use of an old PC XT clone.

But at least one old professor didn't believe in PCs, so for his classes students shared an IBM mainframe (a 3090 as I recall) with admin. We had green screen terminals, but results were printed and the printout placed in 1 of 100 pigeonholes, according to the last 2 digits of your SSN. Admin had 2 levels of priority on mere students. The system increased the priority of an unrun job every 3 hours, so between 8 AM and 5PM, it took 6 hours for us to get back the results of a job run. After hours, performance was on the whole much better, but could still vary. Might get a result in a few minutes, or might still have to wait an hour or more. Couldn't continue working after midnight. University budgets dictated that computer labs had to close for the night. Each dorm had 2 or 3 terminals available all night long, but there you couldn't get back any printouts. You didn't want any evening classes, as that cut into the best times to use the mainframe. Weekends were good, if you didn't mind giving up the best times for a little leisure.

I had a job as late as 1994 writing programs for company with an old IBM System/38. The AS/400 that IBM would sell to replace it was one they considered useful for up to about 15 concurrent users. We had 200-300 on our System/38. I would send a 4000 line RPG program to be compiled to the queue at 9 am and it would finish at about 4 pm. The three other programmers and my boss were all in the same boat. We tried to make the case to even get a tiny 15k dev AS/400 box, which would have an ROI in less than 5 mo

I think you learn more effectively that way though. It's not really all that hard to sit down with a cpu reference and a pen and some paper and write out a program by hand, checking your work at each step, and wind up with a working program written in longhand hexidecimal. It's time consuming, of course, but it's really not all that hard if you focus and spend the time.

The biggest thing is just mindset and expectation. If it's your mindset to just spew something rough out and then start debugging it, that's what you will do (and you will produce a lot of bugs, only some of which will have to be fixed in order to compile.) You will probably learn less and more slowly, though.

Although I would never want to return to the old days, one thing "high turnaround time" environments do is force developers to carefully desk check their code before compiling it. In this process, most developers (including myself) would find logic errors that testing would probably never find (even very obscure race conditions).

Now, far too many developers skip this step (and code reviews are too superficial) because it seems to get the project "done" faster while in high turnaround time environments skipp

Well, there were coping mechanisms. I did mainframe programming in the 90s where an assembler job took hours in the queue - so two-a-day. We just fixed simple bugs directly with a disk sector editor (no butterflies required), in parallel to the source fix, and moved on to the next bug. Once things looked good, or your day's patches became too tangled to progress, you submitted your assembler job.

Then you moved to your other project. That's the key, you know. We were productive because we'd just do 2-3