STANTEC ZEBRA

Picture (50k JPEG) of the control console of the transistor-based version. The telephone-type lever switches, and, at the lower right of the main panel, the telephone dial, are both illustrative of the machine's origins. Note also the late-1950's "expresso bar" style chair, as compared with today's choice of computer office furniture!! (a large version, 1M JPEG, of the picture is available if you want to study every detail...).

As best I can recall it, the right hand part of the control console was the ordinary operating part of the panel, while the left hand part allowed hands-on debugging. One row of three-position lever switches here could be set to cause a conditional stop when a given pattern of bits (0, 1 or don't-care) came up. The dark window in the central part contained an array of tiny "magic eyes" (I forget their proper name, but they contained a filament and an area of phosphor, much like a miniature version of the "magic eyes" that were used in many a valve radio in earlier days), that indicated the contents of the interesting machine registers. L.E.D.s weren't in common use at that time (I was playing with this machine around 1964).

It would be great to get a copy of the Normal Code manual for this machine; I have several documents covering Simple Code (a semi-interpreted floating-point autocode which I was given to understand had been modelled on EDSAC Autocode, though I can't find any examples of the latter to verify that), but I've only got very limited documentation (mentioned below) on the "real" workings of the machine itself.

I still have an extremely scruffy copy of the "railway sidings" diagram (480kB, 2000px wide) which served as a machine-code programming manual, though unfortunately the diagram was too big for the copier that we had back then, so I'm missing some parts off the edges of the diagram; as you can see, it falls into four main areas: the Arithmetic Unit, the Control Unit, the Registers, and the Main Store (which on both of STL's machines were magnetic drums; some later models were fitted with core-store).

I can confirm from my old program listings, that registers 26-30 were one-bit(!) registers for the individual tracks of the 5-track paper tape (reading = tape reader, writing = tape punch), while register 31 controlled stepping the reader to the next character, or punching out the prepared character on the punch, respectively.

From the "railway sidings" diagram, one can see (at the upper right) the structure of a machine "word" when interpreted as an instruction:

    A K Q L R I B C D E V V4 V2 V1 W regaddr storeaddr

Each of the single-letter codes denoted a bit which controlled the similarly labelled switch(es) on the "railway sidings", and thus routed the data and instructions to the appropriate places. The diagram shows these switches positioned as they would be for their respective bits being ZERO: if the respective bit of the instruction was ONE then the switch(es) would be operated to their other position. In other words, a form of "microprogramming" (a term which I only met much later). Some switches (e.g the LR switch) are activated only when both of the specified instruction bits are ONE.

Program tapes were prepared in a special coding, "ZEBRA code", which contained only the characters necessary for expressing the machine instructions (and a few associated directives such as labels). This code was not used for representing textual content; the output and input of textual material was normally done in the code known as Murray or more formally as "IA2" (also known as CCITT#2), a 5-bit code which used letter-shift and figure-shift to cover the necessary repertoire.

The machine possessed a double-length accumulator (A and B), which could also be referenced (read-only) as two single-length registers (2 and 3). Registers 0 and 1 delivered fixed constants (0 and 1). Registers 4 to 15 were normal one-word registers, although registers 4 and 15 could also play special roles in the programming as indicated in the diagram.

One of the strangest aspects of the machine was the fact that it had no inherent concept of executing instructions by sequential store addresses! Instructions were of two kinds: those in which the A-bit was not set were known as "X-type", and had the address of the next instruction in their storage address field (possibly modifed by other data). Thus, all X-type instructions were potentially "jump" instructions, even if they only jumped to the next instruction in sequence.

Instructions in which the A-bit were set, on the other hand, were called "A-type" instructions, and the address field (possibly modified) referred to the address of its operand. After the execution of an A-type instruction, the ZEBRA did not simply execute the following instruction in sequence (indeed, this location would often contain data used by the A-type instruction): instead, it re-executed the previous X-type instruction, with its address incremented by 2! This so-called "come-back" instruction can be seen being built at the right-hand end of the "C-Register" in the railway sidings diagram, where 2 is added to the previous instruction and the result is shunted off to the "D register" for possible use later.

Roughly speaking, the purpose of the various bits was as follows (as best I can recall).

• A: determines whether the instruction is X-type or A-type, as already mentioned.
• K: routes data to/from the Arithmetic unit (if 0) or to/from the Control unit (if 1)
• Q: controls handling of the carry-bit
• L: causes accumulator left-shift
• R: causes accumulator right-shift (LR together have a special meaning)
• I: causes the accumulator adder/subtractor stage to subtract rather than add
• B: single-length accumulator operations refer to the A-accumulator (when 0) or B-accumulator (when 1)
• C: clear previous contents of the referenced accumulator
• D: data is read from (if 0) or written to (if 1) main store
• E: data is read from (if 0) or written to (if 1) the addressed register
• V: the condition test specified by V4,2,1 refers to the handswitches U1-7 (if 0) or to operand tests (if 1).
• V4,2,1 specifies the test (written as U1-7 if V=0).
• W: can't remember, sorry.

Other common conventions found in Normal code program source code were as follows.

• N: this denotes an X-type instruction whose store address field is set to the immediately following location. For example if address 1234 contained the instruction NBCQ, then this represented the machine instruction X1235BCQ.
• NKK: this somewhat eccentric notation created the A-type instruction whose operand was in the immediately following location (think base-2 addition: start with the N instruction and add two K bits to make an A bit!).
• Tn: e.g T5 - set a label for convenient reference later.

Paper Tape Codes

My tape code references for these 5-track tape codes have the three tracks positioned at the high-significant side of the sprocket holes, and the two tracks at the low-significant side. Looking at the corresponding character assignments, it's clear that at least some of the code designers thought in the same way, although later, when I became familiar with 7 and 8 track paper tapes too, it became conventional to always put the three tracks at the low-significant end, irrespective of the number of tracks on the other side of the spocket holes. Anyhow, here's a table, laid out in the original way and taken directly from a faded typescript. (For characters which might prove a challenge for some browsers, an equivalence has been added in parentheses.)

Notes

• LS = Letter Shift, FS = Figure Shift.
• "#" denotes RUBOUT, i.e all holes punched to correct an error and thus to be ignored.
• Mercury-code digits were assigned in sequence, except that the topmost bit was used to ensure odd parity. I no longer have any authoritative reference for this code. I was under the impression that the two Greek letters in the code were nu and eta, and I was a bit surprised to find that Dik Winter's page of 5-track codes has the first as "upsilon" rather than "nu": I've no idea which of us is right.
• In ZEBRA code, the letters B and C were used in Normal Code (i.e machine code) whereas the letters H and S were used in Simple Code (the autocode previously mentioned). A reference for the Simple-code version of the ZEBRA code may be found in "Het PPT-Bedrijf IX.2" of Aug.1959, of which I have a reprint: there in addition to the ZEBRA code it shows the "teleprinter code for output" (in fact IA#2), both of them documented in the same bit-ordering as I use above.

One bizarre technique was to write binary constants as if they were machine instructions: there were even special coding sheets for doing that (rather than writing constants in hexadecimal or octal, I mean). For example one of my programs from that time is for translating between two paper tape codes, and it contains the figure-shift and letter-shift translations packed together into words coded as an implausible sequence of machine instructions:

          ...
        X0PIBDV7
        A0PKQLRIDEU2
        X0PIDEV4
          ...

Other references

A friendly email from Jose F de Almeida in Portugal called my attention to a picture, and description (in Portugese) of the valve-based version at Uminho: after a couple of site reorganisations it disappeared, but later I found it again.

Original materials © Copyright 1994 - 2006 A.J.Flavell & Glasgow University