Subject: Re: The Importance of Terminology's Quality
From: (Rob Warnock)
Date: Thu, 21 Aug 2008 09:11:48 -0500
Message-ID: <>> wrote:
| (Rob Warnock) wrote:
| >In the LGP-30, they used hex addresses, sort of[1], but the opcodes
| >(all 16 of them) had single-letter mnemonics chosen so that the
| >low 4 bits of the character codes *were* the correct nibble for
| >the opcode!  ;-}
| >[1] The LGP-30 character code was defined before the industry had
| >    yet standardized on a common "hex" character set, so instead of
| >    "0123456789abcdef" they used "0123456789fgjkqw". [The "fgjkqw"
| >    were some random characters on the Flexowriter keyboard whose low
| >    4 bits just happened to be what we now call 0xa-0xf]. Even worse,
| >    the sector addresses of instructions were *not* right-justified
| >    in the machine word (off by one bit), plus because of the shift-
| >    register nature of the accumulator you lost the low bit of each
| >    machine word when you typed in instructions (or read them from
| >    tape), so the address values you used in coding went up by *4*!
| >    That is, machine locations were counted [*and* coded, in both
| >    absolute machine code & assembler] as "0", "4", "8", "j", "10",
| >    "14", "18", "1j" (pronounced "J-teen"!!), etc.
| Whats os interresting about all this hullabaloo is that nobody has
| coded machine code here, and know's squat about it.

Think again! *BOTH* of the two examples I gave -- for the LGP-30 & the
IBM 1410 -- *WERE* raw machine code, *NOT* assembler!!! Please read again
what I wrote about the character codes for the instruction mnemonics
*BEING* the machine instruction codes. For the IBM 1410, the bootstrap
code that ones types in:

    v         v

*IS* raw machine code, *NOT* assembler!! [See my previous post for
the meaning of the fields of that instruction.] The IBM 1410 is a
*character* machine, not a binary machine, so each memory location is
a (6+1 bit) character. As a result, one can [and *must*, during bootup!]
type absolute machine code directly into memory using the console
typewriter [an only-slightly-modified IBM Selectric, as it happens].
The fact that -- for the sake of user convenience -- the hardware
supports manual entry of machine code into memory by the operator
in a form that closely *resembles* assembler (but *ISN'T*!) was a
deliberate design feature.

Similarly, the characters you type for the LGP-30's opcodes *ARE* the
opcodes, at least by the time they get into the machine, since when
typing in code (or reading it from paper tape) one sets the I/O system
to "4-bit input mode", in which the upper bits of the characters are
stripped off by the I/O hardware during input. Thus when you type a
"Bring" (load) instruction such as this ["Bring" (load) location 0xd7c
(track 0xd, sector 0x31)]:


you're typing *RAW* machine code, *NOT* assembler!!  You see, the
lower 4 bits of character "b" -- the "mnemonic" for "Bring" -- were
binary 0001, the *same* as the lower 4 bits of the digit "1" (and two
other characters as well). So when you typed a "b" in that position
in "4-bit input mode" you were typing the same thing as the character "1"
which was the same thing as *binary* 0001 which was the absolute machine
opcode for the ""Bring" instruction!!  "No assembler required" (pardon
the pun).

| I'm not talking assembly language.

Neither was I. The fact that for the two machines I mentioned
absolute machine code was somewhat readable to humans seems to
have confused you, but that's the way some people liked to design
their hardware back in those days -- with clever punning of character
codes with absolute machine opcodes (for the convenience of the user).

| Don't you know that there are routines that program machine code?

What do you mean "routines"?!? For the above two machines, you can
enter machine code with *no* programs ("routines?") running; that is,
no boot ROM is required (or even available, as it happened).

| Yes, burned in, bitwise encodings that enable machine instructions?

The two machines mentioned above did not *HAVE* a "boot ROM"!!
You had to *manually* type raw, absolute machine code into
them by hand every time you wanted to boot them up [at least
a little bit, just enough to load a larger bootstrap program].

| Nothing below that.

You're assuming that all machines *have* some sort of "boot ROM".
Before the microprocessor days, that was certainly not always
the case. The "boot ROM", or other methods of booting a machine
without manually entering at least a small amount of "shoelace"
code [enough the *load* the real bootstrap], was a fairly late


p.s. Similarly, the DEC PDP-8 & PDP-11 were also originally booted
by manually toggling the console switches in order to deposit a few
instructions into memory, and then the starting address was toggled
in and "Start" was pushed. It was only later that a boot ROM became
available for the PDP-11 (as an expensive option!) -and only much
later still for the PDP-8 series (e.g., the MI8E for the PDP-8/E).

Rob Warnock			<>
627 26th Avenue			<URL:>
San Mateo, CA 94403		(650)572-2607