John Iliffe (computer designer)
John Kenneth Iliffe (18 September 1931 – 16 February 2020) was a British computer designer who worked on the design and evaluation of computers that supported fine-grained memory protection and object management. He implemented, evaluated and refined such designs in the Rice Institute Computer, R1 (1958–61) and the ICL Basic Language Machine (1963–68). A key feature in the architectures of both machines was control by the hardware of the formation and use of memory references so that the memory could be seen as a collection of data objects of defined sizes whose integrity is protected from  the consequences of errors in address calculation, such as overrunning memory pointers (whether by accident or malicious intent). Technical contributions. Iliffe attended the EDSAC programming course in Cambridge in 1952. He eventually learned about computing by running the IBM (UK) service bureau in London. In 1958 he was invited to join the team building the R1 computer at Rice Institute, Houston, in which he took responsibility for operating system and language design and implementation. In the next 30 years he put into operation four computers demonstrating and evaluating new concepts in design. The Rice R1 Computer. Iliffe led the development  of the operating system and programming language for the Rice Computer. His design included an early instance of dynamic memory allocation and management, enabling programs to acquire storage on demand and automatically recover it when it was no longer accessible. In the R1 Iliffe and his colleagues introduced a protection scheme for all data objects. The manipulation of references to memory (termed "codewords") was restricted to privileged code, preventing some types of program error. Codewords referenced vectors of data items, sequences of instructions or other codewords . Storage was accessed by reference to a codeword and this was resolved to a  conventional address or program counter giving direct access to store when necessary. The system provided functions to create, manage and update codewords, for example changing them to reflect storage management decisions. It also supported an algebraic programming language (called Genie) which was implemented using object-oriented design concepts in 1961. The Genie compiler and associated assembler were unusual in enabling the entire system to be treated as an object-management discipline. Genie was also amongst the first languages to include intrinsic operations on real and complex vectors and matrices. The well-known Iliffe vector storage structure for multi-dimensional and  irregular arrays emerged from the R1 work. It exploits a similar addressing structure but without system enforcement. The Iliffe vector storage structure has been adopted widely for use in application programs and high-level language systems. The Basic Language Machine. In the early 1960s there was a strong requirement for general-purpose computers to provide for the concurrent execution of multiple user programs, both in the form of multiprogramming to optimise the use of a computer's resources and in the form of time-sharing to enable interactive computing. Both of these require a computer architecture in which the operating  system could guarantee the separation, security and integrity of several concurrently-running programs. It seemed clear that the simplified model of architecture derived from the Princeton IAS and followed by all the “von Neumann” models would run into severe difficulties in satisfying that requirement. The Basic Language Machine (BLM), constructed and evaluated in the research department of International Computers Limited (ICL) between 1963 and 1968 was the first general-purpose system to break completely with the Von Neumann architecture. Instead of basing the architecture on a single linear address space, the BLM offered segmented memory addressing, enabling automatic storage management  and access within precise security boundaries. Iliffe took the engineering view that it should be possible to offer a way, based on the memory management techniques already demonstrated in the Rice R1 to ensure the integrity of concurrent programs without resorting to relatively expensive mechanisms involving the frequent swapping of process state vectors seen in most other systems. He developed a design based on the use of codewords to represent all memory references. A codeword included a "base address", a "limit" specifying the length of a data object and some "type information". The internal representation of codewords was opaque to  user programs but specific machine instructions were provided to manipulate them in ways that maintained the data structure. That represented a substantial refinement of the Rice R1 architecture, providing for the efficient management of multiple processes, each having a separate tree-structured data and instruction store. The Rice R1 and the BLM were examples of descriptor-based computer architectures that emerged in the 1960s"" aimed both at the efficient protection of concurrently-executing programs and the reliable implementation of high-level languages"." The other major example was the B5000 series of computers developed and marketed by the Burroughs Corporation. All  these descriptor-based computers included hardware mechanisms designed to support the reliable addressing of data segments. They are closely related to capability-based architectures"" that emerged a few years later. In parallel with construction of the BLM a separate evaluation team assessed it in terms of (1) program efficiency (2) operating characteristics (3) coding and debugging costs and (4) system overheads. For meaningful comparison, legacy high-level languages (Cobol, Fortran, file management) were used. It was shown that despite the precision of the addressing mechanism there was no noticeable loss of efficiency or additional system overhead. Levy discusses the wider  impact of descriptor-based computer architectures with reference to both the Burroughs B5000 and the BLM (p. 38) "... whether or not they were long-lived, these machines demonstrated the feasibility of using descriptors and segmentation to greatly increase programming flexibility for the user, the compilers, and the operating system". Levy also notes that "an excellent discussion of the BLM within the context of modern capability systems appears in Iliffe's "Advanced Computer Design"". The BLM design was rejected by ICL management in an internal review of options to select a new architecture for ICL's mainframe products in December 1969 . In the year 2000 Iliffe received the IEEE Harry H. Goode Memorial Award "For lifetime achievement in the practice of computer system design and evaluation." Changes in semiconductor technology in the 30 years following the development of the BLM led to refinements of the architecture. In the absence of research funding they were evaluated mainly by simulation using low-cost microprocessors and Iliffe's "Advanced Computer Design" describes them in some detail.