Periodically, it is claimed that research in programming languages is now terminated, and that nothing new can be invented after completion of the design of the ultimate language X. Replace X with ADA, C, PROLOG, LOGO, Functional Programming, or any other language you prefer; ten years ago, you could have replaced X with APL, ALGOL 68, PL/I, etc. Surprisingly, however, research in programming languages continues to flourish, although its mainstream shifts from time to time from some aspects to others. (Maybe, in fact, some celebrated programming languages have closed research activity in some specialized aspects, such as orthogonality for ALGOL 68, or strong data typing for ADA.)

Although I would not risk any prediction about the current research directions about programming languages, it seems to me that control structures, after the partial eclipse that followed the main explosion of structured programming, are again a subject of wide interest. See, for example, CLU [1], SL5 [2], ICON [3], or POLY [4]. Magma 2, presented in this paper, is another example of these attempts to make the programmers build their own control structures, instead of providing them with a restricted and completely closed set of predefined ones. In order to distinguish the semantics of control structures from their syntax, various authors prefer to call control regimes the mechanisms they provide, thus leaving the old term to the predefined syntax constructs.

New control regimes are defined in the areas of coroutines, backtracking, goal-directed evaluation, or generators. The mechanisms provided also include well-known control regimes, such as iterations and recursions; the overall success of some new mechanism for defining control regimes could be measured by the naturalness and facility in which iteration and recursion are synthesized anew. The paper under review describes such an attempt, built upon a language called Magma LISP. This language is not described in the paper, but one may assume it bears some resemblance with some dialect of LISP, of course. This hypothesis is confirmed by the examples occurring in the text.

The paper itself is not very easy to read. Its overall structure is hard to find, since the author is frequently shifting between three means of description: plain English, pseudo-LISP, and denotational semantics. The parts of the paper using this latter means are the hardest to understand, of course; in fact, it seems as if they had been added to the text afterwards in order to give it a sufficiently theoretical flavor so that the paper would be accepted by ACM Transactions on Programming Languages and Systems instead of ACM Transactions on Mathematical Software. I would like to make another slight criticism, however: maybe LISP is a very good vehicle for defining new structures, from the implementor’s point of view, but I think that is not the case from the reader’s point of view. It is especially difficult to understand how recursion is defined in a pseudo-LISP without using recursion.

The regrettable result of these weaknesses is that this paper, despite its qualities and interest, would not be extremely useful for people other than those deeply involved in exactly the same research area. This is somewhat unfortunate, in my opinion, since I think research in control structures is interesting and useful, and should be much more widely known.