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 .