Appears to be an ADA-based workstation?
Is this the same Rational as Rational ClearCase etc as acquired by IBM back in the day? Crazy
Looks like it:
https://en.wikipedia.org/wiki/Rational_Software
> Rational Machines is an enterprise founded by Paul Levy and Mike Devlin in 1981 to provide tools to expand the use of modern software engineering practices, particularly explicit modular architecture and iterative development. It changed its name in 1994 to Rational Software, and was sold for US$2.1 billion (equivalent to current US$3.59 billion[1]) to IBM on February 21,[2] 2003.
It is a truly astonishing software development environment which with a a single key-press can answer questions like "what other code is affected if I change the default value of a parameter to this function". (Think about that one for a second!)
And if you add the cost (around $5000 per workplace), it becomes even less understandable.
It also required a designated CC admin or several admins.
But if I were the pilot in an F-22 or the Space Shuttle, I probably would want it to be even more rigid :-)
It's important to keep in mind the context of this machine and the software it was used to develop.
It processes 64bit data and 64 bit type information about that data in parallel, in hardware.
It is also object oriented in hardware, there is no linear address space or VM-tree,
Three left in the world, plus one mostly empty chassis.
My Covid19 project was writing a software emulation of it, starting from 400 pages of schematics, because the instruction set is not documented.
And yes, I'm way behind on documenting it, because I also have a life :-)
Wow, it's hard for me to imagine a CPU with such high level instructions. Were these per-process, like virtual memory on a modern processor? Or was there only expected to be one executable running on the machine at a time?
> My Covid19 project was writing a software emulation of it,
Where did you get to? Do you have a link?
So it's not that the ADA primitives were baked directly into TTL.
It's somewhat related to the Itanium model where the compiler generates a Very Long Instruction Word.
Microcode is a standard way of implementing CISC, but this machine took it further than usual.
The machine actually has both an ALU as we know it, called the "VAL" board, but it also has a second unit, which runs in parallel on the "TYP" board, which does checks and operations on the data types of the data on the VAL board.
That means that the compiler can just emit a "ADD" instruction, and leave it to the microcode to figure out if it is adding two floating point numbers, two integers or a floating-point plus an integer and if the numeric type has a range, the result will be checked to fit inside that range.
So the comparison to the Itanic is not helpful. Itanic was a pretty standard CPU which forced a lot of constraints and complexity into the compiler.
The R1000 does the opposite: The compiler gets to emit code which operates on the types as the Ada language defines and knows them, and the hardware+microcode translates that into action.
Grady Booch donated some internal documents to us, and they contain a couple of references to "Incredibly Complex Instruction Set Computer" and they're not half wrong about that.
And it had a nice portrait orientation monitor like some early Xerox workstations (the PARC ones like Alto, and the fancy word processors like 850 and 860 IPS).
Later, starting as a teen, I was working for Cadre, a competitor of Rational on workstation software engineering tools. The company started with Apollo Domain workstations (not rolled their own), and, by the time I joined, had added Sun, HP, IBM, DEC, and MS Windows.
The Cadre site I started at (a spinoff of Tektronix, which did high-end hardware in-circuit emulators with CASE workstation frontends) was practically across the street in the OGI science park from Verdix, which, a bit like Rational, did Ada development tools and related neat systems work like (IIRC) secure compartmentalized workstation technology.
It was an exciting time in computers, and in hindsight, as a kid I saw engineers picking up and applying broader mixes of skills than we usually do in today's fairly rigid skills silos.
Notably it needs KiCad to run and takes ~140 hours to boot.
Seems like the reason for KiCad and the slow operation is that the emulation occurs at a really low level, and they've written a program to digitize all of the computer's schematics and convert them into netlists (which is then converted into systemC components for the emulator): https://github.com/Datamuseum-DK/R1000.HwDoc
a video explaining the process?: https://www.youtube.com/watch?v=oMRTr0bPuOA
On an Apple M2 CPU it runs around the same speed as the real hardware now.
(The first version based on the unaltered hardware schematics ran 4000 times slower than real hardware, it's been quite a journey :-)
Supposedly the first verification of the first Ada compiler was done on a system made with the Pascal MicroEngine.
Ada Compiler Validation Summary Report: Rational Environment
aaron_m04•5mo ago