From 1976 on I have - together with Bent Bruun Kristensen, Ole Lehrmann Madsen and Birger Møller-Pedersen - been working on a very modern object-oriented programming language that for strange reasons got the name BETA.
BETA has now for many years been available
on a number of platforms. The BETA systems
are implemented and maintained by the company
Mjølner Informatics, owned by the people who developed and/or
work on BETA. Addison Wesly has published a book (front page above)
on BETA, and much other material exists (see links and reference lists
on these pages, including my own).
What is BETA?
material in this and the next section is from "The
BETA Home Page" at Aarhus University in Denmark (http://www.daimi.aau.dk/~beta/)
. Most of it is quoted from the page FAQ:
BETA Programming Language (http://www.daimi.au.dk/~beta/doc/faq/beta-language-faq.html)
BETA is a modern object-oriented language with comprehensive facilities for procedural and functional programming. BETA has powerful abstraction mechanisms that 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. The abstraction mechanisms include class, procedure, function, coroutine, process, exception, and many more, all unified into the ultimate abstraction mechanism: the pattern.
In addition to the pattern, BETA has subpattern, virtual pattern, and pattern variable. 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.
Where did BETA come from?
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 language, 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 (email@example.com), Birger Møller-Pedersen (firstname.lastname@example.org), Ole Lehrmann Madsen (email@example.com ), and Kristen Nygaard. Kristen Nygaard was one of the two original designers of the Simula languages. (End of quote. from Jørgen.)
Strange Family Relationships in the OO World
Ole-Johan Dahl and I are said to be the "fathers" of SIMULA I and SIMULA 67 and thus of object-oriented programming. No "mother" has been identified. I definitely regard the SIMULA languages as my children and accept the way people talk. It is also commonly stated and accepted that all the object-oriented languages are descendants of SIMULA. Everyone seem to regard SIMULA as a "mother" and even "grandmother". I have never heard SIMULA referred to as the "Father" of C++. That distinction belongs to Bjarne Stroustrup alone.
A child with two fathers and no mother is of course something special, and it becomes rapidly even more odd. Smalltalk has obviously Alan Kay as the most important among its fathers (sic), but in this case the child at least also enjoyed the motherly care of Adele Goldberg. Now, since Smalltalk is the child of Simula, and I am a father of SIMULA, it follows that I am a grandfather of Smalltalk and the father-in-law of Alan Kay. However Bjarne Stroustrup and Bertrand Meyer are also closely related (whether they like it or not), since they both are members of the group of my son-in-laws, all having begotten a child with my daughter SIMULA (obviously, a "mother" is a woman)..
BETA's family relationship is more complex, since it is the child of SIMULA and at the same time has me as one of its four fathers. I hesitate to discuss this in further detail. And what about Java? Java is a descendant of SIMULA, and also from C++, and with some influences from BETA (Ole Lehrmann Madsen was in the neighbourhood at Sun when.Java was conceived.) I stop at this point.
However, I am very fond of all my promiscuous language children and grandchildren. So far, the family gatherings of the fathers and mothers at various levels have been very friendly. People speak highly about each other and are careful to give each other credit for achievements. (I am talking about the researchers and designers, not the marketing people and the magazine journalists.)
Ole Lehrmann Madsen writes:
Originally Beta was just one of a series of languages developed at Nordic universities. The first object-oriented language Simula I was originally designed as a simulation language but it was soon realised that the main ideas could be used for programming in general and this lead to Simula 67, which has class, subclass, virtual function coroutines, etc. It also supplied the first object-oriented framework (which we called "dialects"around 1970, KN) in the form of Class Simulation which is a set of classes to support the original goal of Simula to write simulation programs.
It turned out that many users of Simula seemed to get more understanding of their problem domain by having to develop a model using Simula than of the actual simulation results. Kristen Nygaard and others then decided to develop a successor for Simula, but with main focus of system description - not execution. This lead to a language called Delta In Delta you could express true concurrent objects and use predicates to express state changes. Delta could, however, not be executed. Delta means 'participate' in Norwegian'. [E. Holbaek-Hannsen, P Haandlykken, K. Nygaard: System Description and the Delta Language. Norwegian Computing Center, Publ. no 523, 1973]
When Kristen Nygaard was a visiting professor at Aarhus University in 1973-75, a project was started to develop a programming language based on the Delta ideas. This language should be a (programming language) successor to Simula and was called Gamma In the seventies, it was often assumed that a general programming language was not usable as a systems programming langauge. It was therefore decided to define a systems programming langauge which should also be used to implement Gamma. This language was called BETA Finally the machine level languages were referred to as Alpha Long story:-)
So what happened to Delta and Gamma? There is a (big) report describing Delta and there has later been some related work on Delta including using it in a few projects, but it is no longer being used or developed (see below. KN). The language Epsilon was a simplified version of Delta and the result of attempts to formalize Delta by means of Petri Nets. The Gamma language was never developed.
During the work on Beta it was soon realized that there was no need for Gamma. It turned out that by having powerful abstraction mechanisms in Beta, the Gamma-level could be handled by supplying class libraries and frameworks. You may thus think on the Gamma-level as the libraries and frameworks of the Mj¿lner System.
And this is where we are today. Some of the stuff in Delta could be handled by adding constraints to BETA and supporting invariants and pre/post conditions. (The idea of invariants and pre/post conditions for classes were originally suggested by Tony Hoare for Simula. [C.A.R. Hoare: Proof of correctness of data representation, Acta Informatics, 4, 271-281, 1972]
The Mjølner System has some libraries supporting initial versions of constraints and invariants. It has often been discussed changing the name BETA - to avoid the beta-testing jokes. The suggestion for a name change is Scala - Scandinavian Language and also Scala means 'going up'... But so far it has been decided to stick with Beta.
(Comment by KN: The DELTA language will in my opinion get much more interest in the years to come, since it will become necessary to give more concise descriptions (and prescriptions) of the actions spaces of human actors in information systems. In the GOODS project we have started this work.)
You can download the system from http://www.mjolner.com/download/ for
What is BETA? To an important extent a programming lanuage is the group of people implementing, maintaining and
developing the compilers and surrounding programming environments. Thus, on the picture are an indispensable part of BETA -
the staff of Mjølner Informatics: Standing - from left to right: Ole Lehrmann Madsen, Peter Andersen, Manmathan Muthukumarapillai, Bo Frederiksen, Lars Balker Rasmussen, Klaus Langgaard Jensen, Jacob Seligmann, S¿ren Pingel Dalsgaard, J¿rgen Lindskov Knudsen Sitting - from left to right: Flemming Gram Christensen, Elmer S¿rensen Sandvad, Henry Michael Lassen, Stephan Erbs Korsholm, Morten Grouleff