Luca Dan Șerbănați

RTL/2 was a small real-time programming language designed by J. G. P. Barnes at Imperial Chemical Industries in 1972. The language was based on ALGOL 68 and allowed separate compilation of program components called bricks. The design of RTL/2 was guided by principles that are essential for real-time systems, where performance and predictability are paramount: simplicity, reliability, and efficiency. Accordingly, the language introduced several key concepts:

• strong typing of variables, thereby reducing the risk of programming errors and improving code reliability;
• modularity: the language supported the separate compilation of modules, known as bricks;
• compact syntax: by following a minimalist design, RTL/2 ensured that programs were easy to read and write.

Several characteristics of RTL/2 were also adopted in the LPTR language:

1. In RTL/2, code units, or modules, were called bricks. These bricks represented different components of a program and were classified into four categories:
   • procedure bricks: named, re-entrant pieces of code;
   • data bricks: named, static collections of scalars, arrays, and records;
   • stack bricks: storage areas reserved for the execution of all procedures belonging to a single process; they also contained the call stack, local variables, and other auxiliary elements;
   • SVC bricks (Supervisor Call): interaction with the host environment of an RTL/2 program was provided through special procedures and protected data, called SVC procedures and SVC data.
2. Memory management and real-time constraints: a defining feature of RTL/2 was its approach to memory management. The language had no dynamic allocation mechanisms, a design choice consistent with the deterministic nature of real-time systems.
3. RTL/2 compiled into assembly language and provided the CODE statement, which allowed assembly language to be embedded in RTL/2 source code.

RTL/2 was used in various fields requiring real-time computing capabilities, including industrial automation, aerospace and defence, telecommunications, and others. Our colleagues at ICI who worked on real-time information systems hoped that RTL/2 would become a worldwide industrial standard and provide a basis for cooperation with other countries, especially the United Kingdom.

Our contract with ICI lasted two years and provided for the development of a compiler for a language compatible with RTL/2. The compiler was to be included in the National Program Library (BNP), accessible to all interested industrial organizations. At the end of the contractual period, the Polytechnic team under my leadership completed the implementation of LPTR, and the compiler was validated and deposited in the BNP. I received no further information about its fate. It was probably not adopted by industry—much like RTL/2 itself, which, although standardized, died a natural death, as many unused software products do.

For me, the LPTR contract meant forming and leading a team of colleagues and students for the design and implementation of the compiler. After making minor changes to the RTL/2 syntax, I transformed the LPTR syntax into an LL(1) grammar, which made top-down parsing possible. The grammar was attributed, enabling an elegant semantic analysis. Finally, code generation was performed in MACRO, the assembly language of the target INDEPENDENT minicomputer. The entire compiler was written in C.

This experience brought me significant technical maturity and a new perspective on the management of complex projects.