old processor architectures [was Re: The Strange Birth and Long Life of Unix - IEEE Spectrum]

[D. Hugh Redelmeier]

| From: Scott Allen <mlxxxp-Re5JQEeQqe8AvxtiuMwx3w at public.gmane.org>
| To: tlug-lxSQFCZeNF4 at public.gmane.org
| Date: Wed, 7 Dec 2011 09:56:06 -0500
| Subject: Re: [TLUG]: old processor architectures [was Re: The Strange Birth
|     and Long Life of Unix - IEEE Spectrum]
| Reply-To: tlug-lxSQFCZeNF4 at public.gmane.org
| 
| On 6 December 2011 23:28,  <phiscock-g851W1bGYuGnS0EtXVNi6w at public.gmane.org> wrote:
| > Personally, I found programming in PDP-8 assembler a huge chore and never
| > got the hang of it. The 6502 instruction set was a gift from god by
| > comparison.
| 
| The company I started working for, back in the late '70's was founded
| by a few people who used to work at IBM.
| 
| The head technical guy was used to working on IBM System/360 class
| machines, but we were developing products based on the 8080 CPU. The
| 8080 based product was also suitable as a development machine. Rather
| than create a development environment using 8080 code, he wrote a
| System/360 instruction set emulator for the 8080 and then proceeded to
| write an editor, 360 assembler, job control language, etc. in 360
| assembly code. So we had an emulated System/360 running on an 8080
| microcomputer.

Wow.  That's awesomely goofy.

/360 code was engineered for a quite different world.

The machine language was better than the 8080's in a number of ways
but not in code density, which mattered when your address space is
only 64k.

Emulating would have created an enormous hit.  If you were willing to
pay that, might as well get something worthwhile for the cost --
UCSD's pcode comes to mind.

| Products that we sold that used an 8080 (or later Z80) CPU also ran
| this emulator and much of the application code was written in Sys/360
| assembler.

One of the best features of /360 machine code, as compared to 8080
code, was that you could reasonably compile to it so high-level
languages were more practical.  So to write in /360 assemble was dumb.

| Some parts of the 8080 product applications ran native 8080 code,
| which was created using an 8080 cross assembler written in Sys/360
| assembly code. So we had an 8080 system emulating a Sys/360 which ran
| a cross assembler to generate 8080 code.

That takes the cake: writing all that systems software, for no
leaverage.  Wow.

One example where it kind of made sense: I understand that the IBM
5100 had an 8080, emulating a /360, so that it could run APL\360.
This made a great implementation of a powerful language available
without a mainframe.  It did not take over the world.

The MCM/70 was an APL machine implemented on an 8008 or 8080.  It was
interesting but didn't take over the world.  A local product: the APL
was originally York APL.  Apparently no source code of York APL still
exists.  For years, I had a big pile of scrap paper that had been a
listing of it, but when I went to look for it to give to the York
computer museum, I couldn't find it.

York APL was written in /360 assembler first but rewritten for the
MCM/70 hardware, as I understand it.

<http://www.cse.yorku.ca/museum/collections/MCM/MCM.htm>

| My experience was similar to Peter's: I preferred working with 8080
| assembler over Sys/360 assembler.

I imagine it is partly a matter of what you deeply understand.

/360 assembler was more powerful and better for larger programs.  Its
regularity made it a better target for compilers of conventional
languages.

The 8080 was quite workable for humans.  But it hit annoying walls
quickly.  Like lack of address space, no indexing, almost no 16-bit
support, let alone 32-bit support, no memory protection, no invalid
opcodes.

The worst part of /360 assembly programming was talking to the aweful
OS APIs.  Second worst: worrying about base register coverage for your
code.
--
The Toronto Linux Users Group.      Meetings: http://gtalug.org/
TLUG requests: Linux topics, No HTML, wrap text below 80 columns
How to UNSUBSCRIBE: http://gtalug.org/wiki/Mailing_lists