The Manchester Mark 1 was the world's 1st stored program computer, prototyped as the Small Scale Experimental Machine (nicknamed 'Baby') which was built at Manchester University in 1948. Now 50 years on, the university has built a reconstruction of the Baby, and declared a small competition. The competition (now closed) was to write a piece of software to run on the Baby, and the best program (judged by one of the original constructors) was run on the actual machine on the anniversary of its first running.
Since the baby is so old, it is quite a perculiar piece of hardware. It only has 32 store lines each of 32 signed bits (memory). It has a Control Instruction (CI) register of 32 bits, similar to todays Program Counter (PC). Also a Present Instuction (PI) register, again of 32 bits that holds the instruction (or function) currently being executed. Then there is of course the obligatory Accumulator (32 bits yet again). That is the sum total of the hardware for the Baby.
The instruction set consists of 8 functions (though function 4 and 5 are identical SUB instructions) which give just enough flexibility to be able to write a useful program - the first ever program took nearly an hour to execute completely, and was used to find the highest common factor of 2 input numbers.
Quite obscurely the bit order is the 'wrong' way round on the baby,
with the Least Significant Bit (LSB) being the left most bit, numbering
0-31, from left to right. This was to make arithmetic carry circuits easier,
and was common place in early computers, although these days, the MSB tends
to be the right most bit. eg.
AXXXXXZ A is taken as being bit 0, and Z as bit 6
1101001 on the Baby = 1+2+8+64=75 (left bit is worth 1 and right bit is
worth 64)
1101001 on the ARM = 1+8+32+64=105 (left bite is worth 64 and right bit
is worth 1)
To aid in this competition, a Baby assembler, and emulator called M1SIM has been written for the PC by Andrew Molyneux, and although there is also a java emulator, there is no emulator that will run easily on an Acorn (without a PC card).
Babe
Babe is a fully integrated assembler and emulator of the Manchester Mark 1. It can take assembly language text files written in any text editor, and convert them into the series of 1s and 0s needed for the computer, or in this case the emulator. This program is then run, and then emulates exactly the actions of the Baby.
Screenshot is of Babe, having executed the highest common factor program.
The emulator is actually slightly slower than the original (on my A5000) but since it has a full disassembler, and decimal as well as binary display, it's hardly surprising. The original baby display the results on a CRT, unfortunately they are a little hard to emulate correctly, so the display is a representation of the original, rather than a true likeness. The object code files produced by the assembler are also suitable for use with the official emulator on the PC supplied for the competition.
Babe v0.04 28/3/98 (59Kb ZIP file)
Most of this will come in handy for writing programs on the Baby.
Programmer's Reference Manual (30Kb Text file)
- all you'll ever need to know about the Baby.
Introduction
to Programming the Baby - a nice easy introduction
Baby emulators on the
PC
The Programming Competition
information
Entry details
for the competition
SSEM
rebuild project - information about the reconstruction of the Baby
Computing's 50th
Anniversary Celebrations
Prize winning programs (from the competition)