L.S.E.

L.S.E. (Langage Symbolique d’Enseignement, “symbolic teaching language”) is the programming language France chose in the early 1970s to bring computers into its secondary schools. It was designed at the École Supérieure d’Électricité (Supélec) by Yves Noyelle, with Jacques Hebenstreit, head of the school’s computing department. It ran on the Télémécanique T1600 and CII/SEMS MITRA-15 minicomputers installed in the “58 lycées” experiment. LSE was an interactive, interpreted, line-numbered language like BASIC, but its keywords were French: AFFICHER, LIRE, SI ... ALORS ... SINON, FAIRE ... POUR ... JUSQUA, ALLER EN, TERMINER. It also had strong string handling, which BASIC of the period lacked. For more than a decade it connected a community of French teachers who wrote their own educational software. Through the 1980s it was France’s national alternative to BASIC on school microcomputers.

History & Origins

LSD: a language for Supélec’s students

LSE grew out of an earlier Supélec language. Yves Noyelle’s 1988 history, “La Saga du LSE et de sa famille”, is the main firsthand source. It describes the problem the school faced at the end of 1967: about 600 students needed access to a computer, and the only machines were an old SEA CAB 500 and a new IBM 1130 running batch FORTRAN. The school bought a Hewlett-Packard 2116A minicomputer to drive a time-sharing system, and Noyelle took charge of the project. He had just returned from Stanford, where he had been in contact with Patrick Suppes’s computer-assisted instruction team and their time-sharing system on a PDP-1.

Noyelle concluded that a time-shared system for beginners needed a language that could be compiled one line at a time and run under an interpreter that caught every error. Such a language would not have to retranslate a whole program after each change, and an error in a student’s program could not bring the system down. Between March 1968 and March 1969 he designed LSD (“Langage Symbolique Didactique”). It ran on the 1130 and 2116 together, serving thirteen ASR-33 Teletypes. The language was first called LPS (Langage de Programmation Scientifique), but that name turned out to be taken. A team member, Paul Gavarini, suggested LSD and backed the idea with a stack of “LSD, j’aime” postcards, which the team stuck on the computers. Noyelle names another influence besides Suppes’s system: PAF (Programmation Automatique de Formules), the French-syntax interactive language of the CAB 500, which he says had pursued a similar philosophy “before 1960”.

From LSD to LSE

In March 1970 the OECD’s Centre for Educational Research and Innovation held a seminar at Sèvres on computers in secondary education. The French Ministry of National Education decided to install computers in a number of lycées as an experiment. Hebenstreit, who attended the seminar, proposed LSD as their language. According to Noyelle, his reasons were that it had an easy core but real power, could be implemented efficiently on small cheap computers, “spoke” French, and needed no specialist operators. After a demonstration with a transistor-amplifier design program, LSD was accepted on two conditions: that it change its name, and that it be made usable by every teacher in a lycée, not just science teachers.

The new name was LSE, because E follows D. Noyelle gives two original meanings, Langage Symbolique d’Enseignement and Langage de Sup-Élec. Later came Langage Simple à Enseigner and the mocking Langage Sans Espoir (“hopeless language”), which Noyelle attributes to BASIC loyalists. Hebenstreit argued that text was the common ground of most school subjects, so LSE gained a character-string type. Noyelle designed its string operations between June and September 1971, drawing on LISP, the string facilities of PL/I, and a suggestion from colleague J.-Ph. Szylowicz to study what a text-processing program (the LSD compiler) actually did most often. At the same time he added a loop statement derived from ALGOL, improved output formatting, functions for the date and random numbers, and keyed data files. Supélec delivered the LSE definition report to the Ministry in October 1971.

The 1972 implementations

The Ministry chose two French minicomputers, the Télémécanique T1600 and the SEMS (CII) MITRA-15, and set the September 1972 school term as the deadline. Each needed a time-sharing system serving at least nine terminals. According to Noyelle, Télémécanique “nearly” made the deadline: it delivered two systems at the end of October 1972, on machines with 16 KB of memory and a 256 KB disk. SEMS left its implementation to Supélec. The team fitted the system into a MITRA-15 with only 8 KB of core and a 384 KB disk, using compaction and dynamic overlays, and gave each user about 4 KB of workspace. A “very primitive” version shipped in December 1972, and the complete system arrived only in June 1973. Hebenstreit and Noyelle presented the language at the AFCET congress in Grenoble in November 1972.

This page uses 1972 as LSE’s year, when the first working LSE systems were delivered and the language was first presented publicly. The language definition itself is dated 1971.

The “58 lycées” experiment

Between 1973 and 1976 France equipped 58 lycées and collèges with Mitra 15 and T1600 machines. Each was about two metres tall and came with nine terminals and a Teletype with a paper-tape reader. Jacques Baudé, who taught at one of the schools, records that the lycée of La Celle Saint-Cloud received the first Mitra 15 in February 1973, after the machine had spent time at Supélec for LSE debugging. Loading the LSE system from paper tape took more than an hour, until floppy disks replaced the tape. (Pascal Bourguignon’s NASIUM LSE documentation speaks of “57 lycées”; the EPI association, Baudé and the INRP use 58.)

The first LSE manual was a special issue of the INRP liaison bulletin in April 1973, revised in January 1975. Several hundred teachers received intensive training. According to Baudé, teachers wrote about 800 LSE programs for teaching their subjects between 1972 and 1979. About 400 of them were catalogued and distributed to the schools free, with the source code, as punched tape and later floppy disks. Each came with a teacher’s guide, a student booklet and the LSE listing. The INRP’s evaluation counted more than 45,000 pupils and more than 1,000 teachers using the machines each year.

The experiment ended abruptly. The Ministry abolished its Mission à l’informatique in September 1975, austerity budgets followed, and no more lycées were equipped after 1976.

Standardisation and the microcomputer era

LSE revived in 1979 with the government’s “10 000 micro-ordinateurs” plan for schools. An AFNOR commission was set up to define the language and its programming environment precisely, so that programs would be portable between implementations. Its members included Noyelle, B. Commiot (ENS Saint-Cloud), J.-P. Lamoitier, B. Leroy (CII-HB), P. Muller (INRP) and J. Robert (CAP Sogeti). The text was finished in July 1982, “thanks to (or in spite of) much non-technical pressure and counter-pressure”, in Noyelle’s words. AFNOR published it as the experimental standard Z 65-020 in December 1983. The standard added:

• separately compiled, dynamically loaded external procedures
• compiling a procedure at run time, so that a formula typed at the keyboard could be evaluated
• logical devices
• file and record locking for networked use
• a boolean type and an extended-precision numeric type for arbitrary-precision arithmetic
• calls to routines written in other languages
• string comparison under any collating order

Graphics primitives taken from LSG were added after the standard.

Supélec declined to build the new implementations: in Noyelle’s words, building LSE once had been research, but building it in series was not. Three companies took on the job: MICRODUR, EDL and later LOGICIA. By 1988 Noyelle could write that LSE existed on the Education Ministry’s hardware, where contracts required it (and where all but one supplier, the largest, had delivered it), as well as on IBM PC compatibles, the Macintosh and Commodore machines.

Design Philosophy

Noyelle’s guiding principle was that a tool should “make life as easy as possible for whoever uses it, and not impose constraints on them, especially avoidable ones”. In LSD and LSE this showed in several ways:

• Line-by-line compilation. Every line, including declarations, can be added, changed or deleted without recompiling the rest of the program. Each line is translated into a compact postfix (reverse Polish) form when it is typed. The source text is not stored; listings are regenerated from the postfix code.
• Complete run-time checking. The interpreter detects all semantic errors, including use of uninitialised variables, so a student’s mistake cannot crash the system.
• Few modes. There is a monitor mode and an execution mode. A line beginning with a number is a program line, and any other line is a command. Commands can be typed using only their first two letters, and the system completes them.
• Built-in debugging. The ESC key stops a running program at any point, even in the middle of printing. The user can then inspect or change any variable and continue without losing a character of output. LSE added single-stepping, breakpoints and an immediate mode that makes the system usable as a desk calculator.
• Few declarations. Numbers need no declaration. Strings (CHAINE) and arrays (TABLEAU) are declared, and arrays are dimensioned dynamically.
• French keywords. Hebenstreit said that pupils should not get the impression that computing meant speaking English. Noyelle later wondered whether English keywords would have served the language’s future better.

In a preface quoted by Baudé, Hebenstreit insisted that it was “wrong to say that LSE was inspired by BASIC”, which in 1970 was “almost non-existent in France”. He named its two sources as PAF and ALGOL.

Key Features

Program structure

An LSE program is a set of numbered lines. A line beginning with * after its number is a comment. Statements on the same line are separated by semicolons. Assignment uses a left arrow (←), which ASCII terminals and modern reimplementations write as _. Procedure names begin with &, so calls are easy to spot in the source. Procedures can have local variables and take parameters by value or by reference, and they can be recursive.

Here is a FizzBuzz program from the examples of the NASIUM LSE reimplementation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

1*PASCAL J. BOURGUIGNON, 2012-09-19
2*FIZZBUZZ
3*AFFICHE LES ENTIERS DE 1 A 100, SAUF FIZZ POUR LES MULTIPLES DE 3, BUZZ POUR LES MULTIPLES DE 5.
4*
5*TOURNE
10 CHAINE FB
20 FAIRE 45 POUR I_1 JUSQUA 100
30 FB_SI &MOD(I,3)=0 ALORS SI &MOD(I,5)=0 ALORS 'FIZZBUZZ' SINON 'FIZZ' SINON SI &MOD(I,5)=0 ALORS 'BUZZ' SINON ''
40 AFFICHER[U,/] SI FB='' ALORS I SINON FB
45*FIN BOUCLE
50 TERMINER
100 PROCEDURE &MOD(A,B) LOCAL A,B
110 RESULTAT A-B*ENT(A/B)

A few things to notice:

• FAIRE 45 POUR I_1 JUSQUA 100 repeats every line up to and including line 45 for I from 1 to 100. The loop is bounded by a line number, not by an end keyword.
• SI ... ALORS ... SINON can be used as an expression, which yields a value, as well as a statement.
• AFFICHER[U,/] is formatted output. The format list in brackets says to print the value in its natural form (U) and then a new line (/).
• &MOD is a user-defined function. LOCAL A,B makes the parameters local copies, so they are passed by value. RESULTAT returns the function’s value.

Strings

LSE’s string facilities were its most distinctive feature. They included concatenation, length (LGR), substring (SCH), search (POS) and related functions. A substring could be delimited by a stop character or a set of stop characters as well as by a length, an idea Noyelle credits to S. Berche. Jacques Arsac, who did nearly all of his programming in LSE from 1973, rewrote a 500-line SNOBOL program-manipulation system as 500 lines of LSE. He ranked the languages he knew for text handling as “PASCAL < APL < LSE < SNOBOL”. He also preferred to represent stacks and trees as strings rather than with pointers.

Files

LSE’s data files were deliberately simple. Each record held exactly one complete object (a number, string or array) together with its type, and records were accessed by an arbitrary numeric key rather than sequentially. Users never opened or closed a file; this happened implicitly. Programs saved and loaded records with statements such as GARER and CHARGER. Every user was guaranteed a fixed amount of temporary file space, so a program that had run once could not later fail for lack of disk space. A linking statement let a large program load one module in place of another, and the modules communicated through files.

Protection for courseware

Teachers could lock a program in memory so that it could not be listed or modified. Noyelle explains that this stopped pupils from reading a tutorial program’s source to find the expected answer.

Performance and Size

Noyelle gives some figures for the Supélec MITRA-15 implementation. All are his own recollection in 1988, not independent benchmarks:

• The whole system, interpreter plus time-sharing operating system, occupied about 37 KB on the MITRA.
• Typical response time was “well under half a second” on a machine with 8 KB of core memory, designed for up to 16 terminals at a guaranteed minimum of 600 baud each.
• The Supélec MITRA-15 system performed “between three and four times better” than the competing Télémécanique T1600 system. He gives no workload or measurement method, so this is best read as the designer’s own comparison.

Evolution

Family: LSG and LST

Two languages grew directly out of LSE at Supélec:

• LSG (Langage Symbolique Graphique), defined in 1972 by Jean Le Bourdon, extended LSE for graphics consoles. It added items (a graphical shape plus a list of values, such as a capacitor symbol tagged “10 nF 20%”), patterns (motifs) for repeated sub-images, and targets for picking an item on the screen. It also added call-by-name parameters so that curve expressions could be passed to procedures.
• LST (Langage Symbolique de Test) was developed from 1973 to 1976 for Thomson-CSF’s automated test benches on the MITRA-15. It added dynamically loaded assembly-language procedures that could handle interrupts, task suspension and user-defined commands. Its assembler and text editor were themselves written in LSE. Noyelle reports that when the MITRA-15 went out of production, a compatible machine, the CMP-16, was built to keep LST running, and that about 600 were produced.

LSE83

By the mid-1980s LSE was squeezed between the small BASICs on cheap home computers and the Pascal favoured by universities. In June 1985 Jacques Arsac published LSE83 in the Bulletin de l’EPI. He argued that LSE “suffers from having been designed around 1968-1969, outside the current of structured programming”. He listed its problems: ALLER EN (GOTO) forced the management of line numbers, IF ... THEN ... ELSE had to fit on one line, functions and subroutines were confused under the single keyword PROCEDURE, and formal parameters were confused with local variables. LSE83 removed ALLER EN entirely. It kept line numbers only for editing, added TANT QUE ... FAIRE ... BOUCLER, POUR loops and a general FAIRE ... FINI loop, separated functions from subroutines, and added a minimal exception mechanism.

Arsac implemented LSE83 as a translator written in standard LSE, about 360 lines long. It ran on a THEMIS microcomputer (EFCIS-Thomson, Motorola 6800, 64 KB). Noyelle noted in 1988 that LSE83 corrected some of LSE’s defects “but it sacrifices compatibility”.

Current Relevance

LSE faded as French schools turned to the BASICs built into cheap microcomputers, to Pascal and eventually to mainstream languages. Today it survives mainly as a historical language. The most complete modern implementation is NASIUM LSE by Pascal J. Bourguignon. It is written in Common Lisp and released under the AGPL3. It compiles each source line into a bytecode vector and executes it on a virtual machine. Its first check-in dates from April 2010. It deliberately reproduces the MITRA-15 system “with all its constraints and limits”, including upper-case-only programs and the paper-tape file format, and it also offers a Unix command mode with lower-case input and script execution. A release was tagged in February 2022, and the repository received further commits in March 2026. A community Dockerfile for it exists on GitHub, but no image is published on Docker Hub.

The EPI association (Enseignement Public et Informatique), founded on 1 February 1971 by the teachers trained for the experiment, still hosts the key historical documents online. These include Noyelle’s history, Arsac’s LSE83 paper and the list of the 58 lycées.

Why It Matters

LSE is an early case of a programming language designed to order for a national school system, and one of the few non-English-keyword languages to see real institutional use. Its design anticipated ideas that later became common in teaching environments: an always-available interactive interpreter, incremental compilation, complete run-time error checking, debugging that suspends and resumes a program, and simple persistent storage for beginners. Its “58 lycées” experiment produced a generation of French teachers who wrote and freely shared hundreds of educational programs with their source code in the 1970s. Its later history, caught between BASIC and Pascal, is a case study in how hard it is to keep a national, language-specific standard alive against cheap hardware that ships with its own language.