Where did the 80x25 text terminal size come from?
Quick answer: It's one Punch Card Per Line
Resulting in 24/25 lines (cards) per screen when using a 4:3 tube and a reasonable font as dictated by proportions fostered since Roman times.
Prior to the 1981 release of the IBM PC, the VT05 (72x20 1971), VT52 (80x12 1974), and VT100 (80x25 1978) text terminals were used on many Unix machines and the PDP-11 (probably the most widely used computer at the time).
(Depends on the definition of widely, wouldn't it? *1)
You're maybe focusing a bit to much on the IBM PC and mini computers here. For one, there have been many terminal developments even before DEC started business, and even more when they did. And even more, common memory is defined by many parameters(*2).
However, just as many other computers used widths of 60 (type writer), 132 (wide printer), or convenient memory page sizes of 32 or 64.
It might be a good idea not to mix up different devices made for different usage. And I'm not sure what a memory page size does here (*3).
Type writers are meant to write letters, something no one really thought about when doing computers in the 1950s, even less before. Then again, as with terminals, there is a whole class of typewriters, called tabulators, that did provide a carriage for 132 columns (*4). Like with mainframe terminals, they were usually only seen in back office.
In general, there were two sizes defined in in pre-electronic data processing: 80 characters per block for storage and processing (and sometimes printing) and 132 characters for printing.
The 80 character came from IBM's extended punch card design of ~1930. The 'original' Hollerith card of 1890 had already evolved from 24 columns (characters) to 45 while keeping the basic structure. Still customers continued to ask for ever more storage capacity (*5). So one of the engineers Mr. Watson assigned the task came up with the idea of rectangular holes instead of the round one used up until then. Rectangular holes allowed (almost) doubling the density (*6) form 45 to 80 symbols while keeping the size of the card constant. This happened to be an important decision, as it only required modification on parts of the existing designs, while most of the production chain from paper manufacturing over card storage up to the mechanical parts of processing could be kept the same. Just punch thorn size and timing had to be modified (*7). Also around 1930 Remington doubled the capacity by keeping the round Hollerith holes, but storing two characters per column (90 characters per card). There were other formats as well. At the end of the 1940s (partly due the war) IBM's 80 column card was the industry wide accepted standard.
In 1920 the Tabulating Machine Company (originally The Hollerith Electric Tabulating System, now part of CTR Holding) introduced a new printer-lister system with 132 columns. While not the first to do so (*8), it became the de facto standard, thus setting the 132 characters for tabulating output - what later evolved into mainframe printers (and everything else meant to produce a ledger output).
For data processing on terminals it was a natural goal to display at least one basic data record - read, one punch card - in one display line, so data fields can be viewed as columns. The IBM 1050 Data Communications System is a typical example of an early (printing) terminal system. At the center with an adapted IBM Selectric typewriter, able to print 80 columns.
In fact, while the Selectric is usually seen as an office typewriter to handle standard letters, one major design goal was the capability of printing 80 characters, so it could also replace other data entry and print systems for IBM Mainframes. Mainly ofc, everything based around the IBM Electric typewriter, used for the same role since the 1930s - unlike Selectric also available in 132 character width. (*9)
That manufacturers of typewriters for simple home/office usage did go for design decision with a shorter carriage so only letter size paper (and thus less characters) can be used is unrelated here.
80 columns were therefore also the goal for CRT based terminals. There was some development needed before a 80x24 could be archived. Memory constraints being not the least (*10).
Even IBM struggled with the 2260, the grand daddy of all screen based terminals introduced in 1964. The basic Model 1 displayed 6 rows of 40 characters, while the Model 2 could do 12 line of 40 characters. Only the high end Model 3 could display a whole punch card in a single line with 12 lines of 80 characters. That setup with 3 models was mainly due memory reasons. Less characters per screen means one controller could support more terminals with the same memory. In fact, The 2260 didn't even have screen memory at all. The display was only a CRT and keyboard. Screen memory and picture generation was all within the 2248 control unit - stored in acoustic memory - and transmitted to the CRT.
Since the 1964 2260 Model 3, 80 characters was the standard for mainframes and the goal for everything else.
Many early manufacturers did first ship with terminals with less then 80 characters and 24 lines. Sometimes even in large numbers.
The well known (*11) Datapoint 2200 did support as well 12 lines of 80 character. The similar but earlier Cogar C4) did only 8 lines with 32 characters ... one reason why it never got as popular.
Still, without 80 column support they were less than desirable for any serious usage (aka mainframe related) beside specialized data entry. A general purpose terminal needs to support at least the most common data structure at once.
In fact, DEC's VT series does neatly show the struggle for 80 characters and might be used as an example of non printing terminals toward the 80/132 character per line goal:
- The original VT05 of 1970 offered 72x20 characters in a 4:3 fashion.
- The VT06, essentially a Datapoint 3300, offered 72x25 characters
- The next iteration as the VT50 of 1974 with 80x12 already reached the 80 characters goal, but mostly due memory constraints, only 12 lines were displayed. Since a 4:3 CRT was used, the resulting picture looked a bit like having every other line blanked out.
- A bit more than a year later the VT52 of 1975 supported 80x24 characters. Literally 'filling the blank lines' and even more, as the greatly (for back then) expanded memory allowed to store a window of more than 24 lines, resulting in the ability to scroll up and down thru this buffer (*12).
- In a 'last' step the VT100 of 1978 introduced a 132x24 display, so now every 'professional' output could be shown.
Now the 25 lines is a different but related story.
Technically the gold standard of all CRT based terminals, the 3270, did not display 24 but 25 lines. Just this 25th line was (usually) not accessible to user programs, as it held status information about the connection, session status or terminal/keyboard mode. So on a user level every competitor had to offer (at least) 80x24, which most did. The IBM PC text adapters were designed with terminal emulation in mind. Thus the hardware had to provide a 25th line. A line general available for any program.
That's something not restricted to the IBM PC. Many microcomputers before did offer 25 lines because of that. Heck, even the DEC VT100 did when it was transformed as VT180 into a CP/M machine.
Conclusion: 80/132 character come from the age of punch cards, 24/25 lines due the 4:3 dimensions of common CRTs
TV's became quite blurry approaching 132 (B&W@625px) char so that seems to be the hardware maximum width upper limit.
The whole TV system is made to display continuous greyscales/colours as they appear in real life pictures, not sharp contrast as needed for text display. That's why electronics, coils, and tube coating for dedicated text displays differ from such made for TV purpose. A TV set, including the full path can barely produce 40 characters per line (6/7px per char) in acceptable quality.
*1 - If most used is by computing power, or amount of users, then a single /370 installation might outclass a hundred PDPs. It's much like baking a peanut cake takes many more peanuts than one with a coconut filling takes coconuts :)
*2 - And it's a strange thing anyway. DEC's mini computer terminals were outsold by a magnitude by mainframe terminals like IBM's 3270. While mainframe terminals where used in huge installations in companies and government were only seen by a rather small number of employees working them every day all day, DEC products gained a hold in universities where Joe Average was introduced to them for a short time and moved. In most cases to jobs with (back then) no contact with terminals for the rest of their life.
*3 - even less I can see where pages of 32 or 64 - at least not when amended with a unit of byte or KiB - could be anywhere convenient.
*4 - Depending on the manufacturer there have been many different sizes even way past 200 columns. But 132 and 136 became somewhat a standard during the 1930/40s
*5 - The request for ever more storage capacity (and processing power) by users seam to be a constant during all history of data handling.
*6 - It's a bit like the move from FM to MFM for floppies, isn't it?
*7 - In the late 1960s, IBM tried to introduce a 96 column card together with the System/3 series. Here not only density got improved but at the same time the size got almost halved. The idea was quite like the 3.5" floppy: A card should well fit into a shirt pocket. It did prove unsuccessful as no one else, not even within IBM, adopted it. While the System/3 eventually evolved into the AS/400, the 96 column card was outlived by it's predecessor
*8 - Before CTR's printer tabulator there was the already quite successful Powers Printing Tabulator. Again not the first, as the Royden system of Peirce Patent Company already had one - not to mention custom developments like done at Prudential Insurance).
*9 - Since an IBM Electric was used as genuine terminal for the very first DEC machine (PDP-1), it could be argued that DEC's 80 column orientation is originated here :))
*10 - That's why Tectronix introduced storage tube based terminals. First the 600 series devices which later evolved into the 4000 terminal series and further into the well known 4010 family. No dedicated memory needed for screen refresh - but also no real way to do things like scrolling.
*11 - For being the source of all evil ... err x86.
*12 - It also started the downward spiral of decadence by offering lower case letters. Something real programmers (and users therefore) never needed in the first place.