This article is from the FAQ, by with numerous contributions by others.
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
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
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 BETA