BETA is a modern object-oriented language with comprehensive facilities for procedural
and functional programming. BETA has powerful abstraction mechanisms than provide excellent
support for design and implementation, including data definition for persistent data. The
abstraction   mechanisms include support for identification of objects, classification, and composition.
BETA is a strongly typed language (like Simula, Eiffel, and C++), with most type checking being
carried out at compile-time.

    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 also be executed concurrently with supported
facilities for synchronization and communication, including monitors and rendezvous communication.
BETA originates from the Scandinavian school of object-orientation where the first
 object-oriented language Simula was developed. Object-oriented programming originated with the
 Simula languages developed at the Norwegian Computing Center, Oslo, in the 1960s. The first Simula lan guage, Simula I, was intended for writing simulation programs. Simula I was later used as a basis for defining, a general-purpose programming language, Simula 67 (later renamed to Simula). Simula has been used by a relatively small community for a number of years, although it has had a major impact on research in computer science.

    The BETA language development process started out in 1975 with the aim to develop concepts, constructs and tools for programming, partly based on the Simula languages. The BETA language team consists of Bent Bruun Kristensen, Birger Møller-Pedersen, Ole Lehrmann Madsen, and Kristen Nygaard. Kristen Nygaard was one of the two original designers of the Simula languages.

    The definition of the BETA language is in the public domain. This definition is controlled by the original designers of the BETA language: Bent Bruun Kristensen, Ole Lehrmann Madsen, Birger Møller-Pedersen, and Kristen Nygaard. This means that anyone or any company may create a compiler, interpreter, or whatever having to do with BETA.Currently, no language definition document exist. Work is in progress to write this language definition document. The definition will be given in strict natural language.
See section  HYPERLINK  \l "Q06" Q06  and  HYPERLINK  \l "L02" L02  for information on available language descriptions and latest changes to the language.

    BETA replaces classes, procedures, functions, and types by a single abstraction mechanism, called the pattern. It generalizes virtual procedures to virtual patterns, streamlines linguistic notions such as nesting and block structure, and provides a unified framework for sequential, coroutine, and concurrent execution. The resulting language is smaller than Simula in spite of being considerably more expressive.
The pattern concept is the basic construct. A pattern is a description from which objects may be created. Patterns describe all aspects of objects, such as attributes and operations, as seen in traditional object-oriented languages, but also aspects such as parameters and actions, as seen in procedures.
Objects are created from the patterns. Objects may be traditional objects as found in other languages, but they may also be objects which correspond to procedure or function activations, exception occurrences, or even coroutines or concurrent processes.Objects may be created statically or dynamically and the objects are automatically garbage collected by the runtime system when no references exist to them any longer.Patterns may be used as superpatterns to other patterns (the subpatterns). This corresponds to traditional class hierarchies, but since patterns may describe other types of objects, inheritance is a structuring means available also for procedures, functions, exceptions, coroutines, and processes.
Patterns may be virtual. This corresponds to traditional virtual procedures but again the generality of the pattern construct implies that also classes, exceptions, coroutines, and processes may be virtual.
Virtual patterns in the form of classes are similar to generic templates in other languages. The prime difference is that the generic parameters (that is, the virtual class patterns) may be further restricted without actually instantiating the generic template. The generality of the pattern also implies that genericity is available for classes, procedures, functions, exceptions, coroutines, and processes.
Patterns may be be handled as first-order values in BETA. This implies the possibility of defining pattern variables which can be assigned pattern references dynamically at runtime. This gives the possibilities for a very dynamic handling of patterns at runtime.

You can find more introductions to the BETA language by looking at the  HYPERLINK "http://www.mjolner.com/Manuals/r4.1/PDF/mia94-24.pdf" BETA Language Tutorial .