1.1 The History of T3X

In the mid-90's, I was (once again) looking for a programming language providing the following properties:

1. Simple and straight-forward syntax and semantics
2. Very high portability
3. A small and simple implementation, preferrably in written in itself
4. Suitability for both, interpretation and native code generation

One might think that there must have been quite a few languages providing these features, but obviously my search did not lead to any satisfactory result, or I would not have invented T3X. Point (3) turned out to be particuraly hard to match. The language which came closest to my requirements was BCPL. The typeless approach, which has been very consistently implemented in this language, leads to clear, simple, and flexible semantics. The language is portable, its implementation is small and can easily be done in BCPL itself. The compiler provided by Martin Richards, the inventor of BCPL, generates code which is aimed at interpretation (for the purpose of porting the compiler), but may be translated to native code as well.

Unfortunately, the syntax of BCPL reflects its otherwise overwhelming elegance only to a limited degree. In my opinion, the precedence of some operators is counter-intuitive. The language is also hard to parse by a pure recursive descent (RD) parser. There are, for example, precedence rules for statements, which make parsing and understanding BCPL programs unnecessarily hard. An RD parser had always been a prerequisite for my language of choice, because they are very easy to implement.
[At this point I have to add that Richard's BCPL compiler is small, elegant and easy to understand, even though it does use syntax trees and a bottom up parsing technique.]

Even if BCPL did not match my ideas exactly, it came pretty close and studying the language and compiler sources has influenced the design of T3X a lot. Without BCPL, T3X would not be the language it is today.

The most important thing when designing a programming language is to define its main purpose. The design goal of T3X was to create a portable, simple, and easy to understand notation for the description of algorithms. T3X was never aimed at industrial software development. Its purpose is to support the programmer in the process of reasoning about problems. It should be a productivity tool in the sense that it provides a playground for new ideas and allows the creator of these ideas to share it with others using a formal notation. Such a notation, of course, has to be clear, simple, easy to learn, and it would be a great advantage, if a compiler for this notation would be available in many different environments.

Naturally, my interpretation of productivity is not exactly the same as in the profit-oriented `real world' and the design of the T3X language reflects this intention well. T3X is not suitable for writing large scale application programs, nor for `rapid application development'. Originally, it was is more a notation than a programming language. Because it is simple and straight-forward, it does not force its user to pay too much attention to the language itself. Instead, it provides some very basic building-stones which may be used to construct a formal solution for a given problem.

There are many popular programming languages which provide very high level features which are very helpful when creating 'real world application programs'. However, all these features do not really help the programmer solve a problem (unless the problem is to create an application program). When I am talking about a `problem', however, I usually mean the search for an algorithm. Frequently, people say things like

Mostly, such statements are the result of too little reasoning. Basically, any algorithm can be implemented in any language. The only difference is in the amount of work one has to do to solve the same problem in different languages. So the correct form of the above statement would be

T3X provides only a very basic set of building-stones, but it turns out that this set is suitable for solving a variety of different problems in a convenient way - including, for example, the creation of a compiler and runtime environment for the T3X language itself.