Modular Languages

20 Years Ago

In 1997 I started to study computer science and had the great opportunity to learn from Prof. Dr. Dr. h.c. Hans Langmaack, two years before he retired. He wrote one of the first compilers for the language ALGOL 60.

ALGOL was a milestone in the history of programming languages. It was a procedural language with a small and simple core, inspired by the λ-calculus. The syntax was formally defined based on the Backus-Naur-Form.

"Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."

- Tony Hoare, 1973

Hans Langmaack focused on programming languages, formal languages and compiler construction. I remember that he was vigorous about the rise of virtual runtime environments for portable languages, most notably the Java Virtual Machine (JVM).

In one of his lectures, somewhere between the reflexive transitive closure of a relation and the Kleene operator, he gave us insight into his thoughts. Mr. Langmaack explained to us his vision of future programming languages. I will never forget one sentence:

"Programmers will be able to choose the syntax of their preferred programming language."

- Hans Langmaack, 1997

Nowadays

We talk about polyglot programming. The JVM drives the diversification by housing many different languages, ascending trend. There is a convergence of programming languages while the followers of typed and untyped languages move apart.

Java was the first language on the JVM. We notice endless discussions concerning changes to its syntax. It is nearly impossible to accomplish consensus among all developers. Many proposals are rejected because of backward (or potential forward) compatibility issues. An example is JEP 186 / collection literals.

The Future

ints = [1, 2, 3]  

This could be Lang, a phantasy language on the JVM, similar to Java or Scala. The above example is the type-safe declaration of a list named 'ints'. It contains primitive integer values 1, 2 and 3. I configured the list literal [] syntax on my own because I feel comfortable in writing lists that way.

Immutability is default in Lang. I wrote an immutable list implementation which is automatically injected based on my own configuration of the runtime environment.

The real source code does look different. It is persisted in a portable language (do we still write to disks or does it live on a blockchain!?). My IDE transforms the code on-the-fly based on my underlying syntax definition.

My colleagues are a little bit out-dated. They are used to write in Scala. They configured their IDE to use a different syntax definition. It renders the portable code like this:

val ints = List(1, 2, 3)  

One colleague is very special ;) He does not like type inference and still uses Java, so his source is rendered slightly different:

final List<int> ints = List.of(1, 2, 3);  

A Modular Language

A small and simple core

Simplicity is the key to everything. So the core of Lang has to be simple and small. Languages are well-understood, also the wide field of types has been largely explored. The language architects and developers found consensus on the set of features the ideal programming language should support.

A library consisting of pluggable modules

Libraries are not part of the language any more. However, there are standardized configurations for different types of applications that extend the core of our language.

Exchangeable syntax

Making the syntax exchangeable incredibly increased the productivity of the developers. There isn't the urge any more to learn new languages. No discussion about formatting (tabs vs spaces), naming, JEPs, SIPs, ... it is just a matter of configuration.

Tempting topic, isn't it?

- Daniel