Re: Some time ago... @ShortLegs
I love all this retro stuff, so it's no bother to explain. What I am talking about here is the 80 column IBM or Hollerith card that was common in the '50s, '60s and '70s, but was mostly obsolete by the '80s. I learned to program PL/1 on them, and also used them in my first job.
A punched card was exactly as it sounds. It was a card measuring 187mm by 83mm. It had rounded corners, with one or other top corner cut off to allow quick card orientation checks.
They had rectangular holes punched in an 80 column by 12 row matrix, with each column representing one character. Not every manufacturer used the same encoding type on the cards.
Generally speaking each card represented one line of information or a line of source code. Most card punch machines would punch the holes representing the character, and would also print the character at the top of the card, so that you could read the card.
Most languages (but not all) reserved the first or last six columns to hold a card number, so that cards could be ordered. When punching the cards, it was normal to step the cards number by 10, so that it was possible to insert cards into the deck without having to repunch the whole deck. Most compilers would allow you to miss the numbers altogether, but if you ever dropped the card deck.....
Punching the cards was done on a desk-sized machine with a keyboard and a transport mechanism which allowed blank cards to be fed in to a hopper (normally on the right), typed one column at a time, and then moved into a hopper on the left (cleverly turning the cards over to keep the order). The better card punches also allowed you to copy a card, one column at a time until you got to an error, and then punch the rest of the card.
Alternatively, you could get hand punched that allowed you to punch by hand the correct holes for each character, but you had to be desperate or very clever to use one. Some people claim also to have blocked cut holes by carefully placing a 'chad' (the cut out rectangle of card) into a hole to 'edit' a card, but I'm a bit sceptical myself.
Column 7 in most languages was a card-type indicator. Typing a C in this column normally meant that the cards was a comment. This may sound wasteful, but the comments would be included in the listing from the compilation. In some languages, like Cobol and RPG, the card-type indicator was used to identify the section that the line was in (Input, Calculation, Output, Exception).
Cards were read in a reader that pulled one card at a time (at a rate of 2-10 cards a second) across either an mechanical, air-jet or optical reader, which worked out which holes were punched. You kept card decks together with elastic bands, and just for security, most people would use two bands, in case one broke.
Creasing a card, or allowing them to get damp or worn at the edges would often cause the cards to jam in the reader, normally meaning that the whole deck would be rejected. Having a deck rejected meant that you missed the slot and have to put your job to the back of the queue once the problem was rectified. Remember that systems were mostly single tasking (at least for compilation streams), so they processed the queue in sequence, one-at-a-time.
I'm not sad to see the end of those days, but having lived through them, I feel that it imposed a rigour that would benefit modern programmers if they had to experience it.