I still have my Poly-88 that I bought in 1978 from Hoboken Computer Works, Hoboken, NJ. Bob Radcliffe was the proprietor.
Nice small box, orange cover, 5 “Altair” slots (The S-100 name came later.) And a 16K dynamic ram. Bob couldn’t provide keyboards or moniter. The hobby was leaning at that time on AT&T teletypes, model 33. But he had a video card that did 16 lines of text, about 40 or 50 characters per line which fed a TV via coax. I bought a specific Hitachi (??) TV & added a $25 mod kit that Bob could provide. It worked fine. To test all this I built a small box with 7 toggles & a pushbutton to send ascii into the keyboard jack. AND IT ALL WORKED! My goal was a specific software I built, the interpreter: tiny-C. I had a partner by then, Scott Guthery, and we together wrote a 200 page ring-binder book: ‘Tiny C Owners Manual’. Three printings. Sold 2500 over the next 4 or 5 years at $40. So here is my question: Does anybody out there remember any this? And I have more story if you would like some.
Tom Gibson
(This “reply” is a continuation of my tiny-C post.)
I finally got a keyboard at the 1976 Trenton Computer Festival. And by then I learned of 3 others at work (Bell Labs, Holmdel, NJ) that had Poly-88s, and we met at lunch frequently. In fact as I completed each card (they came as kits) I would visit one of these new buddies who would substitute my card for his in his already working system. And my Poly-88 box needed assembly, too. And to enter assembler code I had Processor Technology System #1 on a 300 baud mag tape. It took 20 minutes to load.
Finally I could actually write code: 8080 assembler.
How do you write an interpreter? First you need a design. I did not want a full C language. What I wanted was something that is best summarized as a first programming training language, but not Basic. I applaud the work of Kemeny and Kurtz. They gave non-programmers access to computing. And that is good. My thinking was aimed at as simple as basic but a proper step towards becoming professional. C is an inspiring goal, how about a simplified C. My 10 year old was coding in Basic, but he would also look at my programming at home while munching a cookie right beside my ear. I was using a portable dial-up terminal connected to my Bell Labs department computer. I had Fortran experience (10 years) and was learning C and finding it very pleasant.
But the build process of Basic is so simple compared to Fortran or C. Type some code, then run it, then opps! fix it and run again. When the bit of code seems ok give it a name and save it. That’s simple. But with Fortran or C or any other ‘full’ language you can’t just run it. You must name, save, and compile it, clear compile errors, import stuff and link it properly, etc.
Cruft! Basic hides that cruft behind a simple command: ‘run.’ My tiny-C hides the cruft. The chip was an 8080, so just char, int and arrays/pointers for either. It was tiny whether or not I called it that. It took me an hour to design, and a few days to get running. Soon my son had his code running with this simple training-wheels software.
But now my watching his coding disclosed two difficulties. He had troubles with curly braces simply because they required use of the shift key. It felt natural for him to type code blocks in square brackets. So I broke from C syntax: square braces for code blocks, and arrays used parentheses for both declaration and element access. But what about function names? No change, they kept their use of parentheses. Unlike C a tiny-c name followed by left parenthesis can be a function or an array element name. The parser can handle that.
So tiny-c is no longer a subset of C. Every array name is a pointer. So the syntax is simplified: char|int () defines ‘name’ as a character or integer pointer respectively. Its value can be set to any integer value.
Very interesting to hear about your design decisions as things progressed!
Thank you, Ed. I have still more story. Should I continue with a chain of replies, or is there a better way?
This is a good way - there is precedent!
(continuation of continuation)
But my goal was still not reached. To write a tiny-c program requires an editor. Most editors were the line-number type. Every line was prefixed with a 5 digit number and a space, and they could not be removed. At work I was using Unix vi; it was so much nicer. I preferred a pure text editor.
So in assembler I wrote a very simple one: I could scroll a pointer (dot arrow), type text, delete a whole line (dot-d).
Any text not starting with dot was entered. It was still hard to use. I needed search & replace & other stuff. Using the assembler version I rewrote this barely useful editor in tiny-c. So the PPS was born: program preparation system. From then on I used the PPS to improve the PPS. When done it had 10 commands, but several of these had variations depending on their arguments. Counting all the variations upped the count to 24.
Thanks, Ed. Here is my 2nd continuation…
(And another (3rd)…
Friends, including new friends we met at festivals, had different computers, The 6502 and 6800 were getting popular for example. I encouraged others to port my 8080 code to different chips. In fact Scott Guthery was the first to do so, porting to his DEC LSI-11. We advertised in Byte magazine for awhile, but our best results came from ads in Dr. Dobb’s Journal. We also got pretty good returns from Kilobaud and David Ahl’s Creative Computing.
I found a news release in a 1978 issue of Dr Dobbs:
‘TINY-C’ INTERPRETER FOR 8080 AND PDP-11
News Release Received: 78 June 22
An interpreter for a subset of the C structured programming language which runs on both DEC PDP-11 and Intel 8080 processors is available from Tiny-c Associates. The tiny-c Owner’s Manual includes a complete reference description of the language, a tutorial walkthrough of a training program, lots of sample programs including comments on their programming style, and a description of the Program Preparation System. It also includes commented source code listings of both the 8080 and the PDP-11 interpreters, and a chapter on how the interpreter works.
Tiny-c is intended primarily for the education and hobbyist markets. The tiny-c language handles integer and character data, and arrays of either type. Other features include compound statements, if-else and while statements, global and local variables, pointer variables, and functions. Functions may have arguments and may return results. Recursion is allowed. The interpreter also recognizes calls to functions written in machine language. These, too, may have arguments and return results. A minimum of 16K bytes of memory is recommended to run tiny-c.
The package includes a Program Preparation System with which the user can write, edit, run, debug, store, recall, and link tiny-c programs. The PPS includes a standard library of tiny-c software tools. The PPS is written in tiny-c. Thus it serves as an example of a significant use of tiny-c, and is also easily adapted to a user’s or operating system’s requirements.
The Owner’s Manual is available for $40 from Tiny-c Associates, P.O. Box 269, Holmdel, New Jersey 07733. Machine readable copies of the interpreter are available separately on several formats of tape and disk.
Edit: other findings, in a 1980 issue:
A Small C Compiler for the 8080’s by Ron Cain
and
Structured Programming, C and tiny c by Tom Gibson and Scott Guthery
Wow, there are a surprising number of print references for this.
I’ll have a Wiki article up shortly…
Tom, what was it actually written on? I see the initial date of 22 June 1978, which is the same year you mention for the Poly-88, but then in your next post above you noted "got a keyboard at the 1976 ". Is that a typo perhaps?
It was a printed 3-ring binder document, 300 pages including listings. The binder was 3 inches thick! Three printings, 2500 copies total. Price = $40. We also sold 300 baud cassettes at $20. Sales were steady for about 2 years, then slowed. Our wives took orders & shipped, and so slowing down was not bad. We needed it to happen. After the last shipping I ended up with about 2 dozen remaining copies. I still have one.
Nice to see the software lasting longer than the hardware.
Ahh, yes. The keyboard thing. I was coding pencil on paper. Keyboards were just not available until 1976. Bought one, a kit, and got it working. And FINALLY I could enter code and debug. We finally had product in 1977.
I remember my first test program, a one-liner… MC(MC(2),1)
Tom
Opps! Typo. Bought my Poly-88 in 1976, not 78.
Tom