IBM
0200 IBM Education
Although IBM didn't reach its greatest success for another decade, when I joined it was already one of the most successful -- and richest -- companies in the world. This had come about largely because it had collected together a quarter million of the most capable staff in the world; of whom, uniquely, more than half had a degree.
Accordingly, when I joined for my basic technical training this was in effect at postgraduate level. I was due to spend between 18 months and two years in training before I would be let loose on IBM's customers. This length of training was unique for sales and marketing personnel.
Consequently, I was to spend my first 18 months more or less evenly spent between Richmond, where I would do my practical consolidation in the branch, and Sudbury Hill (near Greenford), where I would do my classroom training. Sudbury Hill was where I started.
In this way, my first day started at Sudbury Hill; in classroom with 30 others. The first thing we ever learnt was the instruction BALR, Branch And Link Register! This was a strange instruction then, and even later I still thought it a rather weird way to a start course for novices. But the IBM technical people never made life easy for us. In fact it was a practical way for them to start the course, because programs written in Assembler typically started with this instruction; it set up the first register you were going to use.
Computers ultimately are coded in machine language, made up of noughts and ones, but - even when I joined in 1971 - machine code had long been superseded. Instead programmers made the use of Assembler as the lowest level language; which immediately compiled one on one into machine language. We spent the best part of half a year becoming fluent in Assembler; since -- as a last resort -- this was a language you had to understand to get inside programs
We were taught this by two of IBM's systems engineers. At the time they seemed almost like gods to us, since they understood this strange new language. Later, I realised that they were just junior SEs (Systems Engineers). But it was strange, looking back on this, that I had so readily swapped my own position at senior general manager to become a trainee overawed by junior systems engineers! This nicely illustrated the power of the pecking order within companies.
I should, perhaps, say something at this stage about the premises. At Sudbury Hill Court, the IBM education centre was a 12 story office block, which had being converted for use by IBM. It had two wings. One of these was the wing used as offices by several hundred education staff. The other wing contained the classrooms where we were taught. In line with IBM's philosophy, in those days, it was a very luxurious environment. On the ground floor an extension had been built which contained a large theatre, rarely used except for national events, and very good restaurant where we ate. The only drawback was that to get planning permission for this extension IBM had agreed to designate the whole building only for educational use. This was fine while IBM wanted to use it for such; but posed immense problems if it ever wanted to sell it off again - which a couple of decades later, as educational requirements changed, it did!
Also on the ground floor in the main part of the building were the various computer rooms. These contained a massive array of computers, including large water-cooled ones. On a winters day you could look out of the classroom window and see steam rising from the cooling plant outside.
Mixed in with the basic language tuition was an introduction to the OCR, the Operational Control Language (sometimes called Job Control Language). This was the interface with the operating system of the computer; then usually running in batch mode - so the first few cards of the ‘deck’ (which contained the program, say) told the computer what to do with the batch following. As this was taught as we went along, it took a long time for us to realise that this was not actually part of Assembler. But, in those days you had to know the control language, as well as the basic assembler language, since otherwise you couldn't get your programs compiled.
A lot of the time was taken up with writing programs and punching them onto eighty column cards. Indeed, the regular routine was to do this during the day and then, in the evening, hand them in at the main computer rooms -- where they were run as batches on the computers overnight. In the morning you went and picked up your card deck once more, together with a printout of the programme and its output. All too often the latter was very short, since the programme was flawed and had aborted after one of two instructions. You could correct this within a couple of minutes, but you still had to wait for the next overnight run to see what the next problem was!
All in all, I found programming very restful; especially after the stresses at BTR. I was quite good at it, and in the exam at the end of term I did very well. Mind you I had revised as hard for that exam as I did for my A-levels -- far harder than I did at university. Even so, there is something very soothing about writing computer programs. Eventually, I wrote them not as an exercise in logic but almost as a foreign language. I used to pick up the specifications and then simply write. The code flowed from under my pen.
In the second term we went further, to learn high level languages. At that time the main commercial language was: Common Business Oriented Language (COBOL), though a number of organisations -- especially scientific organisations -- wrote in FORTRAN (Formula Translation). We learned these, though, rather perfunctorily and without writing many programs. Our main effort concentrated on IBM's new language PL1. This was a merger of the two approaches, with the free-form writing of Fortran combined with the more structured approach of COBOL. Indeed it could do almost anything you might want it to. It was a superb language, reportedly developed at Hursley in the United Kingdom, and it also reportedly was the key to putting a man on the moon -- without this language NASA would not been able to undertake its various projects. At that time, indeed, the language of computing was often dominated by that of NASA. Thus the main spooling programme, the program which stored the output and then immediately started printed it out whilst the computer got on with other things, was called HASP (Houston Automatic Spooling Program).
We were at last allowed to get our hands on the very large IBM machines, though their size sounds puny these days. The largest machine I ever ran was an IBM 165 -- the largest in the range -- and it had a main memory of just 256K bytes; little more than that of a calculator a couple of decades later!. Even then we had difficulty loading the various partitions into main memory, where it was capable of running separate programs in a number of such partitions at the same time.
Finally, we moved onto the smallest IBM machines -- the System/3 (S/3) range – on which I was later to spend most of my time in the field. This used programming language called RPGII. This was in essence a Report Generating Language, hence RPG, with a few additions to handle basic input/output and calculations. It was the first of IBM’s small commercial machines. The major difference with these small new machines, the major ‘breakthrough’ at that stage, was the use of smaller cards with 96 columns, rather than the 80 columns used for the previous half century. We were at the stage when such differences were seen as leaps forward. Indeed, earlier in our training, we still had to learn how plug up the boards used on tabulating machines; which IBM still sold, In their case the 'programs' (such as they were) were set up by wires plugged into, and linking, various ‘hubs’ on the back of the machine! Even the S/3 machines really were still very small; the card-based machine, for instance, had a main memory of just 8K!
hits