by [Note that this is a commercial product, and alpha testers will receive a
free license of the final product. --mdw]
Mjolner Informatics is currently porting the Mjolner BETA System to the PC:
* 386/486/Pentium based PCs running Linux
* 386/486/Pentium based PCs running Windows NT
* 386/486/Pentium based PCs running Windows 4.0
In this process we have finished the Linux version and are looking for alpha
testers.
Yes, we know that "alpha testers for BETA" sounds funny,
but BETA is a language _not_ a version! :-)
If you are accepted as an alpha tester, you will receive a free
license of the final release.
If you are interested please send an email to supp...@mjolner.dk.
--
The Mjolner BETA System
A software development environment supporting
object-oriented programming
in the BETA programming language
BETA is a modern object-oriented language from the Scandinavian
School of object-orientation with powerful abstraction mechanisms
for identification of objects, classification and composition. It
has strong typing, whole/part objects, reference attributes,
general block structure, coroutines and concurrency.
The BETA implementation has native code generation, garbage
collection, separate compilation, configuration control, interface
to C and assembly, source-level debugger, and persistent objects.
There is a large library of class patterns and application
frameworks.
- Class patterns for text, file, set, multiset, set with subsets,
hashtable, list, stack, queue, priority queue, deque, etc.
- Powerful and easy to use application frameworks on top of the X
Window System, Athena Widgets, and Motif.
- Powerful and easy to use application frameworks on top of the
Macintosh Toolbox.
- Powerful metaprogramming system for manipulating programs as
data.
- Interface to operating system and external languages.
- Powerful graphical system based on the Stencil & Paint imaging
model.
A pre-release is available of the Hyper Structure Editor for
programs and text documents supporting integrated syntax directed
and textual editing, incremental parsing, abstract presentation
and browsing, integration of documentation and comments, hypertext
facilities, and adaptive pretty printing.
A demo version is available of the Mjolner BETA CASE Tool, with
support for design diagrams and simultaneous editing of design
diagrams and program text. Eliminates CASE gap by using one single
abstract language-BETA for design as well as for implementation.
The system has taken its name from the Nordic mythology where
Mjolner is the name of the hammer of the god Thor. According to
the mythology, this hammer is the perfect tool that cannot fail,
grows with the task, and always comes back in the hand of Thor.
The 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 know 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 proce- func- co- process excep-
dure tion routine tion
pattern + + + + + +
subpattern + + + + + +
virtual pat. + + + + + +
pattern var. + + + + + +
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++.
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 behaviour 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.
Support for subfunctions of abstraction
BETA supports the three main subfunctions of abstraction:
It is possible to describe objects that are not
Identification generated as instances of a class pattern, so-
of Objects 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 is supported by patterns,
Classification 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.).
Objects and patterns may be defined as a
Composition composition of other objects and patterns. The
(Aggregation) support for composition includes:
An attribute of an object may be a part object.
Whole/part This makes it possible to describe objects in
composition terms of their physical parts.
An attribute of an object may be a reference to
Reference another object. Reference composition forms the
composition basis for modeling arbitrary relations between
objects.
In the form of block-structure: An attribute of an
Localization 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.
--
Mail supp...@mjolner.dk for more information.
--
Mail submissions for comp.os.linux.announce to: linux-annou...@tc.cornell.edu
Be sure to include Keywords: and a short description of your software.