16

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?

Mark Morgan Lloyd
  • 2,428
  • 6
  • 22
  • 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 '23 at 09:20
  • 2
    @tofro true, but are they in one of the standard DP formats (i.e. 80- or 96-col)? There were also things like small punched cards (actually plastic) used by the UK's GPO for 'phone diallers, but I'm having a hard time thinking of any examples of 80-col cards being used for control etc. other than for the format card in an 029 card punch (which is, of course cheating :-) – Mark Morgan Lloyd Sep 28 '23 at 09:27
  • 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 '23 at 09: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 '23 at 09:35
  • 2
    @Raffzahn No, the body refers to later card-based conventions. The final para is unambiguous. – Mark Morgan Lloyd Sep 28 '23 at 09:42
  • 1
    @MarkMorganLloyd well, the final paragraph does again ask for cards, nothing else. – Raffzahn Sep 28 '23 at 09:49
  • 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. https://www.pcmag.com/encyclopedia/term/punch-card – Walter Mitty Sep 28 '23 at 10:40
  • 3
    @WalterMitty: I remember that. After all the agonizing about hanging/swinging/pregnant chads, many states decided to get rid of their punch-card voting machines and replace them with electronic ones (which brought its own controversies). – dan04 Sep 28 '23 at 14:54
  • 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 '23 at 17:41
  • 1
    @Davislor Yes, I used to work for them and have tinkered with that dialect. – Mark Morgan Lloyd Sep 28 '23 at 18:27
  • Fetching slightly further, some Jacquard looms use punch cards to this day, in "live" environments, educational, hobbyist and industrial. Personally I have only punched some 50 column ones, but they do come in other formats and sizes. – kubi Sep 29 '23 at 07:16
  • 1
    @kubi as in http://www.chrisfenton.com/the-pixelweaver/ which is where I originally found a decent illustration describing how the mechanism worked. – Mark Morgan Lloyd Sep 29 '23 at 07:19
  • I have read that ICBM are using punched cards (at least older models). They are unvulnerable for EMP (and probably the only option at the time of development). – i486 Sep 29 '23 at 08:43
  • @i486 You have read that /who/ is using them? Is that a typo for IBM, or are you really referring to Intercontinental Ballistic Missiles and if so in what role? – Mark Morgan Lloyd Sep 29 '23 at 09:09
  • 1
    I was using punched tape in the early 2000s to support legacy systems, so they are probably still relevant today. – Chenmunka Sep 29 '23 at 09:18
  • @Chenmunka punched tape is a completely different question. It certainly had significant use into the 2000s in e.g. CNC equipment. – Mark Morgan Lloyd Sep 29 '23 at 09:37
  • @MarkMorganLloyd It is missiles of course. What is the relation of IBM with EMP. – i486 Sep 29 '23 at 09:40
  • 1
    You said "ICBM are using" so there's no /of/ /course/ about it. – Mark Morgan Lloyd Sep 29 '23 at 09:58
  • Yes, tape is different. But not vastly different. – Chenmunka Sep 29 '23 at 12:00
  • 1982 high school vocational school, used a B9900 (I think). There were 9 terminals shared between the 'real' users and us students. Each student got one session on one every two weeks, the rest of the time was punch cards. 1983 community college had a system, don't remember what one, with 29 terminals, which was about half as many as needed and we also used punch cards for a majority of programming work. BASIC, COBOL, FORTRAN, RPG and Forth were taught. My semester of interning was at a Oil Exploration company, they used RPG and no punch cards... it was a dream. – CGCampbell Sep 29 '23 at 12:15
  • @CGCampbell Not sure there was a B9xxx series, particularly by '82. The 2900 (possibly also 3900 and 4900) was very new, but it was distinguished by a maintenance console which allowed the logic to be scan-tested in-situ... quite an innovation for any vendor. My recollection of the B6900 and 7900 was that they were fairly conventional, but the 5900 was "all new" with again improved maintainability. There was also the B1900 "small system", which sounds about right for that number of terminals. But since they were business-oriented terminals, I bet you didn't enjoy editing sourcecode on them. – Mark Morgan Lloyd Sep 29 '23 at 12:27
  • Might have been a 1900? Honestly only remember it was a Burroughs and had at least one 9 in the number. I also remember that at first everyone was envious of those who got to use the terminals, and then the dismay that they weren't very much 'easier' than the card decks. – CGCampbell Sep 29 '23 at 12:32
  • @CGCampbell That would have been the most likely. The "large systems" were university-scale, the "medium systems" were heavily oriented towards COBOL... in any event, long time ago for both of us. However one of the things I was thinking about when I originally asked the question was the relative ease of cards compared with Burroughs standard terminals being used for time sharing: unless you got lucky and were given Teletypes or dumb terminals their standard stuff had an enormous learning curve. – Mark Morgan Lloyd Sep 29 '23 at 13:20
  • On a tangent, punched tape was still in use at least as late as 1995, and probably much later. Don't know what the current status is, though. – jcaron Sep 29 '23 at 17:00
  • @jcaron, as Mark Morgan Lloyd already said above; punched tape is completely different from punched cards. There may be some similarity in the hardware and the underlying principles, but their use cases set them apart. A punched tape is a record of a stream of data, but punched cards are unit records. – Solomon Slow Sep 29 '23 at 18:34
  • @SolomonSlow I'd add to that that I've generally formed the impression that paper tape was rather more of a European thing, while cards were rather more American. – Mark Morgan Lloyd Sep 29 '23 at 18:36
  • 2
    When I left the Israeli air force in Dec-1997, the local office was still using 80-col punch cards... as cardboard holders for some papers – Jonathan Oct 01 '23 at 14:08
  • Probably not what you were looking for, but I couldn't resist sharing this usage of punchcard that is in use in The Netherlands to this day. Enjoy: https://youtu.be/j34Hudcgwpc?si=LoV2pfkFAn31_JK9&t=935 – Mausy5043 Oct 01 '23 at 16:59
  • TFT. We did of course touch on cards ("books") used in that role earlier, although they're obvioulsy not standard DP cards. – Mark Morgan Lloyd Oct 02 '23 at 07:31
  • //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. // What does that have to do with punch cards? Some requirements about overall program sequencing were in place to allow the first part of the program to be processed by one piece of compiler, which could then be jettisoned and replaced with code to process the remainder while the remainder what sitting in the input tray, but that approach could be just as applicable with tape. – supercat Oct 02 '23 at 15:08
  • @supercat stretching it- /really/ stretching it- the input medium was assumed to be serial-access with single-pass compilers. In practice, as shown by my demo program at https://forum.lazarus.freepascal.org/index.php/topic,56122.msg417359.html#msg417359 , there were some real wierdnesses in there, e.g. different restrictions on the card line length vs the ALGOL line length. – Mark Morgan Lloyd Oct 02 '23 at 18:08
  • @Davislor: Forgot to page you to the comment starting with //One of the longest//. – supercat Oct 02 '23 at 18:11
  • @MarkMorganLloyd: I'm aware of things like FORTRAN column-usage restrictions, which are very much punch-card related, but cards were hardly the only one-pass sequential-access medium. I don't know how much Ritchie et al. used paper tape, but I think DEC machines used it much more than punched cards, and unlike punched cards it has no concept of fixed-length records. – supercat Oct 02 '23 at 18:13
  • @supercat Whether this is stretching it too far is a matter of opinion, but: a major motivation for single-pass compilers was that they were so much more convenient for programs stored in punch-card decks. And there are contemporaneous sources that this was a major factor in which system to purchase. The conventions designed for single-pass compilation have survived many decades after the original technical reasons became obsolete (and all computers have more than enough memory to easily store the full source code of any program), – Davislor Oct 02 '23 at 18:21
  • @Davislor: Punched card hoppers were the first common single-pass storage medium, but not the only one. I think some microcomputer systems would have benefited from single-pass language designs. – supercat Oct 02 '23 at 18:34
  • @i486 If you mean Inter-Continental Ballistic Missiles, that’s incorrect. The Air Force used a computer system named SAGE from the late 1950s until the last one was shut off in 1983. This predated ICBMs, which made the idea of sending interceptors to shoot down the enemy bombers obsolete. SAGE used tape for storage, not punch cards. ICBMs never, to my knowledge, ran off punch cards. – Davislor Oct 02 '23 at 18:34
  • @supercat Then we agree: they were the first, and the original motivation, and then the same methods carried over into other media. – Davislor Oct 02 '23 at 18:34
  • @i486 James Wong’s description of the Air Force’s SAGE system: “The program was actually on mag tape. The mag tape, when you started up, is read into the computer, and it’s stored on drum. Except for the Executive, and a few of the programs that you need, that would be in core.” – Davislor Oct 02 '23 at 18:38
  • @Davislor: Similar issues would arise in situations where code will be received over a streaming medium. If a web page has multiple script elements, all functions called within a script tag must have been defined within that tag or preceding tags, but I'd hardly call that an obsolescent restriction based upon obsolete technology, especially since the content of later tags might not even exist yet while the code for earlier tags is being executed., – supercat Oct 02 '23 at 18:47
  • @supercat PDF is an example of how something like that is still useful: the changes between PDF 1.0 and PostScript are motivated by being able to open any page and render it without having to download all preceding pages. Similarly, in the early days of the Web, it was important to be able to render as much of a page as possible while it was loading. You could even make a case for JavaScript. There’s no longer any technical reason why a C compiler (for example) would need to be single-pass, however. – Davislor Oct 02 '23 at 19:01
  • @Davislor: A C compiler may not need to, but it would have been entirely reasonable for a language like Javascript to require that any code that would invoke functions that hadn't been declared yet would need to first need a declaration which would create a "stub" function, add it to a table, and yield a reference to the stub. Later, when a definition was found for a function listed in the table, the stub would have a reference to the real function stored in it. Single-pass compilation can offer advantages in some usage contexts. – supercat Oct 02 '23 at 20:02
  • @Davislor Are you sure for russian ICBM? Maybe there were used punched cards. I don't remember details, only the unexpected (for me) solution for storage. – i486 Oct 03 '23 at 07:41
  • @i486 I am reasonably certain that the Russian Federation is not using punch cards to run its ICBMs today. (Not from first-hand knowledge, so don’t assassinate me, Vlad.) – Davislor Oct 03 '23 at 10:54

11 Answers11

21

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?

Raffzahn
  • 222,541
  • 22
  • 631
  • 918
  • 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 '23 at 12:20
  • 1
    @JonCuster Lovely. – Raffzahn Sep 28 '23 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. – dave Sep 28 '23 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 '23 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 '23 at 16:33
  • @Jon Custer -- I missed using punch cards in a programming language class by just one year! This was the early 1980s also!!! – JosephDoggie Sep 28 '23 at 21:04
  • My recollection is that the IBM VM/SP operating system still provided virtual card punch and card reader devices when I used it in the late 1980s, presumably for compatibility with older software that was expecting to talk to physical devices. This is somewhat similar to the way Unix's virtual terminal devices emulate hardwired physical terminals, even to the point of having settings for transmission line speed and other physical protocol details that are no longer irrelevant. – Mark Dominus Sep 28 '23 at 21:07
  • 1
    @JonCuster I was using punch cards in a correspondence undergrad course in 1985. Was interesting sending line editor commands via mailing text written on a grid, and getting the cards back with the printed run results. Debug/test loop was really, really long! – throx Sep 28 '23 at 22:20
  • @Raffzahn Mark/Sense cards were definitely not a US only case as they were widely used in Australia for High School and University students. We also used ICL sheet readers from the UK. – PDP11 Sep 28 '23 at 22:43
  • How about current card usage in the betting and lottery industries refer https://help.tab.com.au/s/article/Changes-to-our-Betting-Cards – PDP11 Sep 28 '23 at 22:59
  • 1
    An 'Engine Deck' once referred to a deck of cards provided by an engine manufacturer to an airplane manufacturer. The deck described the performance of an engine, typically in a standard 7 or 8-column format, with one operating point (Mach, altitude, throttle setting, thrust, fuel flow, etc.) per line. Today, an 'Engine Deck' abstractly means 'a model of the performance of an engine'; few know the origin of the term. A deck can be a single file representation of the old deck, or a black-box computer program that is queried for the information, or even a set of curves on printed paper, etc. – Rob McDonald Sep 28 '23 at 23:56
  • @PDP11 Is that one of the standard 80- or 96-col formats? Pictures at that link suggest not. – Mark Morgan Lloyd Sep 29 '23 at 06:52
  • @MarkDominus I think that the legacy version of VM/CMS still does that. Basically, the punch/reader "standard handles" have been repurposed for communication between VMs, i.e. users etc. – Mark Morgan Lloyd Sep 29 '23 at 06:54
  • @JonCuster I was on the staff at Lowbrow uni in the UK in the mid-80s, and the Multics system available to undergrads was similarly swamped: 30 secs character-echo time at peak periods. The eventual response was to install microcomputer labs in each department (I ran one, with LAN working in early '84) tied together by Cambridge Ring (replacing an ad-hoc arrangement based on Gandalf line drivers and Kermit). – Mark Morgan Lloyd Sep 29 '23 at 07:02
  • @RobMcDonald I think your engine deck falls into my "aside" category: stuff derived from 80-col cards even if it its use of the original media has been virtually forgotten. – Mark Morgan Lloyd Sep 29 '23 at 07:04
  • 1
    When I read, "every user and use case will not only have dropped them at a different time," the first image in my mind was of some hapless undergrad or clerk spilling a deck all over the floor. (You did number those, I hope?) – Solomon Slow Sep 29 '23 at 12:25
  • @SolomonSlow I'm not claiming to have intended that pun, but seeing it now I like it as much as you do :)) – Raffzahn Sep 29 '23 at 12:33
  • 1

    handed the biggest punch to card processing

    Nice! Love the puns!

     – The Bic Pen Sep 29 '23 at 23:18
  • @MarkMorganLloyd : "Lowbrow" = Loughborough? And is that what you called it, or autocorrect? – dave Sep 30 '23 at 02:19
  • @another-dave well, the designation does appear to be universally recognised ;-) – Mark Morgan Lloyd Sep 30 '23 at 06:15
  • 1
    The Numerical Electromagnetics Code is an example of the second and third. First written in the 70s, the latest version is from 2022 and it's still in common use. An input file is still called a "deck", the lines are still "cards", and the format is fixed-width. But now most people edit them in a GUI. – hobbs Sep 30 '23 at 22:48
14

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

Organic Marble
  • 571
  • 2
  • 7
  • 1
    No problem for your lack of a ref., and your reminiscences are invariably interesting :-) – Mark Morgan Lloyd Sep 28 '23 at 17:01
  • 1
    @MarkMorganLloyd Thanks! I managed to find something in an old document and edited it in. – Organic Marble Sep 28 '23 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... – Mark Morgan Lloyd Sep 29 '23 at 07: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 '23 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"? – chux - Reinstate Monica Oct 01 '23 at 08:03
9

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.

chicks
  • 397
  • 1
  • 4
  • 15
Walter Mitty
  • 6,128
  • 17
  • 36
  • 3
    They were definitely punched cards, but were they 80-column punched cards as specified in the question? – Psychonaut Sep 28 '23 at 11:26
  • 4
    Don't know. But they vere licensed with IBM. – Walter Mitty Sep 28 '23 at 11:50
  • 4
    https://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. https://verifiedvoting.org/election-system/ess-votomatic/ says that they were in use up to 2014. – Mark Morgan Lloyd Sep 28 '23 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. – Walter Mitty Sep 28 '23 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 '23 at 15:44
  • Re/Edit: The Votomatic system had up to 960 positions, as number of valid positions depended on each election. Usually only every 3rd or 4th column was used.The system used blinders in the station to mechanically allow punching only valid holes (one could still screw up). Cards were printed accordingly. As seen here the cards were 'longer' than standard punch cards to hold extended areas for write in candidates as well as markings. Those would be cut and handled separatly while the 'front' was feed a standard reader. – Raffzahn Sep 30 '23 at 15:17
  • I've accepted this as the answer since (a) the Votomatic cards appear to be standard 80-col (although I believe other voting machines might not be) and (b) it's unambiguously the latest cited date in what has been an interesting discussion. – Mark Morgan Lloyd Sep 30 '23 at 22:42
  • The last time Votomatic cards were used in the US was in 2014 by two counties in Idaho. The cards used were not 80 column cards. The cards used variable sized squares, which sometimes did not align between columns. – Fred Oct 02 '23 at 09:02
6

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.

Will Hartung
  • 12,276
  • 1
  • 27
  • 53
  • 2
    https://en.wikipedia.org/wiki/NCR_315 appears to identify one of the NCR peripherals as being a rebadged IBM, and https://www.chipsetc.com/ncr.html clearly shows that NCR was using IBM 026 punches... as did just about everybody. – Mark Morgan Lloyd Sep 28 '23 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. – rexkogitans Sep 29 '23 at 06:55
  • As in the English "cockchafer", i.e. a Beetle with cock-ups. – Mark Morgan Lloyd Sep 29 '23 at 07:17
  • @rexkogitans Doesn't change the fact that VW Bug was the common name in the US. – Raffzahn Sep 30 '23 at 15:03
4

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.

supercat
  • 35,993
  • 3
  • 63
  • 159
  • https://en.wikipedia.org/wiki/Aperture_card cites an article from 2004 describing them as "Still Active, Still Vital". – Mark Morgan Lloyd Sep 28 '23 at 16:05
  • The USA Federal Govt. started moving off aperture card/paper in 1996. Ref. http://federalvoice.dscc.dla.mil/federalvoice/030924/tech.html – ubfan1 Oct 01 '23 at 15:44
3

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.

dave
  • 35,301
  • 3
  • 80
  • 160
  • 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. – Mark Morgan Lloyd Sep 28 '23 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 https://bitsavers.org/pdf/dec/unibus/DEC-11-HCRB-D_CR11_Mar72.pdf – PDP11 Oct 02 '23 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. – dave Oct 02 '23 at 18:20
3

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..

mike james
  • 81
  • 1
  • http://www.snee.com/bob/opsys/part5vmcms.pdf section 21.3 is quite a good read describing a very elegant hack. – Mark Morgan Lloyd Sep 29 '23 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". – dave Sep 30 '23 at 02: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. – Mark Morgan Lloyd Sep 30 '23 at 06:14
3

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.

Eugene Osovetsky
  • 131
  • 2
2

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.)

arp
  • 171
  • 3
1

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.

camelccc
  • 645
  • 4
  • 9
  • 2
    There's also fairground organs, but neither of these use standard 80/96-col cards and that's what the question's about. – Mark Morgan Lloyd Sep 29 '23 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 02 '23 at 15:10
1

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.

supercat
  • 35,993
  • 3
  • 63
  • 159
  • 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. – Mark Morgan Lloyd Oct 02 '23 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 02 '23 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?" https://organforum.com/forums/forum/organ-marketplace/on-the-internet/794651-allen-tone-card-listing-in-florida#post794728 – Mark Morgan Lloyd Oct 02 '23 at 20:26