Computers and Software

The earliest calculating engines, such as Charles Babbage’s Difference Engine were all mechanical. It wasn’t until the invention of the thermionic valve that electrical computers were possible.

After the second world war, electrical computers began to slowly displace mechanical calculating engines in the corporate world. These were very slow by modern standards, and required a lot of maintenance due to the relatively short life of the valves. They were also very expensive and only large companies could afford a computer. Towards the end of the ’60s, they began to be replaced with designs based on germanium transistors, which allowed much cheaper (and smaller) computers to be built. While still expensive, these were affordable by a much larger number of organisations.

Early computers were very simple machines and a number of companies sprung up in the UK, including Wales, to build them.

Further Reading: Simon Lavington, Early British Computers, Manchester University Press, 1980.

From the early ’80s, a large number of manufacturers were creating cheap computers built around off-the-shelf 8-bit CPUs, typically the MOS 6502 or the Zilog Z80. Competition was fierce; one manufacturer cut their margins so fine that they needed to keep the money from their customers in their bank account earning interest for a month before they could afford to buy the components.

Many of these machines were used primarily for gaming, but machines of this class introduced a generation of school children to computer use and programming. In Britain, this was encouraged by the Government of the time, through initiatives such as “Micros in Schools” and “IT82: The Information Technology Year”.

Early Programming

The first computers were little more than electrical calculating engines. They could perform tasks like additions faster than their human and mechanical counterparts. A typical use for these machines would be calculating bills. Each customer would have a punch card for their usage and each item on this would be multiplied by the per-item cost stored in a table, added to an accumulator and then emitted, often on another punch card which would be fed into a separate machine that would type numbers on an invoice.

These operations were very simple, and supporting them in the first generation machines involved wiring them up to perform the task. In June 1948, the Manchester Baby changed this by storing its programs in the same way that it stored data, allowing it to be reprogrammed without being rewired.

Optimal Programming

In 1936, Alan Turing proposed the Turing Machine as a universal model of a computing engine. A Turing Machine had an infinitely long tape containing data. It would read the current cell on the tape, then either write something over it or move the tape left or right and update some internal state. A Universal Turing Machine was one where the tape could contain an encoded form of another Turing Machine. This is the basis of all modern programming - making a general purpose computing machine behave like a special purpose one.

One feature of note with a Turing Machine is that the running time of an algorithm depended heavily on the location of data on the tape. Adding two values together could be very quick or very slow depending on how much the machine had to move the tape to get to each of them.

Although the Turing Machine was a purely theoretical idea, early computers inherited this limitation. Most of them used a storage mechanism that was either inherently serial or had large penalties for seeking. In a modern computer, main memory is Random Access Memory (RAM) and the time taken to read a value is more or less independent of its location. In a machine using mercury delay lines for storage, each value in the line was read in order and could only be accessed one nth of the time, where n is the number of values stored in the line. Magnetic drums had similar limitations, since accessing a value required turning the drum to make it visible. Even modern hard drives retain this limitation, but it is less of a problem since they are generally used as secondary storage (if at all) on a modern computer.

The cost of seeking in early hardware lead to the development of optimal programming, with Alan Turing one of the subject’s principle proponents. The idea behind optimal programming was to ensure that data and instructions that would be accessed together were placed physically close together. This meant that the computer would spend more time computing and less time waiting for data.

In modern programming, this kind of thing is rarely done by programmers, but is still very important for compilers. Modern computers use a memory hierarchy, with two or three layers of cache between the main memory and the CPU. Accessing data from a cache is much faster than accessing data in main memory. Data is loaded into these caches and evicted from them in blocks, and so positioning related data so that they can be loaded together still provides a performance benefit.

David Chisnall

Graphical Workstations

In 1963, Ivan Sutherland created a pointer-based system known as Sketchpad, which allowed direct manipulation of graphical objects. This later became the inspiration for the Apple Newton personal digital assistant (PDA). It wasn’t until the late ’70s when computing power became sufficiently concentrated that a machine designed for a single user could run a graphical interface. The first machines of this kind were graphical workstations - expensive machines like the PERQ, the size of a small fridge which sat under the user’s desk and drove a small graphical display. During the 1980s, these machines gradually dropped in price until they had completely displaced text-only machines in all but a small number of places. By the ’90s, even cheap home computers were expected to come with a graphical user interface.

This part of the collection contains some notable examples from the development of the graphical user interface.

ICL PERQ

The 1980s saw an explosion in computing manufacturers. The components for building a cheap computer cost only a few hundred pounds, and the demand grew considerably.

The PERQ was one of the early graphical workstations. It was designed by Three Rivers Computer Corporation, named after the confluence of rivers in Pittsburgh, where the company’s founders had previously been employed at Carnegie Mellon University. International Computers Limited (ICL), a British company founded in 1968, handled European distribution and some of the manufacturing.

The PERQ was built in an era when the Pascal programming language was popular. Pascal is a member of the ALGOL family. It was designed as a simplified and slightly extended version of ALGOL for teaching, but became popular in industry since it large numbers of students graduated knowing it.

In order to encourage the adoption of the language, a ‘porting kit’ was written in Zurich. This included a simple, stack-based, virtual machine which executed an instruction set known as ‘p-code’. Since the compiler was written in Pascal, all that was required to get the compiler and all other Pascal programs working on a new platform was to port the virtual machine. The Java virtual machine can be seen as a direct descendant of the p-code virtual machine. Both are stack-based, meaning all operations load data from memory onto the stack or manipulate the top few stack elements. For example, adding two numbers together in a p-code virtual machine was accomplished by a sequence of three instructions. The first two would load the values onto the stack and the third would replace the top two elements on the stack by their sum.

The PERQ had a microcoded architecture, where the public instruction set was very similar to p-code. This made running Pascal code very simple, since the portable compiler’s output could be run directly. The operating system and other tools were all written in Pascal.

The University of Wales, Swansea, acquired two PERQs shortly after their release. Professor Chen gained some of his first graphics programming experience on one of them.

David Chisnall

NeXT

In 1984, Steve Jobs, co-founder of Apple Computers, resigned after a short power struggle with the new CEO John Sculley. He formed NeXT, with the intention of building the perfect computer.

In 1988, the company released the NeXT Cube, a one foot square black magnesium cube, was released. This machine was dubbed an ‘interpersonal computer’ by Steve Jobs, who believed this was the next step in development after the personal computer. It was designed with networking in mind and was instrumental in the creation of the World Wide Web when in 1991 Tim Berners-Lee wrote the first web browser on his cube and used it to run the first web server.

The cube was somewhat rare for the era in that it lacked both a floppy disk drive and a hard disk drive, although the latter was available as an optional extra. Both were replaced with a magneto-optical disk. This stored 256MB of data on a removable disk - a huge amount in an era when 40MB hard drives were common. The idea behind this was that users would store all of their data on a disk and be able to use it on any machine.

The high price of the cube ($6,500 in 1988, about £6000 in today’s money) meant that it had only limited success. In 1990, the NeXTstation was introduced as a cheaper alternative. This was somewhat more conventional, sporting an internal hard drive and a 3.5” floppy drive instead of the magneto-optical drive. It was also physically smaller, coming in a slab form-factor that sat underneath the monitor.

As with the cube, the machine included a high-resolution display, supporting resolutions of 1120x832 in either four shades of gray or 4,096 colours (for the colour variant), a resolution that wasn’t found in most home computers for another decade. In addition, it included a digital signal processor for sound output, giving CD-quality sound output with effects processing.

The NeXT machines are credited with the first real commercial development of the object oriented programming concept. They used Objective-C for application development. Both the language and the development environment were heavily inspired by Smalltalk, the first real object oriented environment, developed at Xerox PARC. Although NeXT stopped making hardware in the early ’90s, this environment would later be used for WebObjects, the first web application development framework.

In the late ’90s, Apple bought NeXT and used their operating system as the basis for Mac OS X, and many features of the operating system can be traced back to this system. The development framework originally created by NeXT for their workstations, and later refined in collaboration with Sun, is now branded as Cocoa by Apple.

David Chisnall

The very earliest computers were hard coded machines which could only run one program and needed rewiring to run anything else. In 1948, the Manchester Baby became the first stored program computer, a machine which eliminated the distinction between code and data and used the same storage mechanisms for both, allowing ‘rewiring’ simply by changing the contents of storage.

All modern computers follow this model and as the complexity of the programs to be stored has increased, producing them has become an increasingly complex challenge.

Early programming was done by the programmer writing the machine instructions, sometimes called orders. These would be of the form ‘load memory address 100 into register 2’ or ‘add the contents of register 2 to register 3.’ Each instruction was a combination of an operation and one or more operands (things being operated on, such as register numbers, memory addresses, or constant values).

Remembering the numbers corresponding to operations was difficult and when computers started being able to handle text it became common to use mnemonics which corresponded to operations.

As complexity of programs increased, programmers started keeping libraries of algorithms that they used frequently and could insert into their programs where needed. Complex programs were assembled by combining these blocks. This process gradually evolved into the high-level programming languages used today.

[Object Oriented Programming] to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I’m not aware of them.

Alan Kay, inventor of the term ‘Object Oriented’

In the ’70s, a number of major developments came out of Xerox’s Palo Alto Research Center (PARC). These included the graphical user interface, ethernet networking and the laser printer. In addition to these was a new way of thinking about programming, known as object oriented design. Rather than viewing programs as a set of subroutines which called each other, as procedural programming encouraged, object oriented programming decomposed a large program into objects. An object is a simple model of a computer, which interacts with other objects via message passing.

Many object oriented languages include the notion of a class. This is a special kind of object which is used to create objects. In class-based languages, an object’s behaviour is defined by its class, which may in turn inherit some of its behaviour from another class. This idea comes from the Simula language, originally designed for simulation. Classes were introduced in Simula to allow general categories of simulated objects to easily share code. These could be refined to represent more specialised types of simulated object. Although object oriented languages inherit a lot of ideas from Simula, it lacked a number of features such as encapsulation that are generally regarded as being requirements for an object oriented language.

Newer object oriented languages, such as Self, Io, or JavaScript, abandoned this notion. The designers of Self noticed that classes inheriting behaviour from other classes and objects adopting behaviour from classes were both special cases of the general idea of delegation. In Self any object can have additional behaviour added to it and can be duplicated by sending it a clone message. A cloned object delegates all of its behaviour to the original object, allowing traits objects to act as templates for common objects in the same way that classes do in more traditional languages.

In an unstructured program, flow is controlled by using jumps. With procedural programming, flow is controlled via subroutine calls and returns. With object oriented programming control flows with message passing operations.

In Smalltalk, the canonical object oriented language, there are no explicit flow control operations at all. There is one built in type of object, called a BlockClosure, which represents a block of code and responds to a value message, which evaluates it and gets the return value. Conditional expressions are formed by sending an ifTrue: message to an object representing a boolean value with a block as the argument. Instances of the True class will execute the block when they receive the message, while instances of the False class will not.

David Chisnall

Further Reading: Adele Goldberg and David Robson, Smalltalk-80: The language and its implementation, Addison-Wesley Publishing Company, 1983

Objective-C is a programming language defined by adding an object oriented layer on top of C, using Smalltalk semantics. The Objective-C language began life as the Object Oriented Pre-Compiler. This was a simple preprocessor that took Smalltalk-like constructs and translated them into pure C code. Since C has no native support for dynamic dispatch, the pre-compiler used a separate library to handle dynamic lookup of methods. This evolved into the Objective-C runtime library.

The runtime library is responsible for implementing the aspects of Objective-C that do not map trivially on to C constructs. Methods in Objective-C are translated to C functions, but the static lookup mechanism used for calling C functions is not applicable to the Smalltalk object model and so a dynamic lookup mechanism is implemented in the runtime. The runtime also defines structures to be used for implementing classes which store the metadata needed for introspection on method and instance variable names and types.

Objective-C was first widely released to the public by Stepstone, a company founded by Brad Cox, the language’s designer, and Tom Love. The company sold an Objective-C compiler and a set of libraries. In 1988, Steve Jobs’ second computer company, NeXT, bought the rights to Objective-C from StepStone and became the main distributor of Objective-C products.

Objective-C was used in NeXT’s operating system, NeXTSTEP in a number of places. Device drivers were written in Objective-C by subclassing generic devices and the entire GUI framework was written in the language. The NeXT Interface Builder is generally regarded as being the first Rapid Application Development (RAD) tool. It produced bundles called nibs which contained serialised object graphs. These typically contained the view and controller objects for a window and were loaded and connected to model objects at runtime. The framework made heavy use of the dynamic features of Objective-C. For example, a common pattern was to provide a delegate to view objects. This would implement some of a set of defined methods and the view would query which it did implement at runtime. A similar pattern is used in Java, however since this language lacks the dynamic capabilities of Objective-C the delegate is required to implement all of the methods, even if the implementation does nothing.

Although NeXT’s development tools were popular with those who used them, the high price of the machines ($10,000 for the early models) kept the number of users small. One of the best known was Tim Berners-Lee, working at CERN. Tim used it to write WorldWideWeb, the first web browser. He later claimed that he would not have been able to do so without the ease of programming provided by Objective-C and specifically NeXT’s AppKit framework. Many aspects of AppKit can be seen in the original implementation of the web. The original tags supported by HTML correspond directly to the attributes recognised by the NSAttributedString object used to represent rich text.

Subsequent web browsers were written in more primitive languages, typically C, and it wasn’t until 1996 that Objective-C appeared on the web scene again. In this instance it was as the core language for WebObjects, the first web application development environment, again produced by NeXT. This was used for many of the early eCommerce sites on the emerging web, as well as others such as the BBC News site and Disney’s online presence.

WebObjects included a companion library, the Enterprise Objects Framework. This was released two years prior to WebObjects, but found significant use when developing web applications. It used many of the dynamic features of Objective-C to implement object-relational mappings, allowing persistent storage of objects in a relational database. Something similar is found in most web application frameworks today.

The most lasting impact on the web can be seen from the impact of Objective-C in the development of Java. Patrick Naughton, one of the two main developers of Java, had been offered a job at NeXT prior to beginning work on Java and ‘thought Objective-C was the coolest thing since sliced bread, and…hated C++.’ Java inherits many attributes from Objective-C, including single inheritance, dynamic binding, dynamic loading, classes as objects, formal interfaces (protocols in Objective-C) and primitive (non-object) types. It adds syntax more familiar to C++ users and a more static type system on top of these.

David Chisnall

The distinction between a high-level and low-level language is a constantly moving boundary, but the first language to claim the title of a high-level language is generally considered to be FORTRAN.

A FORTRAN program described the algorithm to be executed in a way that was not tied to any specific architecture. One of the the key innovations of FORTRAN was the GO TO statement, invented by Harlan Herrick. This allowed branching to some high-level concept of a label, rather than a machine address.

FORTRAN took many years to develop. The idea was proposed by John W. Backus in 1953 to develop more efficient methods of programming IBM’s 704 mainframe. The first draft of the language specification appeared a year later and the first FORTRAN programming manual was published towards the end of 1956. Readers of this manual had to wait another six months before they could put their skills into practice, as the first compiler was not released until April of the following year.

David Chisnall

Memory

One of the core parts of any computer, from any era, is some form of data storage. Exactly how this is implemented and exposed to the programmer has changed a lot over the history of computing engines.

Perhaps the most influential idea in designing computing engines is the Von Neumann Architecture. This was proposed in John von Neumann’s 1945 paper, First Draft of a Report on the EDVAC. In such an architecture, both the program and its data are stored in the same way. This is a logical extension of Alan Turing’s ideas - that programs are just another form of data - in the context of a real implementation.

Sequential Stores

The first form of data storage found in early computers was the Williams Tube. At the core of the device was a cathode ray tube. When the electron beam hits the front of the tube in such a device, it becomes negatively charged. This charge can be read by a plate on the front. The action of reading a value also destroyed it. Williams Tubes were used in some of the first stored program computers, but were unreliable and degraded over time making them unpopular in commercial use.

The Mercury Delay Line was developed at around the same time and became more popular. The idea of a delay line is that an electrical wave is turned into a sound wave at one end. It then propagates along the medium (initially mercury) and is turned back into an electrical signal at the far end. The speed of sound in mercury is much lower than the speed of an electrical signal in a wire. This means that a loop can be set up where data is constantly read from one end of the line and written back to the other end.

Mercury delay lines were eventually replaced by other forms of delay line such as magnetostrictive delay lines, which used magnetism to induce a twist into one end of a wire which would propagate along its length.

The key attribute of these storage systems is that they are intrinsically sequential. Data are written into one end of a delay line and can not be accessed until they reach the other end.

Registers and Cache

In spite of their limitations, delay lines remained popular for some time. Small numbers of very short delay lines were used to augment slower memory systems. In some later machines, these were not directly visible to the programmer. These were termed ‘cache,’ from the French meaning ‘to hide.’ When a location in slower memory was accessed, it and the surrounding region would be loaded into the cache (hidden) memory in a block.

In modern computers, cache is typically implemented using static RAM, however we still retain the terminology from this era and refer to a block of cache memory loaded in one go as a cache line.

Delay lines were also used in early computers as registers. A register is a storage location capable of storing a machine word which is considered close to the processing elements. Arithmetic and other operations can be performed directly on values stored in registers.

Random Access Memory

A lot of early programming depended on arranging accesses (see Optimal Programming). Modern memory is known as random access memory (RAM) because access times do not depend on the location in the storage. Accessing a word from memory takes the same amount of time irrespective of where it is.

One of the earliest forms of RAM was magnetic core memory (also known as ferrite core memory). This worked by having a regular grid of wires with discs of iron around each intersection. Placing a current through a pair of wires will magnetise the core in one direction or the other depending on the direction of the current.

In and Out of Core

Magnetic code memory was often used in conjunction with a larger store, such as winchester disks or magnetic tapes. These were collectively known as out-of-core storage, to distinguish them from in-core storage (data resident in the magnetic cores).

The principal difference between in-core and out-of-core data is how a program accessed it. Typically, a programmer loaded data from core memory to registers using LOAD instructions and returned it using STORE instructions. On some systems, operations could be performed directly on data in magnetic core storage. External storage could not be accessed directly. Before computing on data stored out of core the operating system had to load it into the core.

This terminology persists today. Modern operating systems often swap data out of main memory onto a hard disk. On UNIX systems, the mincore() system call (short for memory in core) is used to determine whether a bit of data is currently resident in memory. When a UNIX program crashes, it dumps a copy of its memory to a file with a .core extension, known as a ‘core dump,’ since early systems would have written out the contents of their magnetic core storage for offline debugging. Fortunately, modern programmers are able to use high-level tools to examine their core dumps and don’t have to read through pages of printouts.