I have used a lot of different computers, operating systems, and programming languages over the years, so here is a little bit about some of them.
Copyright © Pete Jinks
My first experience of programming was in my 4th year at grammar school, when I picked up a one-page description of a very simple assembly language that some-one had left lying about. It might have been called "Mini", but I can't really remember. It was for an imaginary machine, and I think it only had about a dozen different instructions. It must have had some registers, and some addressing modes like literal and direct memory access. It must also have had some sort of array or indirect access mechanism. Anyway, I wrote and endlessly rewrote my very first program, which factorised numbers and found primes. I never had access to the simulator, so I never actually ran this program - just rewrote it.
My next experience of programming must have been in the next year or so, when I picked up a copy of "Teach yourself Fortran" (or some similar title, part of the "Teach Yourself" series) in my local library, and did. I remember having a deep sense of recognition when I read about the various control structures like IF and DO - these were exactly the ideas that I had had to invent in my factorisation program. Again, I did not have access to a real computer at first, and just used Fortran to rewrite my program.
My first experience of actually using a real computer must have been in my 6th year at grammar school - my maths teacher happened to have learnt machine code (i.e. using binary numbers to write programs!) in his degree, and took half-a-dozen students once a week for a couple of hours after school to use an IBM 1130 (or here) in the nearby Medical School. This machine had 8K of 16-bit words, 4K of which were used for the operating system, leaving 4K available to run programs. We used punched cards to input our programs, written in Fortran 2, and a line-printer to get the output.
Unfortunately, I made the typical novice mistake of wanting to do too much too quickly - I got my factorisation program working on the first evening, and then started changing it faster than I could debug it. I got hung up on the memory limitations, and spent endless ingenuity on working out how to pack multiple values into the 16-bit integers, using just arithmetic operations, which were all that Fortran supported. I suspect it was triggered by me trying to do something using arrays of booleans and being appalled by the waste of memory.
I can't remember the details of what happened next, but we must have made progress, as the lady who stayed late to run the computer for us offered to teach us how to program it in assembly code, and gave us some lessons. I suspect the first thing I did was recode my pack and unpack operators to use logical operations and shifts.
About the same time, I started to use the local University computer - a KDF9. (More details.) This had 16K words, each of 48 bits. It also used 6-bit characters (no lower-case). Again, this was mainly programmed in a dialect of Fortran (Egdon Fortran or Egtran), using coding forms to create punched cards, and with line-printer output. I have a vague recollection of also using Algol 60, but I might be confusing this with another machine I used a year or so later. I also learnt KDF9 assembler and wrote some small programs in it.
We each had to do a project during the year before A-levels (Maths, Physics
and Chemistry), and I chose to write a Fortran program to do algebra. If it
had worked correctly, I could have input some polynomials, and had my program
perform operations like addition, multiplication and so on. Unfortunately, I
also chose to pack and unpack the coefficients into the 48-bit words, and my
program got so complex that it never fully worked. However, it did work well
enough to get a prize!
I remember another prize-winning student in my year built a working calculator
out of TTL.
Also about the same time, my father's department invested in their first electronic programmable desktop calculator, a Wang 600, and I put a lot of effort into trying to program it to do something interesting - it had a keyboard, so you could interact with it to some extent, but the only output was a paper roll coming out of a printer about 20 columns wide.
After my A-levels, the school allowed us to take part in all sorts of activities, and I spent a week learning to program in Algol 60 at a different local University. I think the machine might have been a Prime or a Nova. I can't remember much about this week, except being surprised by how small the computer was - essentially just an upright cabinet plus a console. I think we used paper tape rather than punched cards, but otherwise the input/output and interaction were as primitive as ever. I can't have been very impressed by Algol 60, as I have no memory of choosing to use it for anything I wanted to do - I think I found quoting keywords tedious, and I hadn't appreciated the joys of recursion and proper scope rules.
When I went to University to do a Pure Maths degree, they had just invested in a brand new ICL 1906A. This had a time-sharing system (MOP) - you could actually interact with the computer using keyboard and teletype, and even using paper-tape, but mostly we still had to use punch cards and line-printer output. It had 24-bit words and 6-bit characters. It ran Fortran 4 and Algol 60 and had a command language, George. It also had an assembly language called PLAN, which stood for "Programming Language for Nineteen-hundreds" or something like that. The manuals were amazing - the KDF9 had had two, one for assembler, and one for everything else. The 1906A had a wall-full of manuals, and I remember spending many afternoons in the library sorting through them, trying to work out what was useful. I used the 1906A for Fortran and also some assembly code programming, but the most fun was writing George macros. I was so carried away by the thrill of on-line access that I wrote some simple macros to allow people at different terminals to communicate, but they were too awkward to use for anything real. (This was a while after the invention of email, but I hadn't actually heard of it yet.)
At the end of my second year, after the exams, we were encouraged to
do something different, and I helped the Computer Science department
to prepare for the coming Open Day - not just for potential students,
but for anyone who wanted to come and see what the University did. I
used Basic on their Modular One
to program a moon-lander program, using on-line keyboard and teletype
interaction. I remember the biggest problem was trying to make it as
easy to use and robust as possible. Apparently, this had
16K [later 24K] words of main memory (16 bits/word, 0.75 microsecond
cycle time), 1M word fixed-head disk (17 ms average access, 7
microseconds/word transfer rate), paper tape reader (1000 c/s), paper
tape punch (120 c/s), and a multiplexer for 8 lines (for local
teletype terminals). The cost was £23,000 after various
discounts.
They also had a PDP-8 and I learnt how to program it in assembler, but
never used it for real.
After I graduated, I came to Manchester to do Computer Science, where I used:
PDP-11s: assembler;
(still my favourite assembly language)
Cyber 70: Pascal;
MU5
(and
here)
(+ICL 1905E): Algol 60, MUSS, MUSL, assembler;
(I eventually got to boot it up, which involved a box full of relays to power
up each of the cabinets in sequence, a paper-tape reader, and pressing various
buttons in the right order.)
MU6G:
MUSS, MUSL, assembler;
ICL 2900 series Estriel
Transputers: Occam
Sirius (Intel 8088): Pascal, assembler;
Atari ST (Motorola 68000): Pascal, assembler;
(my second favourite assembly language)
Sun workstations: Solaris (Unix), Pascal, C, Csh, SML;
PCs: Linux, Windows, Bash, make, C, Java;
MU0 assembler and ARM assembler via emulators;