Very nice site and collection of resources! I hope you don’t mind if I showcase your attractive diagram:
Absolutely! Thanks, it took me awhile to think of a way to convey the idea of those two minicomputers being “compressed” into the 5100. I’ve worked with some old HARRIS systems that used 9-track tapes, but never had the honor of using any of the older IBM mini’s first-hand (at least in their base form, I’ll call them mini’s).
Reading through “the DP2200” book, it describes how in early 1970s IBM “strong-armed” the industry into only renting/leasing computers. That alone made it difficult for “upstarts” to compete (because you have to upfront a lot of money to build the system, and leasing money won’t come back in till over a year later – plus then having to deal with customers that don’t pay).
Another nugget of history we often forget: the IBM anti-trust lawsuit began in 1975 (here) , with a claimed violation of the Sherman Act. This was eventually withdrawn after years of trial (in 1982). This is interesting, because Alvin Ginsburg refers to this in his letter about the 5100: "My next hurdle were the anti-trust lawyers. They were concerned that building BASIC into the unit would open us to charges of bundling, locking out competitor’s who might want to sell a BASIC interpreter. "
( if anyone knows or has contact with Alvin Ginsburg of IBM, would love to get in contact! hope he is still around, but I haven’t been able to find a contact )
1 Like
Great site!
For those who may lust for a bit of hands-on experience, there is Norbert Kehrer’s IBM 5110 online emulator (now hosted on GitHub):
https://norbertkehrer.github.io/ibm_5110/emu5110.html
(Maybe also worth a link on the page?)
1 Like
This is good example of how CPU’s in the first half of the 1970’s out paced memory at
the time. Intel had 1024 x 1 Drams in 1973 and the 8008 cpu with 16kb address space.
4k rams, 8080 in 1975. Intel 8086/16 K drams 1979.
The base unit of any thing was inexpensive compared to a product with use full memory, and or I/O since you only had about 1/4 of the full memory for a base unit. memory chips
seemed to be always about $20 each back then. Core forget the price, as they pushed faster core, not lower price.
Ben,
The Apollo program was essentially over by the time the prototype that evolved into the 5100 was created, so I can’t see how there would be any relation between the two.
Another example of a processor with 8 bit ALU but 16 bit registers and addresses is the RCA 1802, though the Z80 and 6809 might also partly count as such. I agree that the term “hybrid 8 bit” is more descriptive, but everyone just calls them “8 bit” machines.
A pure 8 bit machine would use 8 bit addresses, like the Kenbak-1, for example.
but despite all that, it doesn’t have a “clear screen” command! (but think about why that is: it is emulating a line printer system that would have no concept of clearing a screen)
If it’s emulating a line printer, then, in theory, the form feed character should act as a clear screen.
I just stick to alu width. Many 16 bit computers ,just had 32K of memory with the top
bit for indirect.
That was one of the differences between the emulated Nova in the Xerox Alto machine and the actual Data General Nova. The Alto used 16 bit addresses for 128KB instead of 15 bits plus an indirection bit. A few other Nova clones did the same thing.
Speaking of the Nova, when talking about “alu width” we should add “as seen by the programmer”. The original Nova only had a 4 bit physical ALU but the programmer saw a 16 bit one. The Z80 also had a 4 bit ALU that looked like an 8 bit one. The 68000 had three 16 bit ALUs that looked like a 32 bit one.
1 Like
Well with my FPGA cpu design I have 1 32 bit alu / data path, 16 bit bus.
20 bit Addressing. Just doing the final tweeking of the design now for a MSI/LSI
version using 2901 alu’s , 3 512x8 roms and 3 22v10’s replacing 82S100’s
~ 21 chips for the control card, ~ 26 chips for a 16 bit alu card.
82S100’s replaced ~ 6 TTL chips each for microcode decoding. ~39 chips
for the control card.
I favor a simple slower 32 bit design with more address space, rather than a complex fast 16 bit design (PDP11) and a 16 bit MMU.
More talk would drift from IBM and similar machines in the UK.
The KENBAK-1 replicas have become popular this year 
(anniversary year)
Yes, 1972 was end of Apollo (and probably the “writing on the wall” in major reductions in budget to space-science projects, since “mission accomplished”; although there was Skylab work in the mid-1970s, ramp up in satellite work - like Voyager 1977, and increased use of onboard computers in aerospace (F-14/15/16, etc.).
I don’t think the suggestion is that any IBM 5100 was involved with the Apollo craft itself, but maybe that SCAMP used some “space age derived technology” like the ability to have microcode at all (as an intermediate solution between TTL discrete and the eventual microprocessors). That is, the metals and techniques involved to reliably have a “static memory” to store bits (at an increasing capacity and performance) helped make a full-featured portable computer system possible. Maybe it’s not an explicit relationship to Apollo, but an indirect one.
That makes the term ‘PALM’ itself a bit nebulous. Is it the instruction set itself (i.e. the set of 16 main opcodes described in IBM 5100 MIM Appendix C), or the notional idea of some kind of metal sandwich used to store microcode? (where that microcode implements a few instructions, like ADD immediate, JUMP, etc). Then also finding the boundaries in the environment on where that can be used reliably (relative to heat, ambient radiation, etc).
In the GENASM manual from 1977 (IBM internal manual on the “General Assembler”) it uses the term “6 PALM” which I have to assume is a kind of version number, implying earlier iterations of PALM - so how much earlier? (maybe I’m wrong and the “6” just refers to a section number, or refers to a “class” of systems that use a “category 6” set of opcodes?) The exact quote is:
"GENASM PALM
IT TAKES ABOUT 45 MINUTES ON A 5100 TO COMPLETELY PROCESS ALL OF ‘PALM’ TO PRODUCE THE PALM ASSEMBLER WHICH IS IN ‘6 PALM’ "
Initially I thought this all meant compiling an assembler to run on the 5100 - but now I’m thinking this doesn’t mean what I thought. The full manual is here:
Maybe someone more experienced can help decipher this.
Haven’t read the link, but it sounds to me like a statement of performance: the assembler itself, as an example of a significant program written in assembly language, can be assembled in 45 minutes.
I love Norbert’s emulator, it just needs a feature added to script inputs. I found Corti’s original emulator baseline at the IBM museum FTP site, and noticed he already had a condition to support cross-compiling it to the Wintel environment. So I ripped out the X11 GUI parts and used text-based pdcurses, to run the PALM emulator from the command line. That works, then added some command line arguments to be able to script inputs. That ended up being a little harder than it sounds, since the IBM 5110 doesn’t use standard ASCII, and how to invoke the special key presses to enable DCP and such? So in the text file input, some interpretation is done to apply the special keys.
Conceptually, that same PALM emulator should work on the IBM 5100 executive ROS – and it actually does. However, there is an issue/difference in how the 5100 transitions to the active language. So a viable IBM 5100 emulator is close but after trying to resolve that issue for a few days, I had to move onto other projects.
Hmm, good idea. But… the IBM 5100 isn’t using ASCII natively, so can’t assume 13/10 for CR/LF. But, “FF” should just be some other native code. The thing is, in the Executive ROS disassembly, IBM themselves “clear the screen” by loading “0200” (address of the memory mapped CRT content) and writing two spaces 512 times. However, somewhere in the MIM I thought I recall the “Display Device” had an OUT control bit labeled as “clear screen” - but I haven’t been able to find that again.
So may misspeaking to say “emulating a line printer” - but rather, emulating systems whose main interface is via a line printer. (some of those systems did have a kind of vector screen at some point - but generally programmed through a serial I/O, not really a native/normal part of the system)
In both systems, here is their “clear screen” code…
IBM 5100 Executive ROS code...
; Clear entire screen
1066 8E02 LBI R14, #$02
1068 0EED MLH R14, R14
106A 8E00 LBI R14, #$00 ; top of screen
106C 8C10 LBI R12, #$10 ; 16 rows
; ----------
; Clear part of screen
; R14: address
; R12: number of rows
106E 2F53 MOVE R15, ZERO (for 5100, ZERO is blank/space)
1070 813E LBI R1, #$3E ; last two columns? (x3E == 62)
1072 CE1D SNBS R14, R1 (is R14 pointing there?)
1074 FC00 SUB R12, #$01 ; yes, next row
1076 5FE1 MOVE (R14)+, R15 ; clear two characters
1078 CC03 SZ R12 (end last row? if yes skip next)
107A F00B BRA $1070 ; -> -$0C(R0)
107C 0024 RET R2
; ----------
********************************************************
********************************************************
IBM 5110 Executive ROS code...
; Clear screen
1DFC 8E02 LBI R14, #$02 (init 0x0200 start address of screen)
1DFE 0EED MLH R14, R14
1E00 8E00 LBI R14, #$00
; Clear to end of screen
1E02 8940 LBI R9, #$40 (for 5110, #$40 is blank/space)
1E04 099D MLH R9, R9 (use R9 as " ", two spaces)
1E06 59E1 MOVE (R14)+, R9
1E08 8106 LBI R1, #$06
1E0A CE17 SBSH R14, R1 (have we reached 0x0600?)
1E0C F007 BRA $1E06 ; -> -$08(R0) (no, keep looping)
1E0E 0024 RET R2
; ----
But another interesting tidbit: in BASIC (on the 5110), the screen itself is assigned a file number, so you can “open” that file and write to it (that is, it had a “stream” mode – which is kind of “unix-ish” in the “everything is a file” sense). A special “FLS” file on the 5110 made an interface to use BASIC to do things like make the speaker beeper, turn on/off the display, change character sets, and to query the available “work space” memory. (the 5100 had a somewhat similar capability - when issuing a “RUN” command, you do could “RUN P=D” and then any PRINT FLP commands would go to the Display instead).
There was also the “RD” (round) command, to specify how near two (float) values could be for declaring them equal. (the IBM 5100 BASIC manual explicitly compares itself against the System/370 BASIC - which it say, the 5100 didn’t innovate these features, but leveraged much of that mainframes BASIC)
Regarding the Apollo and high-end technology discussion: It may be also interesting to consider the lower end, top-down dynamic. In 1976/77 IBM was working on various home computer concepts, and I guess, if any of these had become reality, we may recognize one or the other element of the 5100 in them. (The Aquarius project seems to have come pretty far with production prototypes and a concept for a software ecosystem, but was canceled over doubts of the real-world viability of bubble memory.) Had any of this happened, we may regard the 5100 as an important intermediary step in scaling down mainframe technology and bringing it to the masses.
PS: I’d really love to see someone with access to the IBM archives coming forward with something like “The untold story of IBM’s struggle for the home computer.”
On the speculative side, this may provide a reason for IBM being so secretive on the PALM technology, as this may have played a role in protecting a closed software ecosystem.
Regarding the BASIC implementation: A notable feature are multi-line user defined functions with RETURN and FNEND keywords. (I’ve always found BASIC’s single-line DEF FN somewhat limited.)
For example, from Harry Katzan’s 5100 book, a multi-line factorial function with multiple returns:
0010 REM FACTORIAL
0020 DEF FNF(N)
0030 IF N≠0&N≠1 GOTO 0050
0040 RETURN 1
0050 K=1
0060 FOR J=2 TO N
0070 K=K*J
0080 NEXT J
0090 RETURN K
0100 FNEND
(Mind the syntax of the condition at line 0030, using “|” and “&” for OR and AND, respectively.)
And no, you can’t have recursive function calls, but you may call other user defined functions from within a user defined function.
On the other hand, you may still have single-line user defined functions using assignments. This dual nature of the DEF FN keyword is quite peculiar and seldom found in BASIC.
0010 DEF FNX(A,B,C) = (A*A+B)/C
1 Like
Just to break it down…
"IT TAKES ABOUT 45 MINUTES ON A 5100 " assuming this refers to the IBM 5100
"COMPLETELY PROCESS ALL OF ‘PALM’ " why is ‘PALM’ in a quote? (recall the 5100 only has a single quote, not a double quote - was the document itself done in a 5100?) What is it processing? Imagine you had a source code that was larger than 16KB (or even 64KB with comments), so it can’t completely fit in main memory. So we have to process portion of the code at a time through files? Maybe ‘PALM’ is that set of files? (but PALM is a concept, and IBM is making multiple processors – like special processors in their own high end 9-track tape controllers – and GENASM has input options to specify certain aspects of the target processor)
“PRODUCE THE PALM ASSEMBLER” assuming this means an assembler like in the modern sense – which is, something that takes string mnemonics and converts it into machine code. But how does it work once produced? i.e. how do you “run” it, and (presumably) give it command line arguments such as “what data product to assemble.” Is the assembler itself a binary product that is then loaded into main memory? Imagine you’re developing the Executive ROS itself - absolutely that’d be in some PALM assembly (and with comments, I imagine that would quickly be a file {or set of files} larger than 32KB). But… I imagine the assembler to convert that to machine code would be ran on some pre-existing mainframe, not the 5100 itself? [ like when using modern MCUs – we compile to the Arduino or ESP32 on the desktop PC, and serially upload the resulting binary; we don’t compile, assemble, link on the embedded device itself ] [ or maybe that’s the amazing thing: once the assembler was first made on the mainframe, the 5100 {or an earlier intermediate since the prototype} was able to “run itself” { run its own assembler} ] [ compilers are like that - the folks developing visual studio use visual studio itself; or I recall the Borland folks saying “Delphi now compiles itself” ]
"WHICH IS IN ‘6 PALM’ " and the mystery, was there a “5 PALM”, “4 PALM”, etc?? (Nintendo had developer-versions of its Famicon system with special features, maybe “6 PALM” just refers to an internal special system build tailored to those doing things like writing the Executive ROS – hopefully they didn’t need to compile this assembler very often! but if found bugs in the code generator, or saw a more optimal way to generate the machine code, it’s 45min to “process” the code changes?). But again, why is ‘6 PALM’ in quotes? One nuance about the IBM 5100 executive ROS (and 5110) is the very first 4-bytes indicates what address offset to start running at (i.e. it’s not an instruction, it’s data). Maybe other IBM processors had different policy/convention, and maybe ‘6 PALM’ just refers to that particular IBM 5100 convention.
Looks like 6 PALM refers to the 6th file on the tape, which contains the definition for the PALM assembler. Whereas 3 GENASM refers to the 3rd file on the tape, which is the GENASM program.
It seems reasonable to me to expect a native assembler - yes, cross-assemblers were common and remain common, but a self-contained computer system needs a native assembler.
And yes, for small-memory machines, it’s normal not to expect to read the whole of input into memory - it is indeed normal to open a file for read and proceed by reading bytes or records or sections. It’s also normal to use one or more intermediate files, or more than one pass.
Brilliant! And to imagine that original Executive ROS assembly is sitting out there, either archived on some 9-track tape or on a QIC tape. Corti produced an annotated version of the disassembled Executive ROS, maybe about 50% commented (mingled in with the emulator source code), and also of the disassembled APL ROS code - both very insightful, even if incomplete.
The spec on the QIC tape for the 5100 (in the MIM) say the max “file size” is 0x3FFF (16KB). So even if you had a decked out 64KB system, the work is spread across 16KB files.
So, I imagine the 45 minutes is also “tape-deck-movement-time” (loading portions of the assembler program itself, loading the portions of data to be assembled, and writing the binary products back out to other files) and not just strictly CPU processing time.
The original SCAMP didn’t use QIC; I was always curious if it was using a regular audio tape. My understanding on the DP2200 was it wasn’t using “regular” audio tapes either (likewise for the MCM/70). i.e. if one did travel back to 1973, I’m not sure where you’d get suitable tapes for those systems (if not audio tapes, then can’t use a regular record store?)
I don’t think that regular audio tape (as in compact cassette) had been in option. The very first computers to use compact cassettes for storage (according to Wikipedia) were the HP 9821A / HP 9830 (both 1972). So this was then very new technology and only used by what was then considered an electronic calculator. Moreover, HP was then still a rather low-end computer manufacturer. I assume, not what IBM would have considered a persuasive recommendation in 1973. (Also, where’s the potential for serious over-engineering in audio cassettes? 
)
I got in contact with one of the original developers SCAMP!!
He confirmed, the SCAMP prototype did use a Norelco (Phlips) “carry-corder” (a consumer tape recorder from a few years earlier). This is also mentioned in a 1983 PC Magazine article by Friedl, and that article has a photo of SCAMP opened (the only image of that I’ve ever found). And, this contact said that indeed that “carry-corder” did work but was so unreliable, during demos of the prototype – they’d have to attempt reloading the software many times. So, once it finally loaded correctly, they’d just leave the machine on overnight to be ready for the demo the next day. Keep in mind, that’s the 1973 prototype. The 1975 production used a 3M QIC (DC300), completely different tape system (that 300ft of tape could only store up to 207KB max - but within a few years after 1975, you could get longer tapes that fit in the same package).
1 Like