Tap to unmute
What it Was Like Being a Computer Programmer in 1970s America
Embed
- Published on Mar 6, 2026
- Can you imagine writing code when one dropped deck of punched cards could destroy weeks of work? Dive into the world of 1970s computer programming where developers earned $14-18K annually while working behind glass walls separating them from mainframe computers, punching every line of code onto cardboard cards that keypunch operators verified twice, waiting hours or days for a single program run, and debugging from cryptic hexadecimal printouts-all before terminals revolutionized everything by letting programmers finally see results in real-time instead of tomorrow's queue.
#ComputerHistory #1970sProgramming #PunchCards #MainframeComputing #SoftwareEngineering
The punch cards were ingenious. Tape drives just worked. Mainframes were robust and elegant. They just ran, they were solid as a rock. Things just worked day in and day out. Virtually no down time. You had programmers, engineers, and operators on site that new the system and software like the back of their hand. If there's an issue you didn't have to submit a ticket and wait a week until someone in Bangalore India tries to figure out what happened. You weren't constantly dealing with patches and updates on almost a daily basis, again everything just worked the way it was supposed to, imagine that.
Move out of Windoze (sic) over to Linux and a lot of those problems go away.
I started programming professionally in 1977 but starting in 1973, I worked as a computer operator in a bank. In the summer of 1973 I worked as an operator who worked cross shifts and covered for the other operators who went on vacation, but then in early 1974 I was hired full time and was eventually one of the night shift supervisors. I remember data control, not only did we have punch card input like the telephone bills, but as a bank we processed millions in checks every night into the DDS (Demand Deposit System) system. The reports from the DDS runs went to proofing who made corrections and when it balanced we did the final run. The system was an IBM 370/145 under DOS/VS with foreground and background partitions for jobs and POWER/VS as a print spooler.
So long ago.
If you numbered your cards, dropping a deck was less disastrous - just a bit tedious.
if you didn't sequence number your card deck, you got what you deserved.
@RichardFeist Something I learned the hard way!
There was a good reason why they draw a line across the side of the deck, it could be a life line if shuffled.
That was the first thing you did, before submitting your deck.
We had to put sequence numbers on the back columns 73-80 for data decks.
That brings back nightmare memories of programming in my freshman and sophomore years with punch cards in the early 1970's. It was was such a relief when the college upgraded the computer to use terminals instead.
I always wanted to get to the newer machines, the older black and gray card punches were more difficult to use.
The mainframes would always crash towards the end of each semester and all the programs stored on the terminal would be lost. One of my friends snuck his mother in to help him retype all his programs because none of us could type as fast. I on the other hand only had to make sure the cards stayed dry and in order.
@Carmen-k1u7e I first learned programming on a PDP-10 at Bowdoin College from TTY terminals set up at Deering High School in Portland, Maine. When the system was down for maintenance, we could type our programs on paper tape and when the system came back, just feed the paper tape back.
My university had card readers behind the desk and outside of the desk. I learned that they used slightly different compilers and I had to change the order for a few lines of COBOL code to eliminate bugs.
There was no connection for card input into the mainframe under a student's account. The tasks were simple such as mailing names and addresses and I forget what else. I still have the program cards in a box with my college stuff.
For the first few decades it's junk. Then it turns into memorabilia for *The Antiques Road Show* .
also pdp10 asr33@110baud pdp8 front end decsystem10 os. macro fotran basic mic, teco editor@brianfleury1084
Been there done that. It was a big improvement over the paper tape I started with
My first experience with programming (in college) was with paper tape using old Teletype machines as terminals. Fun times.
i need a wall of blinken lights
This is easy to do! I recommend using a good LED matrix, an Arduino, and a pre-made project. It's fun stuff!
Started professionally in 1978 on an O29 card punch.
Didn't even have that glowing red 2-digit LED display of the 129 to tell you what column you were on, eh? Rough.
I remember using punch cards in college. I had to number the cards just in case they fell out and I lost track of which card was first or second. I also used rubber bands to try to keep them in order. The cards were given to a person and then I waited for the print out to see if the program actually worked the way that I intended.
As late as 1984 I had to do the same as a college student in Brazil. But then I bought a clone of an Apple II clone and did my Basic Software assignment on it (nothing to do with BASIC language). I only saw part of the university DEC System 10 many years later, when it had become a museum piece.
Same for me in the mid-1970s.
Same for me in the late 70's. Basic was on green screen terminals, some areas in the school had them on acoustic coupled modems. Assembly language class was based on IBM 360, but the school had a Burrows computer. They had a simulator program that compiled and ran our programs. You only got two compiles a day. Punch cards with no syntax checking. I almost forgot about the diagonal line across the deck.
As someone born in 1985, I can't imagine doing any of this. You have respect for our parents and grandparents.
It wasn't a hardship because it was the best thing at the time. We just did it without thinking about it. Except for the engineers and scientists whose job it was to make things better and faster.
Part of my university classes used punched cards for programs on an IBM system. My first job involved programs on punched cards on an NCR system. The Cobol compiler on the NCR used the sequence number at the end of the cards: sorting the lines and replacing ones with duplicate numbers. I always thought that the original intended was to add updated lines at the end of the deck and then compile that. The report showed the line replacements and then the full results.
Using the VAX-11 VMS editor on the code was much better than fiddling with cards. Immediately compiling the code and running it on test date was wonderful.
And then all the old Cobol code was replaced by new software that was native to Unix.
I first learned to write code in Algol 60 in 1969. Then Fortran followed by Basic. Card readers were a big improvement over paper tape. I remember having to re-write a whole program for paper tape if there was an error. With card readers we only had to re-write a card or add a card.
you didn't splice n patch? haha
What a trip down memory lane. I remember my first go at programming always had 'Syntax Error' on the listing I picked up each morning. Took me a week to get rid of it.
i remember Fortran, cobal and those damn keypunch machines.
In systems programming class in 1975, my instructor commented that even though our IBM 360/91 would require restarting several times a day, the number of instructions executed flawlessly before crashing was remarkable. "I'll bet your heart misses a beat more often than that" he said. I had to comment, "Yeah, but your heart doesn't take 20 minutes to restart!"
*I just jumped past this misery. I joined a minicomputer company in late 1972 known as MAI which used customized Microdata 1600 systems. Each system had slots for the following functional cards.:*
Components in a refrigerator sized four level rack-mount case:
Top Rack:
one 14 inch 2 megabyte Iomega hard drive with one fixed and one removeable platter
Second Rack Down:
Expansion
Third Rack Down:
Main CPU Logics 20 slot backplane with switch panel:
1 - teletype card
2 - CPU card #1 (control)
3 - CPU card #2 (data)
4 - microcode card using 100 nanosecond fuse-link ROM chips. This gave the CPU it's "personality", such a Fortran compiler or general purpose CPU functions (similar to an Intel 8080 instruction set, which MAI used).
5 - three to eight core memory cards
6 - one hard drive controller and DMA card.
7 - one serial communications card with up to eight UARTS
8 - one parallel printer interface card.
Bottom Rack:
10- huge linear power supply.
External Items:
Consoles:
Hazeltine 1420 to 1500 terminal, later various Lear Siegler VDTs were used.
Printers:
Centronics 132 column dot matrix printer
Data Products 132 column high speed band printer
Operating System Bootup:
activate Main CPU Logics switch panel by toggling switches
- Clock - Reset - Run
This would bootstrap MAI/Basic-Four Business Basic I, or II and up from the hard drive.
You would get a ready prompt and you could start programming in an interactive basic.
Multiple users could be supported depending upon how many consoles were configured and connected and how much core memory was installed.
You had all that already in 1972? It sounds really advanced for its time. I was a wee kid back then but I do remember what was going on because I looked at all the stuff the adults were working on.
I also worked for MAI from 1976-78. Became a proficient BASIC programmer with their training 🙂
@WoodskillsCourses *Is that you Jeremy (Mylod)?*
@DataWaveTaGo No. I am in Canada. Was a MAI FE during that time. They still serviced IBM punched card equipment back then.
@WoodskillsCourses @WoodskillsCourses *That is where I worked, 691 Denison St. (now just an empty lot). I left in 1979 for a position at CTM down the rorad where I designed, developed & got into production the Zeus80 Z80 based desktop computer (which I have to this day). The Zeus80 ran CP/M & MP/M. We sold several which ran Control-C Basic Interpreter Level II (BI-280), which emulated MAI BBII. It could support up to 7 users, each with 48K of RAM and ran faster than the Microdata 1600.*
Started on punched cards and punched tape. However by 1969 I had migrated from punched cards to teletypes, ASR 33 & ASR 35 on Dec 10 mainframe and PDP 8 & 11 mini computers. Then back to punched cards on a L-3055 mainframe we filched from NORAD. By the early 70's everything I did was on a CRT terminal on both minicomputers and mainframes. All of our punched card decks had sequence numbers punched on the right columns so when they got dropped, a simple trip to the card sorter would take care of things.
Card deck, card deck.
Programmers were allowed to carry their own tapes too. And for extreme cases, a disk pack.
I started this way. Due to access restrictions, more time was spent thinking through the code before commissioning card production. Trial-and-error programming wasn't an option. However, back then, besides our own code, we used simple mathematical libraries at best, not complex frameworks. Those who joined later don't know the smell of cards and perforated tapes. These were the days of pioneers.
You must have worked on DEC equipment
@rty1955I started on ODRA 1305 - clone of ICL 1900 made in Poland and MERA 300 minicomputer also made in Poland. In 1989 I was hired as administrator of VAX 750 clone but it used disks and tapes. In 1992 I was hired by DEC.
I know the smell of cards a bit, because those were in abundance during the Soviet period, and were used for small tests in schools.
This was my reality in the 1970s in graduate school and then for 5 or 6 years into the 1980s after I started working. Only in the late 1980s did I get to interactive computing on a microVAX, HP 9000 Model 730, IBM AIX workstation, and PCs.
It was a lot more fun than it is now, I can tell you that.
most things are......i mean everything
earliest machine i used was an eliott 905 ptp in ptp out.
1975 started on the punch cards in a whole floor dedicated to the computer and it's systems. Nothing easy back then.
Me too
There were also minicomputers from DEC in the 1960's and 1970's. Where the single operator / programmer had the machine all to themselves. Such as the PDP-1 (first computer graphics game, Spacewar), PDP-7 (first version of Unix), PDP-9, PDP-11 (where Unix evolved), etc. So this 70's perspective in the video was only for those not fortunate enough to have access to minicomputers.
The story here is a reflection of the glacial pace of acceptance of change by large corporations who'd bought IBM ('cuz no one was ever fired for buying IBM.)
Those minis made in-roads at universities and the such, but were a hard sell to elderly executives wanting stability and prestige.
There are IBM computers, the others are just toys
@rty1955 And that's why billions of smartphones all support RJE to launch their COBOL apps.🤣🤣😆
@rustycherkas8229with 2780 bisync protocol too?
I had to punch cards for most of my computer classes but by the end of 1970 I was already getting paid to program completely online (but not from home, LOL), and there were no cards present on my first full-time job in 1975. But what today's young "software developers" can't imagine is that we had to write thousands of lines of code and seldom had any components or packages beyond a few math functions already written for us.
Vera-FEE mide?
What it Was Like Being a Computer Programmer in 1970s America? More fun than now, I guess.
I am an 80s/90s software dev. But I worked with 70s hardware and I loved that stuff. MicroPDP so sweet
I think more fun than now. While mainframes had been the stuff since the mid-60s, there are a number of other systems. DEC, Data General, Interdata, etc. As for me, I was in the IBM camp using cards and for much of the 70's, but starting using DEC equipment later on. Now it's all PC from DOS to Windws to Linux. You can still play with mainframes if you want to mess with your mind. Look up Hercules/370.
@semuhphori worked at IBM but I’m more on the DEC camp. I run PDP 11 and VMs on emulator SIMH.
1:31 Is this a Mandelbrot set printed over here? 😄
I was born in 1951 and I went to California State University Northridge. I remember the computer center at the University. CSUN in the early 1970s had two CDC 3170 computers. There were two ways to do computer jobs. One method as mentioned in this video was to type the whole program out on punch cards and submit a deck of punch cards to the computer center often in the FORTRAN language. Then the next day pick up the cards and a set of folded paper with the printer results. Then the person would look at their printed results and hope that the program was not rejected due to a syntax error. The other way to use these computers was through the timeshare method. There was a room with a number of Teletype Terminals where you could type in the program and store it on a paper tape. Also you could run the program from the teletype timeshare terminal. If a lot of students were running their programs all at once on the teletype timeshare terminals the system could slow down to a crawl. Things are sure different now. I am typing this comment on a modern Apple Studio Computer in my dining room.
I got really good at COMPASS, the assembly language for those CDC computers.
“the 1970’s code….I really can’t imagine it….its a time and reality of computing I’ve never seen in a museum or on film….the last time I used scantron sheets in my work was during high school testing- university completely skipped it, preferred written responses, also began doing online testing”
Punch cards make the best bookmarks.
Michigan State University, my first computer programing course. Key Punch, Card Reader, submit my deck, wait - monitoring the status board, to find out if my program ran. Sometimes at 3 in the morning, when you could get computer time on the University Mainframe in the Computer Center on campus. Great times. LOL
"Do not fold spindle or mutilate." I did just to see what would happen, and then I was sorely disappointed.
Dick Feller - The Credit Card Song - 1974 - "Stick that up your computerrrr"
What happened?
Sidebar: It's interesting to read about how Herman Hollerith was inspired by the Jacquard loom to invent the Hollerith punch card tabulator to use punched cards of his design to assist with the 1890 census. Episode four of the 1978 "Connections" BBC TV series detailed this.
Fantastic video. Great bit of history, and really interesting.
Pretty good description of how it was "back when." BTW, some of those card punches were 026's, not 029's. I spent many hours on both.
Can we go back there!!
President Trump is working on it. It’s called “make America great again” 😊
The huge panel of blinking lights was the IBM 3660/91 or 95. The fellow with the beard was Dr. John McCarthy creator of LISP and totally unrelated though contemporary to the period.
As someone who programmed computers professionally in the 1970's, I never saw any of this. This video is describing a large, corporate or educational environment, but my world was in microcomputers. These were a different animal entirely, and represented a giant step forward in the field. Punch cards and paper tape were obsolete by 1975, and we never looked back.
My dad was a programmer in the 70s. He would bring home boxes of used punch cards for us to draw on, since they would just get thrown out (no recycling back then).
Same. I used to love that there were different color cards.
I had a similar experience. I remember I was a young child in a daycare centre around 1981 and we used to get tons of these cards coming in and I’d draw on them or use them in various crafts as a toddler! I knew they had something to do with computers but otherwise was too young to understand what they were for. To this day (i’m 48 now) when I see them I think of playing with them as a young child. 😂
@TransCanadaPhil did he work for the province? My dad was in finance at the province downtown in the Norquay building.
@T@TransCanadaPhil oh never mind. Someone else brought them to the daycare then. I thought it was your father.
I started my IT career in the 70s. Better than using the used punch cards for post-it notes was to get the chads out of the bins in the keypunch machines - they made great confetti!
In college the school's IBM 360 ran 24-7 and late at night you could often get 1 hour turnaround. Great (for the time) if you were doing test runs.
I was probably in the last cohort trained on punch cards (at school an even simpler system, mark sense cards, 40 columns, using a pencil to mark the data on the cards, the card readers were no especially reliable), so near the end of that period that they'd stopped renewing the typewriter ribbons on the keypunch machines, so the text at the top of the card was very faint.
Terminals did speed life up a bit, but if you were a low priority user on a time sharing network, well......
I was working for Forest Research on the Canterbury campus using the university mainframe, editing weather data loaded from a somewhat sketchy paper tape output from automated weather stations (not totally weather-proof so the paper tape could get damp, then when it went through the reader layer might stick together or the tension on the reel might tear the tape apart, you get the picture). So there I was with my tiny time slice of the network's attention, some days I could hit a key to edit a dud reading, leave the room and building, get a coffee and return just in time to see my keystroke echo on the screen. Great way to develop paitience.
At Community College in 1980, we had a PRIMOS minicomputer with 5 megabytes disk storage, 5 terminals, a line printer, and an ancient teletype for backup. They taught BASIC, Fortran, and Assembly. This was the school’s entire computer department…
Brings back such wonderful warm memories - I was there (system programmer).
I was a Systems Programmer on large IBM 360's and 370's from 1967 to 1980 for NASA and DOE. The 360's had on site Customer engineers (hardware guys) that had scheduled PM (preventative maintenance) for 2 hours every day. This was often followed by an hour or 2 of RM (remedial maintenance). I wrote mostly in 360 assembler language, modifying the operating system for speed, writing programs to monitor performance and testing or writing support programs for special hardware. We also had to read system dumps (memory dumps) when the operating system crashed to find out what caused it. It was an interesting and exciting time.
I just missed this time period. I first took programming classes on IBM PCs in the mid-80s, thank God.
I remember my batch program not loading properly because of additional hole on a card with a control language statement. Took time to find it 😂
When you worked with a computer the size of a swimming pool you had STATUS
Yes!!! Back then I was a systems programmer and had a pretty cool reputation with the data typists - and with the operators too, because when they couldn’t find the error, they came to us.
My magnetic card that opened the door to the machine room felt like a real treasure.
@bernardodiobosco8268 It was ... "Power. Unlimited Power" ... if you were working in VSE, otherwisa "HASP" .. :D
0:50 Um the air was kept cool and MOIST to prevent static. NOT dry.
It was also for the paper and card handling too as the room had specific humidity requirments
Correct. We used to have paper disc recorders to continuously record temperature and humidity.
I remember the steps of submitting code and getting result in early 1980 .
If I remember correctly, in college in 1983 in my "Introduction to Computing" class we were beyond punch cards but there were only a few computer terminals in the university library where you could enter in your computer code and then run it. I think we were using FORTRAN or maybe it was just BASIC. So you had to wait in this anteroom of the main library for a seat to open up and then it was your turn to sit down and type in your code that you had been writing out by hand. The results printed on a dot matrix printer and you took that printout home because that was what you turned in for class.
I still have a stack of Blank Punch Cards. Unpunched and ready to be used by equipment that no longer exists. Some day I will have to throw them away. The largest program I ever wrote (while in college) using punch cards filled an entire box of blank cards (1000 cards).
You never know, punch cards may make a comeback ;) I had a nice stack of them from my college days too. Through the years they got used up for one thing or another. Grocery lists, a bit of a shim for a striker plate, something to mix a little epoxy on, making paper airplanes to amuse a friend's kids, etc.
Did you ever encounter that dire piece of equipment: the card reader/punch? To get the compiled program output you had to remember to put a bunch of blank cards after the source deck. Oh, the unhappy person who had their source deck after one that was being complied...
Send them to the RI computer museum. We let people punch on cards and take them home as a souvenir
@rty1955I was just at the Rhode Island computer museum last weekend. Great place.
Donate to a computer museum. They will take them.
By the time I got into programming in the 1980s, we were using 3270 "green screen" terminals connecting via VTAM to the mainframe, making programming a million times easier and more accurate.
I was a computer programmer in the 1970s.
What did you work on then?
I was fortunate to experience what those programmers from the 70's went through. I was introduced to Computer Science in my high school back in 1983 when my school happened to have a mini computer still running with punch cards. We programmed in FORTRAN 77 so I sort of have the feel of frustration when a bug itself manifested and we had to figure out the culprit (maybe a misplaced card or wrong punched hole). Within a year or two we were introduced to the first PCs using Basic and build my first game. 😀
I used punched cards for a FORTRAN class in 1980.
Same here. I was a freshman/sophomore in engineering that year.
Air was kept dry to protect from static? I thought dry air increases the risk of static.
correct
By '77, here in the UK, and when I started, we used punched cards for Job Control, and small changes. Largely we had coding forms that were submitted. And a couple of years later, online terminals so we could type and edit code more easily. The external auditors though would come in with their independently created code, and that was all still on case loads of cards. I bought a keyboard like the one at @3:19 in a junk shop at the end of Borehamwood high street, and took it apart, and wired the keys up to my MK14. It had a lovely clicky feel. But yes, not allowed into the computer room for the most part. Two floors above. Later, as a support programmer coming in at 2 in the morning, things were a bit more relaxed, since we needed to be looking at things as they ran and possibly failed.
3:00 We called it 'The Hollerith Room'. Hand our work in and received a box cards a little while later. I still have a box of about 1000 cards of PDP/11 PAL in the attic, safe there, the thought of dropping it gives me chills :-) 10:40 In the late 70's we would put a job in for assembly and linking and it would take maybe 2 hours so we would go down the Pub in the mean time. The number of times we came back and found an ~18" spool of paper tape with a miss punched checksum was really annoying. We thus learnt how to edit punch tape manually with a hole punch and a splicing board. When it was fully tested it would be output on Mylar tape for 'proper use' on an FM1600B at the customer's 'site'.
I never had to code this way but all my professors at university did and I have great respect for those people. They were very professional and put a LOT of thought into their coding. They were not sloppy like today's developers.
My wife was a programmer in the UK in the early 1970s. Trained by IBM she worked for an industrial concern, programming in PL1. The machine was an IBM360/60. The process was exactly as described in this video. All worked well until a new suite of programs blew the magnetic cores that constituted the machine's RAM. The company nearly went down and everything had to be rebuilt from the printouts. Years later, when she began programming in BASIC on a desktop machine, she had to learn the operating system, which had not previously been part of her job as a programmer.
8:40 this looks like 6502 assembly language (well, 65xx). LDA immediate mode is A9, which is what the hex shows. The $1234 loaded is in little endian mode, 34 12. The status register and various other registers are shown. Accumulator. X, Y, etc. ;-)
As an IBM Mainframe programmer during this era, the presentation was all to real.
@WaynoGur .. brings ya back, yes? What work did you do?
I learned to program in the late 70s. Write the code, punch the cards, stack them, take the stack to the card reader, load them with the weight on top hoping the entire stack ran through without a snag then wait, sometimes hours for your printout, only to find out one card had a mistype or you put one in the stack out of order. Those were the days!
I still have my IBM Flowcharting Template and IBM System/360 Assembly Reference Data Card I long ago lost my "drum tab card" for the card punch what an advance when we finally were able to run CMS under VM and program in PL/1 on a System/370 connected via IBM SNA
The year was 1979. IBM 370/168. It was housed in Binghamton NY. My first work study job was in the Academic Computing Center at Buffalo State University running an RJE station with card reader and two continous form printers. Students typed code on punch cards. The 370 processed jobs on a job scheduler and results were sent to the printer. We seperated the printout and dropped it in a slot on a wooden case. Students looked for their name on the printout. Within a year or so monitors were installed and goodbye punch cards. Boy did we have fun back then.
It was much the same in the UK, except that things tended to be a bit smaller. In some installations Assembler wasn't confined to system programming, because COBOL needed too much memory, and memory was expensive.
I started as an operator on an IBM 360/30 in 1970. We were told that the flashing lights on the CPU were mainly for show, though I suspect that engineers would have used some of them to diagnose hardware faults by switching it into single-cycle mode, nudging it from one cycle to the next by pressing a button. Similarly there was an instruction-step mode, which we were very occasionally asked to use to help an assembler programmer with debugging. One set of lights told us the address of the next machine instruction to be executed, and another set showed the contents of the registers.
Two years later I was an assembler programmer at a manufacturing firm, where most of the 360/40 was used to run the factory, leaving only a 24K background partition for batch programs. There was no virtual storage on a 360, so we had to use phase overlaying to limit the amount of code in core in order to leave enough room for the data. Happy days!
0:55: That's an RCA microcomputer MCDS development system if memory serves. Circa 1982, I think.
I'm glad I missed the 70s and started in the 80s.
In the early to mid 80s and in High School I took a vocational course called Data Processing. We learned how to program in Fortran and Cobol and stored the programs on punched cards. We would then take the stack of punch cards and insert them in the compiler. It was a lot of fun. Soon after that I went in the Navy as a Data Processing Technician and worked on Data General and Digital mainframes. Those were certainly different times.
Remember lots of late nights punching cards at the 026 card punches doing ALGOL programming feeding the Univac 1108 🤪
Maybe 50% accurate. Production jobs typically ran overnight. During the day application programmers submitted compile and test jobs.
Once punched, program decks were stored and modified on disk. Typically a test job would update and recompile one or more programs, link them with other programs and run with test data on card, disk or tape.
It was rare for an application program to take down a mainframe - unless it was COLT, a truly dreadfully written application that ran in supervisor mode that would occasionally trigger an interrupt cascade. Somehow banks managed to stay in business running COLT.
System programmers got to solve whatever stumped application programmers who usually couldn't figure out a dump. Configuring, updating and modifying the operating system and managing performance were done by system programmers. Their testing slot was typically around 3-5am after production was completed. I got good at writing test instructions for the operators to perform.
This seems more accurate to the 1960's rather than the 1970's. By the 70's teletype or video terminals were more available to programmers as the speed in productivity was obvious
If you wrote code for mini computers you often had the computer to yourself... including operating it. I only suffered card batch submissions in later college or when working at customer sites for mainframe work.
Diagonal lines on top of the decks, written by fine point sharpies, we're critical to reorganizing dropped decks. After a dropped deck, if you had the pickup skills, you would squat by the deck, studying the patterns thevdeck made, then carefully pick up scattered card groupings in as close to the original order as you could to minimize post pickup sorting. The more times you ran the deck the better you knew how it was supposed to be. You learned the tricks real fast.
This reminds me of a prank some guys in our systems programming department pulled on the data typists.
They told the girls that the punch card sorter could actually sort cards by color. They had a batch of mixed-color punch cards, loaded them into the sorter, hit the button - and boom: all the red cards in one tray, all the blue ones in another… perfectly sorted by color. 😄 Of course, the girls were massively impressed by the wizards next door.
You can probably guess how they pulled that off…
What we would do was to mix up the cards of our classmates. My partner was a lab operator and he would make sure we got our projects processed :D. Good ole Holerith! :D We were on The Sperry Univac 90/25, introduced in 1977. I used to pay checks to type out the decks for us :D
Very nostalgic. I started my IT career as an IBM Operator. Pay wasn't great but, man, did we have fun!
Darned lucky that deck at 4:47 was clamped in tightly!😂
I have done this. Wrote my first Pascal program on Punch Cards , submitted it to the Tech, waited for 2 days to get the results of the Compiled program. Those were the days. IBM 1124 with 64K ram, 10 MB hard disk arrays used to run our entire University, Admissions, Class Schedule, Test Schedules, Tuitions .. everything
I'd go back!
Mid 70s and we got access to IBM's TSO (Time Sharing Option) which was a ponderous CRT terminal that was the death knell of punch cards. You would use ISPF (IBM Structured Programming Facilities) to edit your source code and JCL (Job Control Language) and actually submit your jobs. You could review the output listings using ISPF but, sometimes, you got so familiar with the job/test you were doing running that you could tell by the line count of the job in the output queue.
Why not just use the perforated mylar or paper tape instead so shuffling card accidents couldn't happen?
Um ISPF is the TSO Interactive System Productivity Facility (ISPF). While one typically used it to edit programs (structured or not), it had nothing to do with structured programming. Depending on one’s profile privileges, one could examine console logs, issue console commands among other things, as well as edit, assemble/compile, and link programs.
I remember the time before ISPF was offered as a product, we used the TSO EDIT command to edit datasets. Some of us wrote our own full screen editors using CLIST, but more commonly, we grabbed a full screen editor from the SHARE tapes 🤓.
I graduated with a degree in Industrial Engineering in 1962. I became a "programmer/analyst" at GM in 1965.. In about 1967 I was assigned to code a complicated math program on a 1401 for some engineers. It ran at the rate of one calculation (one input card) per minute. Each time an operator ran the job for the first time job he would think the card reader had jammed. I suspect that these days, on a pretty good PC, the same calculation would be done before the return key popped back up.
I'm surprised that the video didn't mention that the punch card (Hollerith card) predates actual computers by nearly a century. They were invented by Herman Hollerith as a way of tabulating the 1880 US Census. His company built machines to punch, store, read and tabulate the information on the cards (which were patterned after the dollar bill at the time, since machines already existed to process paper money). Since the cards were adopted by businesses to store and process data, the company became "International Business Machines." They were, without knowing it, developing all the peripherals for a CPU that wouldn't exist for decades.
In college we would lose points for each compile after the second. Debugging was done by hand and in our heads, in the commons, with the smell of cigarettes doused in Coke cans lingering in the air and lighter wheel tracks worn in to the wooden booth table tops. And of course we didn't worry about 4-digit years (we were intentionally taught NOT to code for four-digit years)! Why? "No company would still be using our COBOL programs 30-years in the future! And if they are... they deserve what they get!"
I miss the "blinkenlights"
That is how I learned back in 1977. And I had never typed before. So many mistakes ...
One of the card punches I used could be set to automatically put numbers in the right-hand columns, so if you dropped the bunch they could be sorted back into sequence. I only needed this once, but it was about a hundred cards! I recall putting chads back into holes to make quick corrections: but the reader had to be optical, not mechanical for that to work.
Which card punch was that? I worked on ALL the IBM kepunches as well as a Honeywell. None of them had autoincrement counters in them
@rty1955 As a retired systems programmer, I recall that the IBM 129 (not sure about the 029) keypunch could indeed be programmed to auto increment and punch sequence numbers on cards.
Oh man, those were the days. As a systems programmer in those days I completely enjoyed the life style. We were the giants of the data center and enjoyed considerable power. You do know IBM had terminals and the software to drive them. IBM VM/370 was even a cooler environment to work in.
I wrote COBOL programs on punch cards. I was so glad when they got rid of those things, they such a PITA. IBM 360/370 OS/VS2 for the win! 😀
06:30. William Henry (“Bill”) Gates the third, looks about 14.
07:27 Douglas C. Englebart in 1968 showing the interactive future.
11:27 John McCarthy doing important early AI work.
SOC7 - I wrote COBOL for a few years to make a living. I remember well those days... submit a batch job and wait and wait pressing refresh on the input queue display and worse waiting for a tape(!) to be mounted. Or running a CICS application under development and the operations guys tell you your transaction is looping in the test environment. I quit that and got work writing C on early IBM PC's, what joy!
Haha you worked on OS or MVS
I kept on getting SOC4s IMS/VS DL1 😀
@ronaldlee3537yes those code were an oscilloscope or MVS addendum codes. In Dos/use we call them Data exceptions or protection exceptions. If you look on the Green or yellow card, they are listed under program exceptions. An exception was something thay should not occur and the opersti9n system will cancel your job if it detects an exception. Is and MVS was so weird
This actually quite accurate. I started 1972 taking care of the printouts. Then operator, job planner, cobol progammer, systems programmer, assembler programmer, DB admin, security officer. 4th gl developer. CTO and consultant. I worked in Sweden Norway, Netherlands and US. Those were the days😊
Heck, guys I predate punch cards. We had shared the mainframe between schools in the district vis phone coupler on a Teletype. That said, our programs were stored on 1” punched hole paper tape that could be reloaded through a tape reader. I remember carrying around a slotted tray with a bunch of paper tapes rolled up with rubber bands. Make one code mistake, a new paper tape needed to be created. Felt real nerdy back in the 70’s. Spent an entire career in IT from the 80’s on. CAD to Desktop to Servers to Networks. Got to live it all! Good times. 😃
We did what was needed to get the job done, and didn't think twice about it. It was a great experience - except waiting for jobs to be processed.
I knew a guy that was pissed with HP so he threw the switch on the HP3000. The whole company stood still for a day.
The cards dropping problem is probably undecidable: what is the probability that the cards stack of a working program still is some working program after the cards get all mixed up?
I had to go get my printout from the bin. Everyone looked through everyone’s outputs like postcards to find theirs. LP = Line Printer. LF = Line Feed. ;-)
Ah! The good old days of programming.
3:05 What is "verifee mode"?
During my studies in the 80s I worked at my university on a Siemens mainframe with punched cards. One day I was going to submit some little calculation program but tripped entering the room and dropped my stack of cards. The employee told me that I would have lots to do because the sorting machine for punched cards was out of order. This meant sorting a big stack of cards by hand. In the future I walked very carefully while carrying cards...
It was harder to learn it. Once you did, much easier to get the job with a doctor-and-lawyer income.
Yeah. I had a couple buddies that went the electrical engineering route while I went comp sci. They struggled and sweated their way through nasty math while to me the comp sci curriculum was, while also far from easy, much more enjoyable - it was all like solving puzzles. And the pay was a fair bit better too.
I *just* missed the punch-card era. I got started programming in the late '70s, and terminals were taking over. Minicomputers were becoming more powerful, and thus more popular. Then the personal-computer revolution hit, and we were off to the races.