Computers were programmed by punching holes into paper (Seriously) | Punch Card Programming

I knew I was officially old when another programmer asked me, “what’s a punch card?”

Like many commenting here my career started in this way. Our coding sheets were sent off site for punching (actually in a different town). It was typically 2 weeks until you were able to test your code when the cards returned. An instructor at the company I worked at , supposedly coded a program with 2 statements per line, using a GOTO as the second statement on every card. As the story goes if the card stack was dropped by an operator, only the first and last card needed to be correctly placed for it to work correctly!

This is so good!

Thanks for bringing up memories of my youth! In early FORTRAN versions, the statement started in column seven and ended at column 72. Columns 1-5 were for statement numbers - labels for GOTO's. If any character was in column 6, the card was interpreted as a continuation of the previous card. Columns 72-80 were for identification - you could number them to help out in the case of dropping the deck on the floor (not that it ever happened to me ;-). It was painful to make these cards as one mistyped character would make the card useless. I wonder how many of the 10 million cards per day created were later used to make Christmas wreaths.

I got the Computers merit badge back in the 1970s. You had to be able to read Hollerith code.

The original cards had only 10 rows. The cards could only hold numbers. When they started using numbers and letters, they added the X and Y rows at the top. So, if neither X nor Y was punched, one hole in a numeric row was ... that number. The first 10 letters (A - J) were X + a number row. The next 10 (K - T) were Y + a number row. The remaining 6 letters (U - Z) were X + Y + a number row (0 - 5). There were some punctuation marks which could be punched by X + Y + some number greater than 5.

You're showing a later generation of card; original Hollerith code only punched 1 numeric row + X and / or Y. Your example has two rows punched in the number section, to get additional punctuation.

Modern IBM Power systems (fka AS/400) and mainframes can all use Extended Binary Code Data Interchange Coding (EBCDIC), which evolved from what you're looking at, which evolved from Hollerith code.

You didn't have a hole to punch for a space. A column which wasn't punched was a null, which was used as a space. This is different from ASCII, which uses hex 00 as null and hex 20 (dec 32) for a space. It's one of the reasons why EBCDIC - ASCII conversion (either way) sometimes has problems. Three guesses how I know.


Do a video, next, about Unit Record Equipment, which used punched cards as records in a relational database. And remember, IBM wasn't founded to do engineering calculations; their whole raison d'être was database work. That's why Herman Hollerith was doing for the Census Bureau (sorting and counting) and that's where IBM made most of their money through the decades. They had an entire machine which did the equivalent of a SQL join between two tables (card decks) and another machine which did the equivalent of SQL count() and sum() instructions. You had to move decks of cards around the data processing center, to different machines, to do the equivalent of a simple SQL query with a join across a couple tables.

I went to George Westinghouse HS in Brooklyn NY next door to Brooklyn College. Our HS Computer science classes used the IBM mainframe in the college. It was awesome. The first computer i programmed was with punch cards. 1973

Snoooopy!

IYKYK…

We? Hey... Kiddo, been doing computers for decades and never did a punch card. There are so very few people who did punch cards left...

I enjoy and appreciate your channel. Thank you.

Punched cards were used well into the 1980s? Really? I did a work experience placing (in Britain) in perhaps 1979, where they had interactive terminals. At university I saw no punch cards, and never in my career after. Punch cards are a story I was told by old guys when I was in my first job.

My mum was a punch card programmer before she had us kids. Later on in my primary school we were taught how to program and read punch cards in a couple of maths lessons. I think we were part of a study that the head and deputy head were doing before they were about to retire on what would happen if you fast tracked all the kids in the same year.

When I was in college, there was a desk sized card punch machine in the corner of the room where we went to pick up our print jobs.
Students used to sit on it while waiting for their jobs to finish.
One of the grad students told me that it hadn’t been used in a years, but they couldn’t remove it because it wouldn’t fit through the door after some remodeling of the area.

"well into the 1980's, just a mere FOURTY-FIVE years ago"
ever feel like you've been damned with feint praise right into the jugular? no, you Y O U T H S don't get that phrase? no worries, get grandpa his prune juice, theres a good lad

"Fuqqing loom bands in't it, m8?!!"

I can't anymore. We go Meghan Markle coding before GTA 6

Our version of the Internet back then was after you got done, putting the required information on the punchcard to transmit them in the military. I had to walk six blocks down to a communication center that had dedicated lines to other communication centers, and they would print out more cards for the customers to pick up and then load in their computers

The cards were input method. not programming method.
Nothing really matters...

Don't forget the fun and merriment of dropping your box of cards on your way to the computer lab.

I remember taking my box of program cards to enter my code. Heaven help you if it was humid, that could mean sticking cards, and a line or lines of dropped code. You might find out hours later. Then have to do it all over. Each card was 1 line of code. Ah the joy of Fortran.

In my first programming course in college, I programmed a DEC PDP-8 in FORTRAN using Hollerith cards. Those where the days when was possible to accidentally drop a program (a sorted deck of cards) on the floor and scramble it. But that never happened to me, because I was a very good programmer.

i started programming Assmbler and PL1 on punch cards. in 1981, we installed 3 swappable hard drive systems storing 360meg each so able to store 1 gig online at a time. These disks were a little 2 feet in diameter with 16 disks on top of each other giving 30 record able areas. 2 per disk, but one for the top and bottom one each. My job was to laod the card decks into Librarian, a source management system from Computer Associates (CA ). I then wrote a system which we called ROJER - Remote Operator Job Entry Resource - names after Rojer, our useless operator who kept on dropping the card decks so the boss fired Rojer. ROJER allowed the operators to submit and schedule jobs from one of the 3 terminals on our brand new IBM 158. I wrote ROJER originally in Volley/Voice on VSE , then in Roscoe/Rosproc on VS1 and eventually using TSO procedures and assembler on MVS/VSE.

A side note; in 1981 we had 2 x IMB 158's interconnected, with 800k RAM on one and 1 Meg RAM on the other. With the 1 GIG of shared online storage this was the biggest computer installation in 1981 in the southern hemisphere.

I learned my first programing language (Fortran IV) using punch cards. I would write the code on a pad of graph paper, using the first 80 boxes as columns. From there, I would type the code on an IBM card punch machine which was similar to typing on a PC in and IDE. Only there was no color coding, auto tabbing or dropdown menu selection boxes. And no lowercase. The 'stack' of cards as we called it, was much like a computer stack in ASM, lol. It had all the cards in descending order: first card (code line 1) then card 2, 3, 4, etc. To accomplish this, the stack was in normal descending order as you would expect, then the entire stack fed through the card reader upside down. The exception was that there was two stacks of cards: the program stack and the data stack. The program stack would be fed in first, then the data stack next with the first card being the data stack identifier for the computer to understand that the following cards were the data and not interpreted code. The computer we used was the IBM 360. After the code was run, you would get an 80 column wide dot matrix print out of the results. Usually, it started with the code then the printed data stack and then the dreaded line that read something like, "SYNTAX ERROR LINE 234. EXECUTION TERMINATED. Yes it would scream that at you because, again, no lowercase! lol You would then have to go figure out what the error was. It was not always on the stated card because it could have been a logic error on a previous card up the stack. Normally, it was that exact card and you just simply re-punched it and replaced the faulty card and ran it again. Hoping you would not get another syntax error further up the stack! It was the best time of my early programming life and I would not want to have changed it. You learned so much about computer science while learning to program. A few years later we went from punch cards to timesharing terminals which was also load of fun! :)

my fist programing was on a terminal in Charleston SC while I was learning Fortran 4 in 1976. It was using the "Punch Cards" and the assigned program was to Solve a Quadratic Equation. Of Course, one of the Feared outcome of running the program was that the output was on a printer and have it in a infinite loop. If always amazed me that my program was about 30 punch cards and the Cabal programmers' cards were 100 or more. Then when I started programming in DBase3, I learned that Database programs are much longer because of the size of matrix of Columns (Fields) and Rows (Records). I also took a course of Assembly for the 8080/8085 microprocessor in 1984. I saw my first CNC type machine in 1967 while working in a Manufacturing Plant as a Lathe Operator. The, I never used it or saw it run, CNC machine was a small Mill and was run using IBM Punch Cards, Programed by Engineers. This type of history is base level, like the Loom you started with.

I started on FORTRAN-77 with punch cards. I lived in fear the card reader would chew up my deck for lunch.

Ha! thats how I took tests back in school. Havent seen one of those in years. I can smell the ditto fluid still....

I remember programming like this and with the noisy teletypes. I kind of miss it.

It's also how we voted.

When it came to getting data into early computers, punched cards had a similarly low-tech competitor: punched paper tape. Borrowed from use with teletypes, you had a long strip of paper with holes punched into it to encode characters as used by the teletype systems of the day. Many early computers had instruction sets that were designed to be easily encoded on a teletype, and word sizes that were multiples of the 5-bit teletype character size. Australia's CSIRAC being one such example, using 20-bit words.

That's very interesting. When I first found out about punch cards I wondered how they worked. Great explanation!

Punch cards were modern. I remember Chebysev on a paper tape roll.

Calculators, tabulators, etc were programed with "program boards" that were essentially patch boards using jumper wires to "process" the data on punched cards prior to the GP computers. Yes, I'm old enough to have seen them at work. SAFETY TIP: Do not wear neckties tied around your neck, only clip-ons. Unit record devices WILL confuse the end of the tie for a card long enough to cause, at a minimum, a Workers' Compensation case.

from fabric machines to super computers to where ever it takes us now is sooo amazin...i only wish i could be here 100yrs from now.

OK, I got this from the Jargon File, but it sounds very, very plausible: the lace card. A card with all holes punched out. This would in fact jam the card reader, and this would be its only purpose. You might want to slip this card into the deck of cards of your least favorite co-worker, for instance. Operators had a card knife to unclog the card reader.

I punched cards only once, in 1983, but I do remember how loud these card punchers were. Anyone complaining about clicks of a keyboard has never worked with card punchers...

Bythe way, the Jargon File is a delightful piece of Internet history (and stuff that lead up to it).

I have done it all. As a prototype tester I keyed small binary programs in the computer main memory and afterwards I punched it on paper tape to reuse it (1970/71). When I changed to OS programming I used punch cards (1972) for a short period, then the ASR 33 Teletype (1973) and a 24x80 CRT display (after mid 1973). I used assembler for IBM 360, PDP 11, P800 Philips mini computer (1980) and P1000 Philips main frame (1970). From the programming languages I used mainly PL/1 and RTL/2 (a UK language comparable to C), but I learned Fortran, Cobol, SQL, C and Clipper. SQL, C and Clipper I used occasionally.

I stopped programming around 1985, because I made a career as chief architect and department manager.

I started with punched cards in 1975 on an ICL 1903a running George 2+. Sometimes we would use a hand punch machine. The other method was paper tape. The old definition for Turnaround time was the time between submitting your cards and receiving the remains. At least coding changes where replace a card. I do remember my dad taking me to NatWest Bank’s computer centre in London and setting me up to run one of the first IBM 360s in the country to do tests using punched cards to tape whilst he and his colleagues fixed some tape drives.

I used Hollerith punchcards when I was a student at Georgia Tech. I learned read the holes. I used that ability to astound my fellow students. The first card in a card deck included the user's name and password. You were supposed to put a blank "cover card" to hide the first card, which usually had the text along the top with the user's info. Often, students would skip the cover card and black out the text (or if they were savvy, they'd turn the print function off on the key punch). I would chastise others, about the missing cover card, rebuke their protests, and announce their username and password, to their amazement. This was made easier since a great many students used GATECH as their password.

There was another form of programming for punched cards that was used on card processing machines such as IBM 407's (tabulator) and IBM 82's (sorter). These were programed by hand wiring boards that were plugged into the machine which changed the circuitry of the machine. The 82 series of machines could sort on any combination of columns and the 400 series of machines could interpret the data on the cards and print reports such as tabulating columns.

great job. thx.

:D

Do not fold, spindle or mutilate.

They could have borrowed the stack binding threads, like some sort of card cassette, to alleviate the dropped stack problem.

Cool presentation!
Important to know that the IBM 'hollerith'cards were widely used before WW2 in population registries around the world and contributed in a very unfortunate way to the holocaust. Several places the resistance and partisans blew up or set the buildings on fire , then the people belonging to the lost cards did not exist anymore for the german administration and had a much better change to survive.....Today big brother can find you no matter what.........Don't know if IBM themselve has made a proper and honest presentation about their role in the Holocaust, but there is a very good book about this called IBMandtheHolocaust.

When I was young, we sent off our punch card deck in Fortran or Cobol to be processed on an ICL mainframe, You had better not have forgotten the George 4 Job Card!
We didn't even have modern punches, you had to know the rows in each column to punch for each character and press the right combination of keys.

There was excellent documentation on all aspects of Holerith cards. The way they were read was standardized, but not always used. Since the cards were used for tabulation initially, the encoding you mentioned isn't always used.
My favorite use was to vote. In California we used Porta punch devices to knock at one hole at a time to vote. Each hole represented a choice. A card reader simply counted up how many of each hole was punched. To prevent overvoting, when the card was read, if 2 votes for the same office was punched, a program would treat it according to local law. At large corporations we rarely punched our own cards and sent forms for professional key punchers to punch. Once we got IBM 3270 with TSO we did most programming on screen.

The keypunch machines had several cool features. The card you just finished moved to the left where it was being read by the machine. Sometimes you could press a certain key on the keyboard and the card you were working on would copy the character of the prior card. There was also a rotating drum up and to the left; you could open the door, remove the drum, put a card onto the drum, and the holes in the card you put on the drum would instruct the machine to for example skip the first 6 columns and start in row 7 (handy for Fortran at the time), or when you get to column 10 copy columns 10 through 20 then eject the card. Most didn't know how to use the drum cards, but knowing that did save quite a bit of time depending on how repetitive your cards were. Another invaluable machine was one where you fed in your deck and it would print out what was on the cards. Great for debugging and making sure your cards were in order. Some key punch machines did print the line of code at the top of the card; but some didn't.