CESIL

CESIL (Computer Education in Schools Instruction Language) is a small teaching language that was used to introduce pupils in British secondary schools to programming in the 1970s and early 1980s. It has fourteen instructions and one accumulator. Its programs were written in pencil on printed coding sheets, punched onto cards by someone else, and run in batches on a mainframe at a local college, often a week later. CESIL was never meant for real software. Its job was to show teenagers what a stored-program computer does, one instruction at a time, and by the end of the 1970s ICL’s course materials were used in more than 2,000 schools and colleges.

History & Origins

The Computer Education in Schools project

In the late 1960s almost no British schools taught computing and very few teachers had any experience of it. The Computer Education in Schools (CES) project began in September 1968 to change that. According to ICL’s own January 1980 newsletter, it was the brainchild of Chris Wysock-Wright and was launched by the John Hoskyns organisation, a software and consultancy firm. Interest in the first year was high enough that the project needed a larger backer. In September 1969 it moved to International Computers Limited (ICL), becoming ICL-CES with a small team and 27 schools.

ICL-CES called itself a non-profit curriculum development project run jointly by education and industry. Its development staff were former Computer Studies teachers. ICL provided funding, technical expertise and advisers, and regional panels of local education authority advisers, college lecturers and teachers guided the work. The project produced textbooks, teachers’ guides, visual aids and newsletters. It also supplied software “to installations willing to process schools’ work”. The principal languages were CESIL and BASIC.

When did CESIL appear?

The date is less clear-cut than it looks. The encyclopedia’s source list has CESIL as 1974, probably because that is when it entered the O-level syllabus and when many former pupils first met it. The earlier evidence is:

• April 1969. A clipping reproduced in a later ICL-CES newsletter, under the headline “Nice one, Cyril!”, quotes Electronics Weekly’s introduction of the CES package in April 1969: “Initially students are introduced via a simplified language, CYRIL…”. The newsletter seems to treat this as an early reference to CESIL, and the English Wikipedia article now dates CESIL’s introduction to April 1969 on that basis. Whether “CYRIL” was an early name or just a misreading of the acronym is not clear from the clipping.
• 1970–1971. ICL-CES’s own description of the project, from around 1976, says the first materials were used by about 600 students in 30 schools during 1970, and that Computer Studies Part One was field-trialled in 1971. The same document says CESIL “is introduced in part one”.
• October 1974. The AEB O-level Computer Studies syllabus names CESIL as a preferred teaching language. This is the earliest dated document seen for this page that uses the name CESIL directly.

This page therefore dates CESIL to 1969, when the CES package introduced its simplified teaching language. The name “CESIL” itself is firmly documented only from the early 1970s.

Design Philosophy

ICL-CES described CESIL as “an introductory teaching language designed to provide practical appreciation of the way a computer functions, its benefits and limitations”. BASIC, taught next, was meant to show the computer as a problem-solving tool. CESIL was meant to show the machine.

That shaped the design:

• An idealised machine, not a real one. CESIL looks like a simple assembly language, with one accumulator, named storage locations and conditional jumps. It hides binary, addressing modes and instruction encodings. The 1974 O-level syllabus asked for “a subset of an assembly-type language … to illustrate the internal working of the computer” and said teaching languages such as CESIL “are to be preferred”.
• Built for batch processing. Pupils never sat at a terminal. Their programs travelled as coding sheets and punched cards, so CESIL has no interactive input. Data is supplied with the program and read one number at a time.
• Small enough to learn in a few weeks. Pupils usually drew flowcharts first, then wrote CESIL in exercise books. Only after that did they submit a program to a real computer.
• Forgiving output. Arithmetic is low-level, but printing is not: PRINT sends a quoted string directly to the line printer. Programs could label their results without any character handling, which the syllabus explicitly left out of scope.

Key Features

Program layout

A CESIL program is written in fixed columns, matching the printed coding sheet:

Labels and storage-location names are alphanumeric, up to six characters, and start with a letter. According to the textbook’s rules as summarised on Wikipedia, integer constants in the program must carry a sign, so zero is written +0. A line beginning with % ends the program and starts the data. A line beginning with * ends the data. A line beginning with ( is a comment.

The instruction set

CESIL works only with integers. According to the ICL-CES textbook as summarised on Wikipedia, DIVIDE truncates toward zero, and dividing by zero stops the program with *** DIVISION BY ZERO ***. Reading past the end of the data gives *** PROGRAM REQUIRES MORE DATA ***.

What CESIL leaves out

There are no arrays or indexed addressing, no string variables, no subroutine call or return, and no stack. Any loop that walks through several values has to read them one at a time with IN. Pupils soon found the limits, and that was intended: those limits were the reason for moving on to BASIC.

A short example

This program adds up a list of numbers ended by a negative value, counting them as it goes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

        LOAD    +0
        STORE   TOTAL
        STORE   COUNT
NEXT    IN
        JINEG   DONE
        ADD     TOTAL
        STORE   TOTAL
        LOAD    COUNT
        ADD     +1
        STORE   COUNT
        JUMP    NEXT
DONE    PRINT   "COUNT "
        LOAD    COUNT
        OUT
        LINE
        PRINT   "TOTAL "
        LOAD    TOTAL
        OUT
        LINE
        HALT
%
12
7
23
-1
*

Everything passes through the one accumulator. To add a value to the running total, the program must load or read it into the accumulator, add the stored total, and store the result back. Pupils learned to trace this kind of shuttling by hand in “dry runs”.

How CESIL Was Actually Used

A former pupil’s account on the ICL-CES archive site (iclces.uk) describes the routine during their O-level course (the account gives no exact year) at a school that sent its work to Nene College, Northampton:

1. The teacher set a programming problem as homework.
2. Pupils wrote their programs on CESIL coding forms, which had fixed fields for the school and pupil identifiers.
3. The teacher took the forms to Nene College, where computer-centre staff punched them onto cards.
4. CESIL programs from all the schools using the college were batched into one card deck and run together on the college’s small ICL 1900.
5. The line-printer output was split up by school and handed back in the next lesson.

With about a week between runs, each O-level project got perhaps half a dozen runs in total. Pupils spent a lot of time checking their programs on paper before submitting them. In batch mode CESIL was processed by an ICL program called #JCES, and BASIC by #JBAS. When Nene College later replaced the 1900 with an ICL 2903E, CESIL was still one of the languages in its evening batch service, alongside FORTRAN, ALGOL, BASIC, RPG2 and PLAN.

ICL-CES also offered SIR, a simple assembly language for sixth-form work. City and Guilds Mnemonic Code, a separate teaching assembly language, was sometimes taught in its place.

Evolution

CESIL was never formally versioned. It was defined by the ICL-CES textbooks and a pocket reference card covering both CESIL and BASIC, and implementations differed in small details. Its history is really the history of the course around it:

• Early 1970s. CESIL becomes the first programming language in Computer Studies Part One and spreads to CSE and O-level courses.
• 1974. The AEB O-level syllabus names it as a preferred low-level teaching language.
• Late 1970s. Revised editions of Computer Studies Books 1 and 2 appear. The 1978 edition of Book 1 is by Colin Monson, Ian Sewell and Frances Vickers. By the project’s tenth anniversary in 1979, ICL reported that more than 2,000 schools and colleges based their computer education courses on CES materials.
• 1980s. Microcomputers arrived in British classrooms, and ICL’s own January 1980 newsletter expected future courses to use “a more structured approach to programming … using languages based on the BASIC we know today”. Mainframe batch teaching faded, and CESIL faded with it. The encyclopedia’s source list puts its last real use at around 1985. That date has not been independently confirmed.

Current Relevance

CESIL is no longer taught, but former pupils keep it alive:

• The MagPi, issue 8 (December 2012). Gordon Henderson’s “CESIL Pi” article describes a CESIL interpreter he wrote in his RTB BASIC for the Raspberry Pi. It adds extra registers, a colour instruction and a subroutine facility so programs can drive a grid of “fairy lights” on a Christmas tree.
• Visual CESIL. Andrew John Jacobs’s freeware CESIL environment for Windows. Its original home page was unreachable when this page was written.
• Python and other interpreters. Ian Dunmore’s GPLv3 interpreter (GitHub, repository created March 2020) runs classic CESIL and his extended “CESIL Plus”, documented at cesil.org. Wyrm Software released Wyrm CESIL, an Android interpreter, and a C# CESIL interpreter is published under the WyrmUK GitHub account.
• Browser-based CESIL. Andrew Bovett’s GPLv3 web environment (2024) adds compile, run, single-step and breakpoint controls, plus a live view of the accumulator and variables. The author notes some deliberate differences from the original ICL-CES reference card.
• iclces.uk. An archive of ICL-CES materials maintained by a former pupil: the project description, the CESIL/BASIC reference card, the 1974 O-level syllabus, coding sheets, and programs recovered from photographed punched cards and a home-built paper-tape reader.

Why It Matters

CESIL matters less for its design, which is deliberately tiny, than for its reach. It was the first programming language that many British pupils ever learned. They learned it at a time when schools had no computers and the programs had to travel by post. For many people who later worked in computing in the UK, their first experience of a real computer was a CESIL printout coming back a week later, often with *** PROGRAM REQUIRES MORE DATA *** on it.

The language also reflects a teaching idea that still comes up in computing education: learn what the machine does before learning to hide it behind a high-level language. In British schools of the 1970s, CESIL was one of the main ways that idea was put into practice.