Turing

Turing is a high-level, general-purpose programming language built for one job above all others: teaching people how to program. Designed in 1982 by Ric Holt and James Cordy at the University of Toronto and named after the British computer scientist Alan Turing, it pairs a clean, readable syntax with precise, machine-independent semantics. For decades it was the language a generation of Canadian students met first, especially across Ontario’s high schools.

History & Origins

Turing was conceived in 1982 at the University of Toronto’s Computer Systems Research Institute (CSRI). Its creators, Ric Holt and James Cordy, were already veterans of educational language design: nearly a decade earlier they had worked on SP/k, a carefully constrained teaching subset of PL/I developed around 1974 with David Wortman and David Barnard. That experience — building a language whose rough edges were filed off so beginners could not easily hurt themselves — informed Turing directly.

The language draws its lineage from Pascal, Euclid, and SP/k. From Pascal it inherited a structured, block-oriented style; from Euclid (a language Holt had also helped design, aimed at verifiable systems programming) it inherited a concern for clean, well-defined semantics. Turing distilled these influences into something deliberately gentler and more approachable, intended for students taking their very first computer science course. Initial implementations became available around 1983.

Design Philosophy

Turing’s design is organized around a few consistent ideas:

1. Readable, lightweight syntax — Turing avoids much of the punctuation clutter that trips up beginners. It does not require semicolons to end statements, and it favors explicit keyword-based block terminators like end if and end loop over braces.
2. Precise, machine-independent semantics — The language was defined carefully enough to reason about, a value carried over from the Euclid tradition, so that program behavior did not depend on the quirks of a particular machine.
3. Safety for learners — Strong, static, manifest typing and checked runtime behavior help catch mistakes early, so students get meaningful errors rather than silent corruption.
4. A teaching tool first — Every design choice was weighed against the needs of a first-time programmer. Turing prioritized clarity and immediate feedback over performance or systems-level control.

Key Features

• Clean block structure — Constructs are opened with a keyword and closed with an explicit end, making program structure visually obvious.
• Strong static typing — Types are manifest and checked at compile time, catching a large class of beginner errors before a program runs.
• Simple, minimal “Hello World” — A working program can be a single put "Hello, World!" statement, with no boilerplate, headers, or main function to explain first.
• Flexible declarations — Declarations may appear where they are needed rather than being forced to the top of a block.
• Rich standard library for teaching — Later versions shipped with straightforward graphics, sound, and input handling, making it easy to write engaging, visual student programs.
• Object orientation (in later versions) — Object-Oriented Turing added modules, classes, single inheritance, and exception handling.

A minimal Turing program shows how little ceremony the language demands:

% A tiny Turing program
put "Hello, World!"

% A loop and a simple procedure
procedure greet (name : string)
    put "Hello, ", name, "!"
end greet

for i : 1 .. 3
    greet ("student")
end for

Evolution

Turing did not stand still after 1982. It grew into a small family of related languages:

• Turing Plus (1987) — A concurrent systems programming variant designed by Cordy and Holt. It extended the base language with processes and monitors (following C. A. R. Hoare’s model), binary I/O, separate compilation, variables at absolute addresses, and other features needed to write real systems software. It was reportedly intended in part as a successor to Concurrent Euclid.
• Object-Oriented Turing (1991) — An extension by R. C. Holt adding modules, classes, single inheritance, processes, and exception handling, along with optional machine-dependent programming. OOT was released as a replacement for Turing Plus, and over time absorbed some — though not all — of Turing Plus’s capabilities.
• The 2001 renaming — In September 2001, Object-Oriented Turing was renamed simply “Turing,” and the original language became known as “Classic Turing.” From this point on, “Turing” generally refers to the object-oriented incarnation.

The language also spawned TXL, originally the “Turing eXtender Language,” which James Cordy developed into an influential tool for source-to-source transformation and rapid language prototyping.

Current Status

Turing was, for most of its life, a commercial product sold by Holt Software Associates (HSA), the company Ric Holt founded to develop and support the language along with its Ready to Program (RTP) teaching environment. Around November 25, 2007, HSA ceased active development, and on November 28, 2007, Turing was released as freeware, made available to download at no cost for personal, commercial, and educational use. The last releases were in the 4.1.x series; note that versions 4.1.1 and 4.1.2 no longer generated standalone .exe files the way earlier releases did.

With official development ended, the torch passed to the community. The most notable continuation is Open Turing, an open-source fork of Object-Oriented Turing 4.1.2 for Windows written by Tristan Hume and active by around 2012. It reportedly offers speed improvements, a new code editor, and additional features such as OpenGL 3D support while remaining backward compatible with the original interpreter. Because the classic implementation targeted Windows, running Turing on other platforms today typically relies on such community projects or on emulation.

Turing is therefore best understood as a historically significant, still-runnable teaching language whose commercial development has ended, but whose open-source descendants keep it usable for enthusiasts and nostalgic former students.

Why It Matters

Turing occupies a distinctive place in the history of computing education. For a large cohort of Canadian students — particularly in Ontario, where it was a fixture of high school computer science — Turing was the first programming language they ever wrote, the environment in which loops, variables, and procedures first clicked. Its emphasis on clean syntax, strong typing, and immediate feedback anticipated design values that later beginner-focused languages and environments would embrace.

Beyond the classroom, the Turing family demonstrated how a single teaching language could scale outward: from the pared-down “Classic” language, to the systems-capable Turing Plus, to the object-oriented version that became the default, and finally to TXL, a serious research tool. That trajectory — rooted in the SP/k and Euclid traditions of the University of Toronto — reflects a coherent, decades-long effort to make programming both learnable and rigorous. Even in retirement, Turing remains a well-regarded example of a language designed, first and last, around the person sitting down to learn.