Path: news.daimi.aau.dk!pingel From: pingel@daimi.aau.dk (S|ren Pingel Dalsgaard) Newsgroups: comp.lang.beta Subject: Final alpha test of BETA for WintNT/Win95 Date: 9 May 1995 14:35:36 GMT Organization: DAIMI, Computer Science Dept. at Aarhus University Lines: 236 Message-ID: <3onujo$cj1@belfort.daimi.aau.dk> NNTP-Posting-Host: daimi.daimi.aau.dk Summary: Final alpha test of BETA for WintNT/Win95 Keywords: Final alpha test of BETA for WintNT/Win95 Dear Windows NT/Windows 95 users! We are proud to annouce the third and final alpha test version of The Mjolner BETA System for Windows NT and Windows 95. BETA is an object oriented programming language developed at Aarhus University. If you would like to participate in the testing of the BETA compiler please send a letter to alphatest.nt@mjolner.dk with the subject "MBS alpha 3". We will then send you a license agreement for you to fill out and return. You will then receive instructions on how to get your copy of the BETA compiler via ftp. After the test period has ended you will receive a copy of the final product -- Personal Edition without Valhalla (debugger) but with Lidskjalv (GUIEnv). Requirements for using BETA version 5.0 on Windows NT (Intel CPU) or Windows 95: * CPU: 386/486/Pentium. * Memory: At least 16Mb RAM. * Free disk space: Approximately 25Mb * Borland assembler v4.0 (including TASM32, MAKE and TLINK) or Microsoft WIN32SDK (including MASM386, EDITBIN, NMAKE and LINK). * Windows NT or Windows 95. In case you're unfamiliar with BETA or the Mjolner BETA System, here's a short description of the language and some of the associated tools. Please contact info@mjolner.dk if you would like more information, or check out the BETA homepage: http://daimi.aau.dk/~beta/info. 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 known 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. The Implementation of BETA The Mjolner BETA System includes an implementation of the BETA programming language. The implementation has the following characteristics: - Native code generation The compiler generates assembly code. - Garbage collection Automatic storage management and garbage collection is used. The techniques used for garbage collection are generation-based scavenging and mark-sweep. - Separate compilation Programs may be divided into smaller fragments (modules) for separate compilation. The compiler makes an automatic dependency analysis on the fragments structure. When a fragments has been changed, the system keeps track of the dependent fragments that must be recompiled. - Interface to C and assembly language There is a general interface to C and assembly language. This includes call of C procedures, call-back and parameter transfer of simple types, text and C structures. For Macintosh, there is also a Pascal interface. - Source-level debugger A source-level debugger for the BETA language is available on the Unix platform. Contains facilities for specifying break- points, single stepping, inspection of object states, inspecting the run-time organization, etc. The debugger uses a graphical interface running under the X Window System. - Persistent objects Support for saving any kind of object generated by a BETA program execution on secondary storage and restoring them in another BETA program execution. The persistent store is fully typesafe. An object-oriented database for BETA objects is currently under development. - Distributed objects Support for distribution of objects to support a client-server model is being developed. - Platforms * Sun SPARC, SunOs 4.0 and 4.1 and Solaris 2.2 and 2.3 * HP 9000 series 300,400,700, HP/UX 8 and 9 * Macintosh (at least 68020 and 5 Mbytes) with MPW * Intel 386/486/Pentium based PCs running Linux (a UNIX variant) We are currently porting the Mjolner BETA Systems to the following platforms: * Intel 386/486/Pentium based PCs running Windows NT * Intel 386/486/Pentium based PCs running Windows95 * PowerPC based Macintosh Mjolner Informatics ApS offers to port the MBS to other platforms. Ask for more information. - Implementation Language The entire Mjolner BETA System is written in BETA, except for a few run-time routines. []