The Mjølner System: BETA Language

BETA is developed within the Scandinavian School of object- orientation, where the first object-oriented language, Simula, was developed. BETA is a modern language in the Simula tradition. The resulting language is smaller than Simula in spite of being considerably more expressive. BETA is a strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time. It is well known that it is not possible to obtain all type checking at compile time without sacrificing the expressiveness of the language. BETA has optimum balance between compile-time type checking and run-time type checking.

Powerful Abstraction Mechanisms

BETA has powerful abstraction mechanisms that provides excellent support for design and implementation, including data definition for persistent data. The powerful abstraction mechanisms greatly enhances reusability of designs and implementations.

The abstraction mechanisms include: class, procedure, function, coroutine, process, exception, and many more, all unified to the ultimate abstraction mechanism: the pattern. In addition to the pattern, BETA has subpattern, virtual pattern and pattern variable.

This unification of abstraction mechanisms gives a uniform treatment of abstraction mechanisms and a number of new abstraction mechanisms. Most object-oriented languages have classes, subclasses and virtual procedures and some have procedure variables. Since a pattern is a generalization of abstraction mechanisms like class, procedure, function, etc., the notions of subpattern, virtual pattern and pattern variable also apply to these abstraction mechanisms. The following table shows some of the possible combinations supported by BETA:

  class procedure generic class process exception
pattern + + + + +
subpattern + + + + +
virtual pattern + + + + +
pattern variable + + + + +
nested pattern + + + + +

Pattern:
The pattern is the ultimate abstraction mechanism that generalizes class, procedure, function, coroutine, process, exception, etc.
Subpattern:
The subpattern covers subclasses as in most other languages. In addition, procedures may be organized in a subprocedure hierarchy in the same way as classes may be organized in a subclass hierarchy. Since patterns may also be used to describe functions, coroutines, concurrent processes, and exceptions, these may also be organized in a pattern hierarchy.
Virtual pattern:
The notion of virtual pattern covers virtual procedures like in Simula, Eiffel and C++. In addition, virtual patterns cover virtual classes, virtual coroutines, virtual concurrent processes, and virtual exceptions. Virtual classes provide a more general alternative to generic classes as in Eiffel or templates as in C++.
Nested pattern:
BETA is a block structured language. This means that patterns can be textually nested. Nested procedures are known from Algol and Pascal. In addition to nested procedure patterns, BETA also supports nesting of class patterns. Nested class patterns makes it possible to define a class pattern as an attribute of an object. Often the structure of an object is defined by other classes. Nested makes it possible to define such classes where they logically belong.
Pattern variable:
BETA includes the notion of pattern variable. This implies that patterns are first class values, that may be passed around as parameters to other patterns. By using pattern variables instead of virtual patterns, it is possible dynamically to change the behavior of an object after its generation. Pattern variables cover procedure variables (i.e. a variable that may be assigned different procedures). Since pattern may be used as classes, it is also possible to have variables that may be assigned different classes, etc.

Coroutines and Concurrent Processes

BETA does not only allow for passive objects as in Smalltalk, C++ and Eiffel. BETA objects may also act as coroutines, making it possible to model alternating sequential processes and quasi- parallel processes.

BETA coroutines may be executed concurrent (non pre-emptive scheduling in current version). The basic mechanism for synchronization is semaphores, but high-level abstractions for synchronization and communication, hiding all details about semaphores, are easy to implement, and the standard library includes monitors and Ada-like rendezvous. The user may easily define new concurrency abstractions including schedulers for processes. The distribution library supports true concurrency between BETA objects. The current implementation only supports non-preemptive scheduling within a process. Preemptive scheduling and multi-processor support is currently being implemented.

Support for subfunctions of abstraction

BETA supports the three main subfunctions of abstraction:
Identification of Objects
It is possible to describe objects that are not generated as instances of a class pattern, so- called "class-less objects". This is in the many cases useful when there is only one object of a kind. In most object-oriented languages, it is necessary to define superfluous classes for such objects. In analysis and design, it is absolutely necessary to be able to describe singular objects without having to define them as instances of classes.
Classification
Classification is supported by patterns, subpatterns and virtual patterns that makes it possible to describe a classification hierarchy of objects and patterns (i.e. objects, classes, procedures, functions, coroutines, processes, exceptions, etc.).
Composition (Aggregation)
Objects and patterns may be defined as a composition of other objects and patterns. The support for composition includes:
Whole/part composition
An attribute of an object may be a part object. This makes it possible to describe objects in terms of their physical parts.
Reference composition
An attribute of an object may be a reference to another object. Reference composition forms the basis for modeling arbitrary relations between objects.
Localization
In the form of block-structure: An attribute of an object may be a (nested) pattern. The block- structure mechanism makes it possible to create arbitrary nested patterns. This makes it possible for objects to have local patterns used as classes, procedures, etc. Local patterns greatly enhances the modeling capabilities of an object- oriented language.

Inheritance

In BETA, inheritance is not only restricted to inheritance from superpatterns. It is also possible to inherit from a part object. Virtual patterns in the part object may be redefined to influence the enclosing object. Multiple inheritance is supported through inheritance from multiple part objects. This gives a much cleaner structure than inheritance from multiple superpatterns.

Downloads

Download The Mj°lner System
Download the book Object-oriented Programming in the BETA Programming Language(PDF)
BETA Programming Language related downloads

More Information

For further information see:

Books:

Object-Oriented Programming in the BETA Programming Language
Newsgroups:
comp.lang.beta
comp.lang.beta news archive
comp.object
Other information:
MIA 94-26: BETA Language Introduction - Tutorial
MIA 99-41: BETA Language Modifications - Reference Manual
MIA 90-02: BETA Compiler - Reference Manual
MIA 99-42: The Fragment System: Further Specification
BETA Terminology
BETA Quick Reference Card