BETA

BETA is a statically typed, pure object-oriented programming language from the Scandinavian school of object orientation, the tradition that produced Simula. Its most distinctive idea is the pattern, a single construct that stands in for classes, procedures, functions, coroutines and exceptions. BETA never gained a wide audience, but it carried the ideas of Simula in a different direction, and some of its ideas (nested classes, virtual classes) have been discussed in language-design research.

History & Origins

The BETA project began in 1976 as part of the Joint Language Project, an initiative taken in autumn 1975 at the Regional EDP Centre at Aarhus University. The designers’ later account, the HOPL III paper of 2007, says the original team was Kristen Nygaard, Bent Bruun Kristensen and Ole Lehrmann Madsen, and that Birger Møller-Pedersen joined later in 1976. Nygaard, co-creator of Simula with Ole-Johan Dahl, was a driving force behind it.

The project was initially expected to finish in a year or two. That did not happen. A first language proposal appeared in February 1979, and a survey report in 1981 formed the basis for the first implementation, which the authors date to 1983. The first published paper on BETA was accepted at POPL in 1983. This page uses 1983 as the year because that is when the language was first implemented and presented. The design work itself goes back to 1976, and the authors say the sequential part of the language became stable in late 1986 and early 1987. They say the concurrent (coroutine and concurrency) part reached its final form in late 1990 and early 1991.

Design Philosophy

BETA was meant to be a small, general set of concepts that could cover what other languages spread over many constructs. The authors describe it as continuing the Simula line while aiming for a more unified foundation. Everything is described in terms of objects and patterns, and the language is statically typed.

Patterns

A pattern can act as a class, a procedure, a function, a coroutine or an exception, depending on how it is used. A simple record-like class looks like this:

point: (#
    x, y: @integer
#)

A function-like pattern uses enter for input, do for the action part and exit for the result:

max: (#
    x, y, z: @integer
enter (x, y)
do
    (if x >= y // True then
        x -> z
    else
        y -> z
    if)
exit z
#)

A Hello World program in the Wikipedia-style listing is:

(#
do 'Hello, World!' -> PutLine
#)

I did not run this example against a compiler, so treat the exact library call as indicative.

Key Features

• Unified patterns. Classes and procedures are the same kind of entity, so procedure-like behaviour can be specialized with subpatterns.
• Nested patterns. Because patterns are attributes of objects, a pattern cannot be instantiated without an object context, which gives BETA nested classes.
• Virtual patterns. Virtual entities are never overridden but further bound in subpatterns, which is how BETA supports virtual classes as well as virtual methods.
• The inner construct. Inherited from Simula, inner combines the action part of a superpattern with that of a subpattern, so the superpattern controls when the specialized part runs.
• Coroutines and concurrency. Objects can act as coroutines, and the language has facilities for concurrency and semaphores.
• The fragment system. A mechanism for modular, separately compiled program pieces and for combining source fragments; it took its final form during the Mjølner project.

Evolution

The Mjølner project ran from 1986 to 1991 and produced the practical BETA systems. According to the designers, it delivered native compilers for Sun and Macintosh among others, and libraries and GUI frameworks for Athena, Motif, Macintosh and Windows. It also produced the MjølnerTool, an integration of a browser, a syntax-directed editor, a debugger, an interface builder and a CASE tool. The team also mentions contracts with Apple Computer Europe (Macintosh) and Apollo Computer. Mjølner Informatics was, according to its own history, founded in 1988 and sold the system commercially for many years. The authors say sales never generated a high profit.

The 1993 book by Madsen, Møller-Pedersen and Nygaard became the standard description. Later research directions included metaprogramming, reflection, distributed programming and the generalization gbeta. There were also research projects on integrating BETA with .NET and Java, described on the BETA site as research rather than production tools.

Current Relevance

The official BETA home page at Aarhus University states that the BETA projects are currently inactive and that its pages are not being maintained. The HOPL III paper says the Mjølner BETA System is no longer a commercial product. I found no evidence of a current release, so this page lists the language as historical. Documentation, the book, the reference manuals (for example MIA 94-26 and MIA 99-41) and the compiler manual (MIA 90-02) remain available there.

Why It Matters

BETA is a rare case of a second-generation Simula-family language designed by many of the people around Simula. Its pattern concept, nested classes and virtual patterns explored options that mainstream languages took only partly, and it remains a reference point in discussions of object-oriented language design. For a reader interested in where object orientation could have gone, it is worth reading.

Sources and Caveats

Dates come from the designers’ HOPL III paper (2007) and the BETA home page at Aarhus University. The 1983 first-implementation date and the POPL 1983 paper are stated in that paper. Wikipedia gives “implementations known since 1986”, which probably refers to the Mjølner work. I did not verify platform support beyond the designers’ statements, nor the University of Dortmund teaching adoption or the exact 1979 revision month, and I did not verify any influence on other languages beyond gbeta.