Subject: Alpha testers for BETA on Linux
From: [email-masked] (Elmer Sandvad)
Date: Tue, 24 May 1994 15:14:31 GMT
Newsgroups: comp.os.linux.announce

[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 [email-masked].

--
                                                         
                      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 [email-masked] for more information.
--
Mail submissions for comp.os.linux.announce to: [email-masked]
Be sure to include Keywords: and a short description of your software.