ELAN

ELAN is a structured, strongly typed teaching language from the ALGOL family. It was created in West Germany in the mid-1970s as a deliberate alternative to BASIC in schools. The design came from C.H.A. “Kees” Koster, one of the editors of the ALGOL 68 report, and his group at the Technical University of Berlin. It was developed further with the computing centre of Bielefeld University and the national research centre GMD. ELAN’s best-known feature is the refinement: a named, parameterless piece of code that lets a beginner write a program top-down as a series of plain-language steps, then define each step underneath. According to the English Wikipedia, ELAN never spread much beyond schools in Germany, the Netherlands, Belgium and Hungary. In Germany, though, it shaped a generation of school computer science teaching. It also had an unusual afterlife: the operating system written to run it, EUMEL, led to Jochen Liedtke’s L3 and, from there, to the L4 microkernel family.

History and Origins

SLAN: a family of languages (1974-1976)

The fullest early account of ELAN’s origins is the history chapter of the 1979 ELAN-Sprachbeschreibung, which the 1979 ELAN-Handbuch by Rainer Hahn and Peter Stock reprints. According to that account, Koster presented the first provisional description of a planned language family called SLAN at the end of 1974, while he was at TU Berlin. The idea was a series of language levels, each building on the one below, for uses ranging from teaching in schools and universities up to systems programming. The design drew on experience from TU Berlin’s introductory “Algorithmen” course and from further-training courses for schoolteachers. Both groups, the account says, showed that a new language was needed to support systematic program development.

Staff at Bielefeld University’s computing centre (Hochschulrechenzentrum, HRZ), namely Hahn, Heinrichs, Liedtke and Nolting, had drafted a language of their own. The two groups agreed to develop and implement the teaching level of SLAN together. Two Bielefeld diploma theses, by Jochen Liedtke and Ulrich Bartling, produced the first compiler, for a dialect called SLAN3B. It was written in Koster’s machine-independent Compiler Description Language (CDL) and ran on a Siemens 4004 under BS 1000. Because CDL was portable, it was later moved to the IBM 370 under VM/370-CMS and to the Telefunken TR 440.

The Arbeitskreis Schulsprache

SLAN was first presented publicly in 1975, at a workshop on school languages held by FEoLL, a research and development centre for educational technology in Paderborn. It was then submitted to the Arbeitskreis Schulsprache (ASS), a working group on school programming languages funded by the Federal Ministry for Research and Technology. Peter Heyderhoff of GMD’s Informatik-Kolleg backed SLAN and dropped his own design, called SOL. Stefan Jähnichen and Wilfried Koch of TU Berlin represented SLAN in the working group. With Karl Kleine they wrote the first language description of what had by then been renamed ELAN.

The working group’s final report recommended that schools stop using BASIC and adopt ELAN and Pascal instead. The German Research Foundation (DFG) then funded full-time ELAN work at TU Berlin. Günter Hommel and Joachim Jäckel continued the language design, and A. Bernatzik worked on a compiler, which was left unfinished when DFG funding ended in late 1977. The language description reached version 2.3 as TU Berlin report 78-28 in 1978. In 1979 it was published as a book, the ELAN-Sprachbeschreibung, by Hommel, Jäckel, Jähnichen, Kleine, Koch and Koster. Koster himself had left Berlin in 1977 to become the first professor of informatics at the University of Nijmegen in the Netherlands, where he went on teaching with ELAN.

What does the name mean?

The sources do not agree. The 1979 ELAN-Handbuch calls it the “Ausbildungssprache ELAN (Elementary LANguage)”. According to the EUMEL preservation project, Leo Klingen’s 1983 article on ELAN in the teachers’ journal LOG IN uses the same expansion. Other sources, including the Hommel et al. language description as cited by the same project and the German Wikipedia, expand it as Educational LANguage. Both expansions fit the language’s purpose.

Design Philosophy

The Nijmegen ELAN manual is unusually frank about the design. It calls ELAN “not an experiment in language design; both syntactically and semantically it is quite conventional.” It describes a typical ALGOL-family language, “more related to ALGOL68 than to PASCAL”, built for one job only: teaching systematic programming. The Bielefeld handbook lists the design aims drawn from the language description. ELAN should be:

• a tool for teaching computer science to beginners;
• a language in which algorithms are written simply and readably, so that the code “reflects the solution”;
• simple in structure, so its syntax and semantics are easy to teach and learn;
• flexible through a few simple rules for combining constructs;
• safe, so that unintended semantic side effects are avoided as far as possible;
• a language that supports both top-down construction of algorithms (“programming in the small”) and bottom-up construction of abstractions.

ELAN got its simplicity by leaving things out. Compared with ALGOL 60, the handbook notes, it has no GOTO, no explicit compound statements, no blocks and no nested procedures. Compared with ALGOL 68, its data structures are limited to fixed-size rows and structures, with no reference (pointer) concept. For safety, a name may hide (shadow) another only across packet boundaries: a later packet may redefine something exported by an earlier one. Shadowing inside a program, as with nested blocks in ALGOL 60 or nested procedures in Pascal, is not allowed, because the handbook says it “easily leads to errors”.

Key Features

Refinements: top-down programming in the small

A refinement is a named sequence of statements, defined after the point where it is used and ended by a full stop. A program can therefore start as a short outline in plain language. In the style of the Bielefeld handbook:

INT VAR sum :: 0, i;
add up the numbers;
print the result.

add up the numbers:
  FOR i FROM 1 UPTO 10 REP
    sum := sum + i
  END REP.

print the result:
  put ("Sum:");
  put (sum).

Identifiers may contain spaces, so add up the numbers is a single name. Keywords and type names are written in capitals, which ELAN calls “bolds”. Refinements have no parameters and no data space of their own, and the compiler expands them in line. For that reason, the handbook explains, they cannot be recursive; procedures are used for recursion. A refinement can also deliver a value, and LEAVE refinement WITH value exits early from it:

IF value found THEN ... END IF.

value found:
  INT VAR row;
  FOR row FROM 1 UPTO n REP
    search columns
  END REP;
  FALSE.

search columns:
  INT VAR col;
  FOR col FROM 1 UPTO n REP
    IF matrix [row] [col] = wanted
    THEN LEAVE value found WITH TRUE
    END IF
  END REP.

The German Wikipedia article sums up the effect: used well, refinements make ELAN programs largely self-explanatory.

Conventional structured control flow

ELAN’s control structures are Dijkstra’s standard ones plus a leave statement:

For example, here is the handbook’s days-in-a-month selection, with the identifiers translated:

SELECT month OF
  CASE 2: IF leap year THEN days := 29 ELSE days := 28 END IF
  CASE 4, 6, 9, 11: days := 30
  CASE 1, 3, 5, 7, 8, 10, 12: days := 31
  OTHERWISE no month
END SELECT

Access rights: CONST and VAR

Every data object is declared with an access right as well as a type: INT CONST limit :: 100 or REAL VAR total. Parameters are declared the same way, as in PROC push (INT CONST value), so a procedure’s signature shows whether it can modify its arguments. The basic types are INT, REAL, BOOL and TEXT. ROW n T builds fixed-size arrays and STRUCT (...) builds records. LET gives names to constants and type expressions.

Bottom-up abstraction: types, operators and packets

For larger programs ELAN offers what the handbook calls “strong” abstraction. Programmers can define new types (TYPE SALARY = REAL). A new type is distinct from its underlying type, and the concretiser CONCR gives typed access to that underlying “fine structure”; fields of a STRUCT-based type are selected with the usual dot notation. They can also define procedures and new operators, including operator priorities. The unit of modularity is the PACKET, which exports an explicit interface with DEFINES. The handbook’s complex-number example (identifiers translated) shows all of these together:

PACKET complex DEFINES COMPLEX, complex zero, put, +:

TYPE COMPLEX = STRUCT (REAL re, im);

COMPLEX CONST complex zero :: COMPLEX: (0.0, 0.0);

COMPLEX OP + (COMPLEX CONST left, right):
  COMPLEX: (left.re + right.re, left.im + right.im)
END OP +;

PROC put (COMPLEX CONST c):
  put (c.re); put ("i"); put (c.im)
END PROC put

END PACKET complex

Packets could be compiled ahead of time and shared with other users. The handbook notes that most of the standard library, including the mathematical functions and the TEXT operators, was itself written in ELAN as packets.

Implementations and Evolution

EUMEL: an operating system for a language

ELAN was meant for schools, but in the late 1970s schools could not afford mainframes. HRZ Bielefeld, with GMD support, therefore built a compiler and runtime system for cheap Zilog Z80 microcomputers with 64 KB of RAM. This system became EUMEL, the “Extendable Multi-User Microprocessor ELAN System”. Eumel is also a colloquial German word for a likeable fool. According to the EUMEL preservation project at 6xq.net, version 0.7 dates from May 1979. EUMEL was described in GMD’s house journal and at the annual conference of the German computer science society (GI) that same year.

EUMEL was well ahead of typical microcomputer systems of its time:

• ELAN was compiled to bytecode for EUMEL0, a process virtual machine designed specifically for ELAN. Only this layer and a thin hardware layer (SHard) had to be rewritten for each new machine.
• A single-level store kept every file and task in one virtual address space. Pages were swapped to disk transparently and shared copy-on-write.
• The whole system was persistent: it took a snapshot every 15 minutes or on request, and after a power cut all tasks resumed from the last snapshot.
• One machine could serve several serial terminals, which suited school computer rooms.

ELAN served as EUMEL’s system language, programming language, command language and documentation language. In 1982 GMD’s MIKROS project rewrote the original ELAN compiler in CDL2. EUMEL was ported to the Zilog Z8001 (Olivetti M20, shown at the 1983 Hannover Messe), the Motorola 68000 and the Intel 8086 family. In December 1985 a GMD/HRZ delegation including Liedtke and Heyderhoff received a Technologie-Transfer-Preis for their efforts to transfer EUMEL to Japan. The spin-off company ERGOS began marketing EUMEL in October 1987. Sources disagree on how widely it was installed. Liedtke’s 1993 retrospective paper speaks of 2,000 systems by 1985, while a GMD report counted about 1,000 by the end of 1986.

L3 and the road to L4

Liedtke first presented ideas for a successor to EUMEL in 1985. That successor, L3, was presented in 1988. It replaced the EUMEL0 virtual machine with native code for the Intel 386, which by then had the memory-management hardware EUMEL0 had emulated. ELAN remained its language. Liedtke’s later work on making L3’s message passing fast led to the L4 microkernel, and the TU Dresden operating systems group still hosts ELAN documentation among its L3 pages. Calling EUMEL “L2”, as both Wikipedias do, is a retrospective label: the EUMEL preservation project notes that the name appears in no EUMEL documentation or source code.

Nijmegen ELAN

At the University of Nijmegen, Koster’s group kept ELAN alive for teaching. They developed an ELAN programming environment for MS-DOS PCs and made it freely available for non-commercial use. In 1987 Koster published the English-language textbook Top-Down Programming with Elan (Ellis Horwood). Later, Marc Seutter wrote a new compiler for Unix-like systems, elancc. Its ChangeLog dates version 1.0 to January 2003. The compiler generates assembly code and uses gcc to assemble and link. Its README lists x86 Linux, amd64 FreeBSD, SPARC Solaris and Alpha NetBSD as tested platforms. Later versions added a socket library, threads, an AMD64 code generator (1.8, January 2007) and an experimental X11 binding. FreeBSD packaged the compiler as lang/elan from 2005 until the port expired in 2020. In 2024 Ulrich Hoffmann republished the elancc 1.11 sources on GitHub.

Current Relevance

ELAN is a historical language. According to the English Wikipedia, schools had largely stopped using it by the end of the 1980s. Koster died in 2013. Two preservation efforts keep it usable today:

• The EUMEL preservation project (6xq.net/eumel, with sources mirrored on GitHub) has rescued install floppies for EUMEL 1.8.x and L3. It gives step-by-step instructions for installing EUMEL in a QEMU virtual PC, which gives you a working ELAN system as schools used it.
• elancc (github.com/uho/Elan) compiles ELAN source files to native executables with gcc on Linux and other Unix-like systems.

No official or community Docker image is known.

Not to be confused with

• ELAN (rewriting logic), a rule-based specification and programming language developed in the 1990s by Borovanský, C. Kirchner, H. Kirchner, Moreau, Ringeissen and others in Nancy, France. The English Wikipedia article on the teaching language currently cites their paper “An Overview of ELAN” (1998) by mistake.
• Elan (2023), a new UK-designed educational language. According to the English Wikipedia, it has no historical connection to this one.

Why It Matters

ELAN is one of the clearest examples of a language designed from the start around a way of teaching. Many educational languages simplify an existing language. ELAN instead built stepwise refinement, the method Wirth and Dijkstra had promoted, directly into its syntax. A beginner’s program could read like an outline, and each plain-language step was then defined below it. Its designers came from the ALGOL 68 tradition and knew how large that language had grown, so they cut it down rather than added to it, keeping strong typing, operators, user-defined types and modules.

It also shows how much a national education policy could shape computing. A government-funded working group recommended against BASIC in the 1970s. That decision led to a teaching language, then to a persistent, portable, multi-user operating system to run it in schools, and finally, through Jochen Liedtke, to one of the most influential microkernel lines in operating-system research.