In Quiz - which of the 1977 trinity for you?, @EdS asks which of the Apple II, TRS-80 (or TRS-80 Model I, as it was later to be known) and the PET 2001 you’d pick if you were a 15-year old in 1977 and had enough to buy any one you wanted.
After thinking about it a bit, I ended up choosing the TRS-80, and here I describe in detail why that is. I’ve chosen to post this as a separate thread because a) this post is quite long, and b) I’m open to discussion of these general types of features amongst all pre-1980 microcomputers, not just the trinity.
So what’s so great about the TRS-80?
Text Display
The biggest selling point for me is that the TRS-80 display has a wider text line: 64 characters rather than 40. When programming (my primary activity), overly narrow screen lines are a total productivity killer for me. Consider looking at some assembly code in a simple editor: I’ve reproduced below a few typical lines (representative of, but not actually, real code), with column numbers and a vertical line just after the 32nd, 40th, and 64th columns.
|123456789 123456789 123456789 12|3456789 |123456789 123456789 1234|
| | | |
|002 via2 equ $f200 |; base a|ddr of 6522, 16 regs |
|003 vddrb equ $02 |; VIA po|rt B data dir. reg. |
|004 via2reinit4 sta via2+vddrb |; top ha|lf input, rest output |
Now the TRS-80 does have fewer rows (16) than the other two (24), but especially when editing code you often “lose” at least some rows due to line wrapping. (This is a frequent and major problem for me in EDASM on the Apple II, and even to some extent in BASIC.)
And further, for situations where you do need to prioritize the number of lines over line width, you can always write some code to split the screen into two halves, giving you effectively a 32 column by 32 line display. That seems like a nice option to have.
I should probably also mention here that the TRS-80 and the Apple II required (relatively simple) hardware modifications to allow the display of upper and lower case (and, in the case of the Apple II, input of lower case). The PET included both from the start, but a bit of a mess with the character set: it actually had two sets, the correct one had to be selected to see lower case, and the upper case letters changed position between the two sets.
Keyboard
When it comes to the keyboard, the major loser of the three is obvious: that original PET keyboard is going to utterly destroy any hope of productivity. Who cares what characters it can generate if you can’t type on it? This was fixed in later years by introducing new models with the “business keyboard,” which would probably be the best of the three, but that’s not available in 1977 when we’re making our purchase.
Between the Apple II and the TRS-80, ostensibly the Apple II keyboard wins for the programmer. Neither has a full ASCII keyboard (the Apple II is missing [\_`{|}~
, but the TRS-80 is additionally missing ]^
and ESC and, far worse, has no control key (though it does generate ^C with BREAK, I believe).
However, hiding underneath the covers is a key difference that makes the TRS-80 keyboard far more powerful. Unlike the Apple II, which has a keyboard generating ASCII characters via fixed hardware in the keyboard itself, the TRS-80’s keyboard is actually just a matrix of switches scanned by the CPU.
This is a major advantage because you can write your own code to scan the keyboard and remap the keys to whatever you wish. This is not terribly difficult: when you enable the line for keyboard scan you set a bit of the address bus corresponding to the row you’d like to scan and on the data bus will appear bits matching the keys in that row that are depressed.
There are some restrictions on what keys you can depress at the same time and still get correct scanning, but you can always distinguish any two keys, so this allows you to make any arbitrary keys into “alternate code” keys. The down arrow key is conveniently placed to the left of the “A” key and would make a good candidate for the control key.
So with just a bit of software hacking, the TRS-80 keyboard can generate the full ASCII character set. While the Apple II could be modified (via a fairly trivial hardware hack plus software) to generate lower-case characters, there was no easy way to get it to generate the full ASCII character set.
A secondary advantage (though perhaps not so important given my lesser focus on gaming) is that you can detect not just keys being struck, but their depression, hold and release. This is mainly useful for games where, e.g., you could move in a direction as long as the key for that direction is held down, and stop when the key is released, but it might be useful for other purposes as well.
Cost
Though cost wasn’t an object in the original post, it’s clearly important in real life. Even if you have enough money to buy any of the three computers, there’s always more to buy to expand your system, such as memory, a printer, an EPROM programmer, and the like.
The base price of the TRS-80, with 4K RAM, a 12" display and a cassette deck, was $600. That’s $200 cheaper than the PET 2001 (which came in the same configuration, with monitor and cassette) and more than $700 cheaper than the Apple II, which was $1300 before adding a monitor and cassette. (Though with the Apple II you could instead buy an RF modulator and use a TV, if you didn’t care so much about display quality).
Expanding RAM to 16K was probably about the same price for the TRS-80 and the Apple II. That would probably have been adequate for my earlier programming activities; remember, everything had to be saved to and loaded from cassette tape anyway. The Apple II could go to 48K and beyond in the chassis as it came, whereas the TRS-80 required a $300 expansion unit to go beyond 16K. But even here you end up paying less (still only $900 versus more than $1300 for the Apple II), not to mention that you get a floppy disk interface and parallel printer port thrown in. (Those would be an extra $200 on the Apple II.)
CPU
The Apple II and the PET used the MOS 6502 processor; the TRS-80 used the Z80. I must admit to a mild preference for the 6502, but that’s probably as much due to lack of programming experience with the Z80 as anything else. But with more registers and a larger instruction set, Z80 code is more compact than 6502 code, which would be a particular advantage in the early days of small RAM sizes (remember again, limited mainly by the practicalities of cassette storage). So while it doesn’t make a huge difference, the TRS-80 does come out slightly ahead here.
Graphics
For graphics, the PET seems the worst of the three. The character set has a wider variety of graphical symbols than the other two, but the block graphic characters are 2×2, giving a resolution of 80×48. The TRS-80, with its 2×3 block graphic characters and more characters per line gives 128×48. The Apple is still the clear winner here, with 280×192 resolution on a monochrome monitor (but only 140×192 on a colour monitor), but graphics aren’t all that important to me if I have a good text mode, and having 64 characters across rather than 40 is much more important to me.
Disk Drives
There were no drives available for any of these machines in 1977, but we can look forward to see how things panned out for the three systems.
The Commodore had the most expensive and the slowest drives, due to the drive unit containing its own computer and using a parallel interface and custom protocol between the PET and the drive unit. (It wasn’t all that much slower, the way the VIC-20 and C64 were with their serial interfaces, but it wasn’t as fast as the computer controlling the drives directly, either.) Commodore did have one big advantage in schools and computer labs: you could connect multiple computers to a single drive unit and let them share the drives. But that isn’t of much consequence to the home computer user. A more serious problem might be that Commodore’s DOS was run on the disk drive unit, not in the computer, which greatly limits hacking opportunities. (E.g., it wasn’t practical to write your own filesystem in order to get one that was faster or had better resistance against hardware failures, or just was able to read diskettes from some other computers.)
The Apple II comes out 30% ahead of the TRS-80 in diskette capacity (114K vs. 88K) and is similar in price if bought from the original vendor. But the TRS-80 had an advantage in using standard drives. (Apple had a customized disk drive and standard SA-400 drives could not be connected to the Apple controller without some serious hardware hacking knowledge.) This gave the TRS-80 a slight advantage at the start if you were willing to buy bare drives and build (or buy) the cables and PSU yourself. And I think the TRS-80 would allow you to hook up 8" drives as well, if you were willing to write the software to access them. (The SA-400 5.25" drive used almost exactly the same interface as Shugart 8" floppy drives.)
Where the TRS-80 really came out ahead of the Apple, though, was in the DOS, at least early on. Apple’s DOS was rather a hack and the public API for handling files was to print Ctrl-D to the screen followed by a command for the DOS, and then have the DOS essentially pretend to be the keyboard and screen for input and output to a file. Ouch.
Conclusion
For a programmer, unless you have a strong interest in graphics, the better display, more flexible keyboard, and additional toys you could get with the cost savings made the TRS-80 the home computer to get in 1977 and beyond, if you couldn’t afford a “real” S-100 machine and a good terminal.