In a recent blog I talked about how I found the role of computer operator illogical in the early 1970’s, especially with the arrival of operating systems. I should explain that the computers I refer to were mainframes (one big central computer), and that they largely hosted online systems during the day (accessed via green screen dumb terminals) and then processed the data captured overnight using what was called batch processing. For example, payroll data was entered all week, but on Thursday evening we would run a sequence of 20 or 30 individual programmes (read Apps) to convert the data into payslips for use on Friday. These 20 or 30 programmes were instigated by the computer operator loading, starting, managing and ending each programme via the keyboard; this was very time consuming and boring, and the margin for error was huge. Now you know why I thought this was illogical!
The advent of operating systems offered computer departments the opportunity to introduce efficiencies and reduce mistakes by linking the programmes together into suites, as they were known, using JCL (Job Control Language). But the creation of these suites meant that JCL macros writers were needed, and that was me, based on my ICL Melbourne Victoria Computer Centre experiences.
The first opportunity to use my JCL writing skills in anger arose in late 1976, when a contract role came up at ICL Letchworth, in Hertfordshire. It was weeks after my return from Australia, where I’d been a computer operations manager (despite still being only 23), and therefore my technical skills were somewhat rusty. I went for the interview, and was very honest with the interviewer regarding my rustiness. I got the job, alongside Mario Capiron, working for Graham Hopkins. We spent months JCL coding to create suites of programmes to run on the mainframes. This was as boring and error ridden as being a computer operator, but it taught me a lot. After the project finished, I did a stint contracting in Newcastle working for Plessey (I think), doing more JCL stuff, and I met David Roberts (a lifelong friend) as a result. One-day Graham Hopkins rang and asked me if I wanted to run a similar project for Keith Bogg for ICL Corporate Information Systems (CIS) at ICL Stevenage. I learned later that Mario was first choice, but that he had said no; lucky me.
The Stevenage project took up the whole of 1978, as it involved nearly every ICL CIS office in the UK. The brief was to upgrade all their suite macros to a single standard; a mammoth task. The first thing I did was get David Roberts involved, and we rented a house locally for the whole project team. The next thing I did was look at how to standardise the JCL. As I didn’t have the code for VCC (see this blog) I started from scratch, and created a single, universal piece of code (perhaps subroutine would be a better description) that would ‘control’ the execution of any programme you threw at it. Just for clarity, every programme running on this type of architecture behaved in the same way, basically asking for resources (input, storage, outputs) as and when needed. I called this single piece of JCL “Runmac”, and it was circa 99 lines of code! If you wanted to run a suite of 20 programmes to produce payslips, you executed Runmac 20 times, each time giving it a different payroll programme name, so it knew what programme to load and run; Runmac PA01 then Runmac PA02, and so on. Simples! During this time, I met some great people, some of whom will get a mention here, with a big shout out to Maggie Spanton and the late Barry Whitehead.
The overriding suite macros had to very resilient, and restartable, should they fail, so I had to build this into what we produced. To achieve this, I utilised an existing ICL subroutine, and then created a macro generator called MacMaker, which we used to create the suite macros, including all the resilience we needed. We now had the tools (MacMaker and Runmac) to deliver the standardisation ICL required, and we could do it in half the time.
Over the next 12 months, Dave, myself, and the team of contractors converted all the ICL CIS sites to a single set of standardised suite macros, but not without a few hiccups on the way. The biggest hiccup occurred the night we went live. Our mainframe was capable of running 10 ‘streams’ of work at once, with six executing, and four swapped out, awaiting operator intervention. Due to the nature of our new approach, there were far fewer requests from the programmes for operator intervention, so more were attempting to execute, and the mainframe started to choke, and the overnight work finished at the same time as it had before our project. The tech support team at ICL Stevenage were John Pratt, Derek Poole and Steve Clegg (both sadly no longer with us). I consulted them, and we concluded that we needed to reduce the streams from 10 to 8, and the next night the work finished in record time, and we never looked back. The project was viewed as a great success by ICL CIS, and the big boss, Leon Harding, asked me what I was going to do with the tools I had created. I offered the view that the IP belonged to ICL CIS, as I’d developed it on their time, but Leon very kindly pointed out that they had given me a job to do, but not told me how to do it, and that I had come up with that, so the IP was mine, and he backed that up in a letter.
I’ll talk about what that enabled me to do in a future blog post.