I'm trying to avoid this being branded as "opinion based", but would be interested in accounts of punched cards being used in "live" environments later than expected.

In my case, when I joined Burroughs in late '79 my recollection is that all inductees used punched cards to submit trivial COBOL etc. programs but on reflection that was a sensible choice since it got introductory exercises ("this is probably the first and only time you'll run COBOL") out of the way before having to get into the much more difficult area of learning how to use a 1970s-grade text editor.

Subsequent to that I was aware of cards being used for short job control tasks, but that was very rapidly phased on in the early 1980s.

As an aside, I recently came across an interesting example where the Shorewall firewall- apparently written by an ex-Burroughs chap- appeared to use what were recognisable card-based conventions. I've also come across data formats which appeared to have limitations which would make sense if they'd originally been formulated in terms of 80-col cards.

So, I can fairly say that I've seen 80-column cards in use in a live mainframe environment in the early 80s. Does anybody have knowledge of anything later?

  • 10
    It may be a bit far-fetched, but time punch card systems capturing working time, public transport ticket validation systems or even some US voting machines use "punch-card-like" systems to the present day.
    – tofro
    Sep 28 at 9:20
  • 3
    It's a long time since I did any COBOL programming (mid 1990's) but even then, the language still had vestiges of its punched card past. The syntax and the formatting of each line were obviously still designed for entry using punched cards, even though, by then, we were using proper text editors and there wasn't the hint of a punched card machine anywhere.
    – JeremyP
    Sep 28 at 9:31
  • 4
    I'm not fully sure what the question is as the title ask for relevance of punch cards while the text also asks for "card-based conventions". Those are complete different issues.
    – Raffzahn
    Sep 28 at 9:35
  • 3
    The election of 2000 brought punched cards into infamy. The punch mechanism was a push rod operated by the voter, and the chad was perfed into the card to make separation easier. pcmag.com/encyclopedia/term/punch-card Sep 28 at 10:40
  • 6
    One of the longest-lasting punch-card conventions is arguably the requirement in some programming languages to declare all variables at the start of a block and all functions before use, e.g. in C89. One of the first compilers to enforce this was the Burroughs 5000 dialect of Algol, specifically because loading a deck of punch cards for a second pass was so inconvenient. Customers (including Edsgar Dijkstra) with punch-card programs loved single-pass compilers and saw forward declarations as a trade-off well worth making.
    – Davislor
    Sep 28 at 17:41

11 Answers 11


The Votomatic system was a punched card based voting system that was still in use in 2000. This stretches the scope of your question a little, because the punching mechanism was a sort of push pin that dislodged a previously perforated chad. But they were definitely punched cards.

Recounts were a nightmare, especially in Florida, where discerning the intent of the voter was problematic, when a chad was not completely pushed out.

You can read up on it in Wikipedia

Edit: The ESS website says that the Votomatic cards had 960 cells for placing a vote. 80 * 12 is 960. That suggests that the Votomatic cards were suitable for being run through an IBM card reader.

  • 3
    They were definitely punched cards, but were they 80-column punched cards as specified in the question?
    – Psychonaut
    Sep 28 at 11:26
  • 4
    Don't know. But they vere licensed with IBM. Sep 28 at 11:50
  • 4
    homepage.divms.uiowa.edu/~jones/cards/collection/i-ballot.html suggests that they were standard punched cards, possibly with one or more "tear-off" sections. verifiedvoting.org/election-system/ess-votomatic says that they were in use up to 2014. Sep 28 at 12:16
  • 1
    ESS says there were 960 ballot positions on the card. That suggests a 12 * 80 layout, the same as plain old IBM punched cards. The pre perfed chads cast some doubt on this. It might be nice to know the card reader that was used in conjunction with Votomatic. Sep 28 at 12:46
  • 1
    It was quite common to use 80 col cards for such purpose - after all, voting is data entry, so using standard format allows usage of standard equipment for processing. It's all about a closed process. Thus such formats may survive several technology changes.
    – Raffzahn
    Sep 28 at 15:44

The question is a bit contradictory as it seems to ask for multiple, possibly mixed-up, items:

  1. Use of physical cards
  2. Use of card originated conventions
  3. Use of the word card as professional term

In addition it carries the issue of

  1. Individual timing

as each and every user and use case will not only have dropped them at a different time(*1), but also as a gradual process.

Physical Cards

In general, use of physical cards started to vanish as early as the mid-1960s when hard disks became a thing with most installations. From then on, punch cards' use in data centers declines - it was simply more convenient to start a job from disk. Despite that, their use as prime media for data entry continued. By 1970 local data-entry systems like Cogar 4 or Datapoint 2200 started to replace key punches and cards. IBM introduction of the 3740 data entry system, in 1973, handed the biggest punch to card processing. (Mass) data entry moved from keypunch to 3740 and similar systems, taking away the need to create and carry wagonloads of cards from data-entry buildings to the computer room.

From there on, physical cards were no longer a main stable in mainframe systems. I know several large-scale computing centers (i.e. such with multiple machines) which by 1978 had removed all their readers (in the old times multiple readers per machine) except for one single card reader kept operational for the occasional task of reading in some old stack.

My last (kinda) professional use was typing a series of cards at a customer site (*2) for our football (*3) bet list to be immediately printed out in 1979. Not because there weren't terminals, but because the lonely 029 keypunch was readily available and printing them out could be done with a console command not needing any account (*4) :))

Physical cards left mainstream service around 1976 to 1979.

A reminder about how gradual the change was/is, can be found in this report about a 1948 electro-mechanical(!) IBM 402 accounting machine still operating for production in 2010 in Texas, USA ... of course using newly-punched 80 column cards for data :)

Card Inspired Conventions

Since the card was the first and all around (*5) data storage, everything was based on those (usually *6) 80 columns. All software was, and often still is, based around buffers of 80 (or 84) bytes to read the next (partial) record.

Introduction of modern data-entry systems (such as the 3740 and later) only straightened and sped up the entry process, not the internal workings - which is exactly what made it such a seamless and successful step ahead.

Fixed-length records are even now the mainstay of data handling on mainframes (*7).

This of course included the command line as well (*8). With increased terminal availability, OSes started to acquire front-end abilities to handle lines longer than 80 chars. Sometimes this was done by turning long lines into series of 80 byte records :)

Such software is still to be found today. After all, why change a running input system if no command, configuration or input data will exceed 80 chars anyway? Likewise command line, compiler, most tools, etc. are still able to read an input line as a series of 'cards' concatenated by a continuation mark.

Not to mention that basic manuals for mainframe OSes still start with an introduction to command structure differing very little to back then.

Facit: Conventional use never stopped.

Card as Professional Term

And then there are people talking about their job. A line was a card and a card was a line. This was deeply ingrained with everyone working in (mainframe) IT. And we all know how hard it is to get rid of terms that have been used for a long time.

Within that setting, calling something a card is in addition a clear hint that it's not about some line but a command or parameter or a stack thereof. Which is another of those remainers: Stack as in Stack of Cards (*9). Mainframe people may still distinguish a stack for commands/parameters from a file which holds data. It's simply part of a domain specific language :)

It does fade more and more with each retiring oldtimer and their successors no longer directly operating the system.

Conclusion: Card as professional term is still known but fading fast.

*1 - Interestingly, smaller customers usually transitioned notably later. I remember one example running a single low end /370 (in real mode) still using tape based procedures in 1980 and complaining that even the real mode OS now needs a disk to fully function. He claimed it was made on purpose to make him buy new hardware, hardware he and most (his words) others would never ever need.

*2 - The Bavarian tax office in Munich, the customer mentioned, might make a perfect example for the situation 1979. At the time they were running six /370 mainframes, 14 printers, a huge disk farm and close to 1000 terminals. Exactly two keypunches were surviving in a corner along with a single card reader. Only a few years before they had several halls filed with a hundred or more key punches and staff operating them in shifts.

*3 - The real stuff, played using only feet (and brains).

*4 - Which also meant that the job was not recorded in any way in the accounting system :))

*5 - As in used foreverything, input, output, intermediate, short term and long term storage

*6 - YMMV depending on manufacturer. 80 is standard for IBM and most IBM-compatible systems

*7 - Along with block-orientated instructions, not needing to iterate along variable-length fields and records is a major reason why mainframes are as fast as they are.

*8 - After all, the command line is nothing other than the terminal collecting characters until they are sent as a record which the host can handle exactly as if a card was read - standardization of interface formats at the very base.

*9 - In some way as well forthedata structure, isn't it?

  • 19
    As an undergraduate in the early 1980s I used punch cards for parts of a programming course. At peak times it was hard to get a terminal to use, and the terminal system ran quite slowly. Over in the corner were the two card punches and the one reader. And then I found out that every 5 minutes the system ran the jobs (well, my job) in the card reader at highest priority and spit out the result on the line printer next to it nearly instantly. I then had time to consider the result, debug, punch a few new cards, and repeat the process while everyone else was swearing at their terminal speed.
    – Jon Custer
    Sep 28 at 12:20
  • 1
    @JonCuster Lovely.
    – Raffzahn
    Sep 28 at 12:23
  • 3
    Likewise - all MOP terminals on the ICL 1906A busy, but keypunches available. Also, on the 6A I had a funny-money budget of computer time; sitting at a terminal doing initial program entry would cost me a lot, but running cards through a reader was more or less free, so I'd use that to establish the source files. Sep 28 at 12:28
  • 3
    Certainly in the mid 1980s University 1st year students were still using cards. Both mark sense and punch cards. Remote Job entry systems were still available to submit card decks. I left that environment in the mid-1980s while from the annual reports the mainframe appears to have been decomissioned in 1989 - 1990.
    – PDP11
    Sep 28 at 15:44
  • 2
    @PDP11 Mark/Sense is possibly as much a US only case as hanging chads in elections. Continuing teaching outdated courses isn't exactly a sign for real world usage. Them having removed the mainframe by 1990 is rather a sign about a basic shift in teaching as professional use of mainframes is not only still a business, but indeed a big one.
    – Raffzahn
    Sep 28 at 16:33

IBM 80-column cards were used in the NASA Johnson Space Center Shuttle Mission Simulators (SMS) (designed in the late 1970s) until the late 1990s. The simulators contained actual shuttle flight computers (IBM AP-101s), and the cards were used to patch the flight software, especially for inserting "flight software (FSW) malfunctions" - simulated coding or data errors - or late fixes to the FSW. There was a physical card punch in the facility for this purpose.

Around the turn of the century a means of emulating the card input was devised and the physical cards were no longer used.

This excerpt of a page from the document Internal ICD: OFT Simulation Interface Device (SID) (Software Only) dated April 30, 1997 shows the format of the 80 column cards. Item 1 shows "Card Input Only" and Item 2 shows that there were 80 columns.

enter image description here

  • 1
    No problem for your lack of a ref., and your reminiscences are invariably interesting :-) Sep 28 at 17:01
  • 1
    @MarkMorganLloyd Thanks! I managed to find something in an old document and edited it in. Sep 28 at 18:39
  • 2
    As an aside, I came across a "golden era" Sci-Fi story which mentioned a card reader on a spaceship. Subsequent discussion (probably in the 90s) arrived at the consensus that that was probably to inject precomputed maneuvers into the navigational system rather than their being a substantial amount of card-based computing on board... Sep 29 at 7:14
  • 1
    Punch cards were in routine use in 1980 at Honeywell Marine Systems Division (West Covina, CA) for programming a mid-sized Honeywell minicomputer (forget which one) - I don't remember which one but it was not a mainframe and yet not one of the small 516/716s (which we also used). They were still using them as I left. A project there which I suggested and pioneered (before I even graduated Mudd) was to do unit (i.e., component) development on Multics (which a different division of Honeywell owned) in FORTRAN, then after units were tested, move them to the minis (and punch cards).
    – davidbak
    Sep 30 at 16:56
  • "Around the turn of the century" --> Since cards have been used for a long time (prior 1900), perhaps better as "Around the turn of the 21st century"? Oct 1 at 8:03

Well, around 1993 we replaced a very large, very old NCR mainframe with our Unix based solution. It was in production every day to that point, utilizing punch cards. When it came time to turn it off, they had to be certain because the company contracted to support it said once they stopped, they weren't going to return.

We replaced it with a pizza box Sun and a terminal concentrator.

The line printer alone was almost as big as a VW Bug.

  • 2
    en.wikipedia.org/wiki/NCR_315 appears to identify one of the NCR peripherals as being a rebadged IBM, and chipsetc.com/ncr.html clearly shows that NCR was using IBM 026 punches... as did just about everybody. Sep 28 at 16:02
  • 1
    The car is called "Käfer" (rather than "Wanze") in German, which translates to "beetle". Certainly, most modern cars have embedded computer systems onboard which all have their bugs. Sep 29 at 6:55
  • As in the English "cockchafer", i.e. a Beetle with cock-ups. Sep 29 at 7:17
  • @rexkogitans Doesn't change the fact that VW Bug was the common name in the US.
    – Raffzahn
    Sep 30 at 15:03

I saw an 80-column card sorting machine used in the late 1990s with aperture cards, which were standard sized 80-column cards that had a transparent pocket into which a piece of film could be inserted. I didn't happen to notice a keypunch in the facility, but I would think there must have been one to key the information onto cards for any new films that were being added to the collection.


I joined DEC in 1977 with a brand-new bachelor degree in computer science. My first project was to emulate a Univac remote job entry terminal on a PDP-11; classic 'card reader, line printer, line to remote mainframe' configuration. Support for specific Univac card codes was part of the requirement, and there were target customers in mind, so as far as I could tell, cards were actually used.

On the other hand, DEC only supported relatively low-speed card readers on the -11, so they probably weren't putting huge jobs through it.

  • 1
    I joined B. in '79 and- like I suspect most mainframe companies- they were still heavily oriented towards fixed-length records of which cards are but one example. They also had at least one "microcomputer" (i.e. computer using ucode) system for remote job entry, but you /still/ (if my memory is correct) had to predeclare files with a record and block size. I didn't come across variable line length until I started using unix- and CP/M-class systems somewhat later, and even CP/M systems had fixed-size segments hence the convention of ^Z (single or fill) at the end of each file. Sep 28 at 12:46
  • If you were implementing an RJE terminal the chances are the line speed in 1977 was the limiting factor and not the card reader. The Documation Card Readers with the PDP-11's CR11 interface were available up to 600 Cards per minute. 80 Bytes per card translates into 6,400 bps. The Documation Card Readers had a reasonably large input hopper but from memory only a fraction of the size of a Burroughs mainframe card reader. Reference is bitsavers.org/pdf/dec/unibus/DEC-11-HCRB-D_CR11_Mar72.pdf
    – PDP11
    Oct 2 at 17:59
  • GPO leased-line, probably 9600 bits/sec sync, so 1200 chars/sec. Probably trailing blanks suppressed. Primary use was expected to be 'input to emulator from PDP-11 disk files', local card-reader support was just another input source. We might have spooled the deck to disk first, I can't recall. Oct 2 at 18:20

I was learning using an mostly obsolete when installed 2970 ICL mainframe in 1981 at Southampton University. This used punch cards for input.

Then joined Philips Research , where the terminals for the IBM 4381 mainframe generated "virtual punched cards" that dropped into the input buffer of your virtual machine and the output from your process produced punched cards - probably stopped by 1990.
I still have somewhere the fan fold line printer output transcript of my chatting with my girlfriend from a chat program that ran on this system. We have been married since 1985..

  • snee.com/bob/opsys/part5vmcms.pdf section 21.3 is quite a good read describing a very elegant hack. Sep 29 at 19:11
  • Speaking of ICL, in 1977 while job-hunting, I toured the ICL software division at Bracknell. While showing off their huge computer lab, I was put off by the guide saying "you submit cards there, and get the printout a few hours later". Sep 30 at 2:24
  • That would be about the time that the U of Nottingham ICL mainframe started downplaying cards and moving undergrads to terminals. By then I wasn't using it any more, so I can't comment on how easy their editing environment was to use: but it did appear that they could cram two terminals into the space previously used by a single 029 punch which I guess is progress. Sep 30 at 6:14

I remember seeing punch-cards in use in Uzbekistan (then USSR) in the late 1980s, pretty confident it was 1989. If I recall correctly this was in a data center related to the local natural gas mining authority, and for the Soviet equivalent of IBM System/360 (ЕС ЭВМ 360). Given how uniform things generally were in the USSR, I'm guessing a similar setup existed in many places at the time, and given how chaotic things got around the time of the fall of the USSR (investing in new computing equipment was likely pretty low on the priority list) I wouldn't be surprised if punch cards were in use far into the 1990s over there.

  • That's a good point, although it still doesn't beat the US voting system :-) Sep 29 at 21:23

I was using punch cards to submit jobs on an IBM-S/360 at a community college in 1982. (There were dumb terminals but there were long waits to use them, almost as long as the waits to get printed output from a batch job. In addition, there was a false rumor that assembly language jobs could only run correctly in batch, so some people would use the line editor to edit a file and then submit a deck to run it as a batch job.)


I'm pretty sure there are still Jacquard machines still in use making carpets to this day, and these store the patterns on punch cards. There are almost certainly other applications in manufacturing where they havnt gone away.

  • 2
    There's also fairground organs, but neither of these use standard 80/96-col cards and that's what the question's about. Sep 29 at 15:38
  • 1
    How about Allen organ tone cards? Those were the same size and shape as 80-column cards, and used the same hole grid, though they were punched with some kind of binary data rather than alphanumeric.
    – supercat
    Oct 2 at 15:10

Tone cards for Allen electronic organs have a trailing portion which holds what I'd guess is the stock number in standard 80-column card format, though the tone data itself seems to be stored in a middle portion which seems to use binary data in rows 0-3 and 5-8 (row 4 is punched in every column). The cards will be relevant as long as anyone is continuing to use the organs; one can change sounds even in the middle of a piece by inserting and removing a card--a process that takes about a second.

  • That's really interesting as an example, and photos via Google suggest they're standard 80-col. However I feel- reluctantly- that one has to lump them in the "retro" category. Oct 2 at 18:17
  • 2
    @MarkMorganLloyd: Many churches still have Allen organs installed that use the punched cards, and continue to use the organs and the punched cards not because they're "retro", but because the cards provide a convenient means of changing between different sounds that has worked reliable for the last 50 years and might remain just as usable for the next 50. Switching sounds on an Allen organ is a task which in some places would be routinely performed every Sunday, is done with punched cards, and couldn't be done as well any other way.
    – supercat
    Oct 2 at 18:21
  • "I see that the Univac key punch at the Allen factory went for $255 with two bids. Did someone on here buy it?" organforum.com/forums/forum/organ-marketplace/on-the-internet/… Oct 2 at 20:26

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .