Questions and Answers

In October, 2017, I had an E-mail conversation with Paul Ruizendaal, who posed a number of questions about Marinchip Systems' history, hardware, and software. This summoned some memories of that distant epoch which I thought might be interesting to others, so I'm sharing them here.

I have slightly edited the questions and answers from the original E-mails in the interest of clarity.

When did Marinchip get started? 1977? Did it get founded to do the M9900?

I started working with the Texas Instruments TMS9900 microprocessor in late 1976. First, I built a simple single-board test platform on a prototype board. This ran a debug monitor I called TIOS which was written from scratch and cross-assembled on a Univac 1108 with their meta-assembler (which could be configured to generate code for any machine). TIOS was stored in two 2708 UV-EPROMS you can see above the CPU chip. The board connected to an ASCII terminal via the DB-25 visible at right. The reset button is at the right, below centre. The board was supplied by +5 and +12 via the connectors at the top. The TIOS ROM monitor eventually evolved into the boot PROM on the S-100 PROM/RAM/SIO/RTC board.

The original M9900 CPU card, MDEX, Editor, and assembler were introduced at the Second West Coast Computer Faire in San Jose, California, in March 1978. This was the first and last Computer Faire ever held in San Jose.

What was initially the leading rationale? The hardware or the software? Or was Marinchip envisioned to be a systems company at that time?

The goal was to sell a “real” computer: a PDP-11 class machine with a rational architecture, 16 bit arithmetic, multiply and divide, and good context switching, which would be compatible with S-100 memory, peripherals, and enclosures, all of which were rapidly advancing and falling in price. This was to be a platform supporting a Unix-like operating system with usable systems- and application programming languages. The object was to deliver a personal computing platform which provided power comparable to a timesharing terminal connected to a mainframe or minicmputer running Unix. Marinchip would make its money selling the S-100 boards which enabled the system. The basic software would be bundled with the boards; since it couldn't run on any other hardware, software piracy would not be a problem.

I guess the 9900 CPU board was developed first, as you don't mention another 9900 based development system? What tools did you use for prototyping and board layout, etc.?

The original system was wired up on the proto board linked above. The next step was the S-100 prototype, which demonstrated running with 8-bit S-100 memory and peripherals. This was designed by hand, a wire list prepared from the logic diagram, and wire wrapped onto two S-100 prototype boards with a big connector between the two boards. These were installed in an IMSAI chassis and run with a Cromemco Bytesaver 2708 PROM board (which could also program the chips), an 8K static S-100 static RAM card (North Star, as I recall, but I may be wrong), and eventually an Alpha Micro floppy disc controller connected to an 8 inch Persci dual floppy drive. This system connected to an ASCII terminal via an IMSAI serial port card. The front panel of the IMSAI, which worked by pumping instructions into the 8080 CPU, was not usable with the 9900 processor: only the reset switch worked. Debugging had to be done using the PROM monitor, which was derived from TIOS but extended to allow booting from the floppy drive.

What was the development history of each of the packages? My current understanding is something like this:
(i) First you developed an assembler on the Univac, perhaps in Fortran.

The assembler was created by writing definitions for the 9900 instruction set for Univac's meta-assembler. The meta-assembler used a different syntax than TI's notation, so I changed the assembly language syntax to comply. Programs were assembled and linked on the Univac, and then downloaded into the RAM of the 9900 machine (single-board or S-100 prototype) by a feature in TIOS which intercepted the data stream from a dial-up modem connection to the Univac and interpreted the binary data. This was done with the same serial port used to connect to the ASCII terminal, via a switch.

(ii) Next came MDEX, developed on the Univac and debugged on the real hardware. This suggests it was written in assembler, but one note in the Autodesk files mentions MDEX being rewritten as native—that may have referred to its utilities, though.

MDEX (which was originally called Sisyphus Junior) was written with the Univac assembler, downloaded via the mechanism described above, and tested on the S-100 prototype machine. Debugging was via the PROM monitor in TIOS, which allowed examining and changing registers and memory without the need for a front panel.

MDEX, the Assembler, Linker, Editor, and Debugger, were all originally written on the Univac assembler in its syntax. The Assembler, however, used the standard TI syntax for its instructions. When I wrote of MDEX being rewritten as native, I was referring to converting the syntax of the assembly code from that used by the Univac cross-assembler to native TI syntax which my assembler used and moving the development from the Univac to the 9900 machine itself. By some time in 1979, all development had moved to the 9900 and the Univac was no longer used. I had access to the Univac because I was working for a company that owned it and used it moonlighting. I had to move development to the 9900 because I couldn't quit my job and lose access to the Univac until I did so.

In parallel with this software development, Fred Camerer, who had joined the company as an equal partner, redesigned my two-board S-100 prototype into the single-board design which became the M9900 CPU. Here is a picture of the board.

This was designed by hand and drawn as a logic diagram, from which the board was laid out using red and blue tape at 4X scale. Part of the final layout was done on my dining room table.

Once we got and debugged the first run of five printed circuit boards, I replaced the two board wire wrapped prototype in my IMSAI chassis with the first M9900 CPU. It was completely compatible from the software standpoint, but also had the ability to use 16-bit memory through the handshake protocol Fred Camerer invented, which eventually became part of the S-100 standard (IEEE-696-1983). It also brought out the 9900's CRU peripheral interface to unused pins on the S-100 bus (of which there were plenty), which allowed access to the serial ports on the PROM/RAM and eventual Quad SIO cards.

(iii) I guess a new assembler was written native to MDEX and a debugger along with it, both in assembler.

Yes, initially on the Univac, then converted to native syntax so they could be built with the 9900 assembler. A simple line-oriented text editor was developed the same way.

(iv) Then perhaps came the META port (by hand I presume) and the development of SPL; I think the front end of SPL may have been written in META. SPL seems to have become the Marinchip systems language.

It's a bit more complicated than that. META was written in assembler. As I recall, it was the first piece of M9900 software written entirely using the native tools, but it's possible WORD (an nroff-like text formatter) preceded it.

Mike Riddle, who worked for a computer store which had started to sell Marinchip boards and software, developed SPL as his own moonlighting venture, which he called Evolution Computing. I think he used META as the front-end, but I'm not sure at this remove. I don't think I actually ever saw the source code of SPL, though it's possible I might have looked at it when we were considering porting it to the 8086 in the formative stages of Autodesk. Marinchip eventually distributed SPL, paying Mike Riddle a royalty on sales, but it was his product and responsibility. SPL never became the Marinchip development language: initial releases were very flaky and the language constantly changed, breaking existing code.

(v) The BASIC interpreter and the line editor were written in SPL?

No. The original BASIC interpreter (eventually “Extended Commercial Basic”) and line editor were written in assembly language, with the line editor originally developed on the Univac.

(vi) The BASIC compiler seems to have a first pass written in META/SPL and a second pass in QBasic itself. How was that second pass bootstrapped?

I recall QBASIC as the only Marinchip product which used SPL. (Interact was an Evolution Computing product, not developed by Marinchip.) I don't recall at this remove how the second pass worked. My guess is that the first version of the compiler generated assembly language which you had to manually assemble with the assembler, and once that was working we added a second pass, which may have been written in QBASIC, to eliminate the need to run the assembler and directly generate relocatable code.

(vii) The screen editor was then written in QBasic?

Yes, the screen editor (WINDOW) was entirely written in QBASIC. Much later, Kern Sibbald re-wrote it in C and extended it into what became the Autodesk Editor (used extensively in house but never marked as a product). An earlier re-write into 8080 assembly language by Duff Kurland was briefly marketed by Autodesk for CP/M systems under the name AutoScreen. When AutoCAD took off, we abandoned development and marketing of AutoScreen.

(viii) Sequential Pascal was probably ported by hand coding the VM for it?

Yes, I hand-coded its VM in assembly language. Brinch Hansen's compiler generated threaded code which was exquisitely optimised for the PDP-11's addressing modes. The TMS9900 was far less efficient in interpreting this code, and Sequential Pascal was very slow. Also, it had no separate compilation feature, so developing large programs was painful.

Does any of the source code for the above programs survive?

It depends upon what you mean by “survive”. All of the source code exists on 8 inch floppies which reside in a store-all in the United States which nobody has ever entered since 1991. These floppies are in MDEX or NOS format, which was only documented in the source code for those operating systems. Whether anybody could get a drive running to read the floppies or whether they would be physically readable after so many years is anybody's guess. There are probably paper listings of some of these programs in the store-all, but I was never big on paper listings.

All of the documentation was written in Marinchip WORD. Printed copies of the manuals probably exist in the store-all.

How does NOS/MT relate to MDEX? It seems to be a further development, or was it a (compatible) rewrite from scratch? It was influenced by Unix, were you a Unix user at the time?

NOS/MT was a completely independent development, although it was compatible with the MDEX boot PROM and could read and write MDEX-format floppies as well as its own native file system format (which could support larger capacity hard drives). NOS/MT (which was originally named “Sisyphus”, hence “Sisyphus Junior” for MDEX) was the operating system I originally intended for the M9900 system. MDEX was the means of allowing it to be developed in native mode on the 9900, and of getting the boards on the market to bring in revenue before NOS/MT was ready.

NOS/MT was intended to be a Unix-like multi-user system, which would eventually become as powerful as Unix. It suffered from arrested development when it became clear TI was not going to develop the 9900 architecture into something as capable as the 68000 or 8086.

I was not a Unix user, but had read the entire Bell System Technical Journal devoted to it. One of Marinchip's goals was to deliver such a system to the personal computer user. Recall that at the time AT&T charged US$25,000 for a commercial Unix license (although it was free to educational institutions, which resulted in its dominance there). I never actually used a Unix system until the mid-1990s, when Autodesk began porting AutoCAD to Sun, Apollo, and Silicon Graphics workstations, and eventually adopted Sun platforms for our software development.

Why was it named Network Operating System? The surviving binaries do not seem to support networking of any kind.

The original concept was what Sun Microsystems later called “The Network is the Computer” (this was, of course, years before Sun was founded in 1982). Using the fast synchronous communication facilities of TI's serial chip, which was used on the Marinchip Quad SIO board, would allow networking NOS/MT systems and for their file systems to be shared among machines interconnected by these serial links. This would allow, for example, a large and expensive hard disc connected to one machine to serve as file storage for other machines connected to the network. I had spent the early 1970s developing a multi-node communication network for the Univac site (Information Systems Design), so I already had all of the communication protocols (which I had designed myself) in hand to build this network. The overall concept was similar to what Apple introduced in 1985 as AppleTalk for the Macintosh and Lisa. I never got further in development of the network features than demonstrating the synchronous data link between two M9900 systems in different rooms.

This was envisioned entirely as a local area network, although it would have been possible to connect remote systems over a dial-up link, but at the speeds of modems of the epoch, painfully slow.

As far as I know, no manuals for NOS/MT survived other than a brief SYSGEN guide. Was other documentation ever written?

There was a complete programmer's guide, documenting all of the system calls and built-in commands. I don't have a printed copy, but there may be one in the store-all.

Does any of the source code for NOS/MT survive?

See the earlier remarks about the store-all.

In The Autodesk File you write: “Ten years ago today, I was celebrating not just the dawn of the 1980s, which I hoped would be an improvement over the Souring Seventies, but also the first successful multi-user test, achieved minutes before midnight, of NOS/MT, the Unix-like operating system that seemed to be the future of Marinchip, my company at the time. What was to eventually become AutoCAD was, on that night, less than 2000 lines of undocumented code in an obscure language for an unpopular computer.”

I assume that the last line refers to INTERACT, and apparently it was 2,000 lines of SPL code for the M9900 at that time. It would be cool if we could resurrect that version of Interact on the Cortex, as it would show the very origins of AutoCAD in a working state. Did the source to that 1979/80 version of INTERACT survive?

There is a printed listing of the Interact source code in the store-all. It is in SPL, and you'd have to find a runnable SPL compiler or port it to another language. That's what the first versions of AutoCAD were: ports of the SPL code to PL/I (for the 8080) and C (for the 8086). The first version of AutoCAD we shipped to customers in 1982 was far extended beyond this initial port of Interact.

Also in The Autodesk File you refer to “node boards” for the Z8000 CPU, for the 9995, the 99000 and the 68000. From what I understand the Z8000 board was completed, the 9995 board half completed and the 99000 and 68000 boards merely contemplated. What exactly were “node boards”, and how were they different from plain CPU boards?

Node boards were to be single board computers which integrated a CPU and memory, and possibly a serial port, on a single S-100 board. You could plug one or more of these into an M9900 system and configure a multi-user, multi-processor system where each user could have his own dedicated CPU, and all shared a common file system supported by the M9900. These boards could support different CPU architectures, and were ideal for cross-development, since you could use a common set of development tools hosted on the M9900 and then test and deploy on the node boards. The architecture of NOS/MT would treat the node boards precisely like machines on the local network but, since they were on the same bus, many times faster.

The Z8000 was completed as a prototype only (this wasn't a Marinchip product, but was developed by Dan Gochnauer doing business as Optimistic Systems), and it wasn't exactly a node board, but rather a CPU with worked like the M9900. Dan ported MDEX and some of the development tools by rewriting them in Z8000 assembly language. Mike Riddle was doing something with the 9995, but I never saw even a prototype of what he was doing. The main plan was for the 68000. It was clear by that time that TI was no longer a serious player in the general-purpose microprocessor business.

I should mention that part of Marinchip's original concept was a gamble based upon Texas Instruments' strategy in the microprocessor business. Since the TMS9900 was a single-chip implementation of their TTL minicomputer line, I expected them to eventually drop the hammer on these upstarts like Intel and MOS Technology by delivering not only a true 16 bit processor which was competitive with the PDP-11, but also a full suite of software, which included Fortran and COBOL compilers, development tools, etc. at an affordable price, perhaps even free to establish their processor as an industry standard. If and when that happened, Marinchip would be ideally positioned to deliver systems which could exploit that software on a platform which used the much more economical S-100 hardware and its myriad peripherals. That gamble didn't pay off: TI remained greedy and afraid of cannibalising its minicomputer business, and never released the software to TMS9900 users, with the result that they ended up a has-been in both the minicomputer and microprocessor businesses.

by John Walker October, 2017 Fourmilab Home Page