From: Michel Dagenais <dagenais@vlsi.polymtl.ca>
Newsgroups: comp.lang.modula3,news.answers,comp.answers
Subject: Modula-3 Frequently Asked Questions (FAQ)
Date: 16 Nov 1994 16:08:46 GMT
Organization: Ecole Polytechnique de Montreal
Message-ID: <m3_785002261@vlsi.polymtl.ca>

Archive-name: Modula-3-faq


   
   
                                 MODULA-3 FAQ
                                       
   
   
   Michel Dagenais, dagenais@vlsi.polymtl.ca
   
   
   
   v2.2, 30 August 1994
   
   
   
Contents

     * Contents
     * What is new?
     * The language
          + What is Modula-3?
          + Is Modula-3 a superset of Modula-2?
     * The documentation
          + Where can I get a description of Modula-3?
          + Where can I get other information on Modula-3?
     * The implementations
          + Where can I get an implementation?
          + What is SRC Modula-3?
          + What is m3pc?
     * Some specific questions
          + Why is "Hello World" so large?
          + Why objects and interfaces?
          + Comparisons between Modula-3 and other languages?
          + What is the story with Trestle and OpenWindows?
          + Linking with C++ code
          + Flushing writers to see the output immediately
          + Problems with threads and VTALARM
          + What is the purpose of BRANDED and REVEAL
          + Why uppercase keywords
          + M3build versus Make or why m3 does not work
          + Missing RTHooks or similar messages
          + The program receives a SEGV signal under the debugger
          + What is M3-lite, MS-Windows support
     * FTP
          + How To Obtain Pre-Compiled Binaries
          + What if I don't have ftp access?
     * Contributing
          + Can I contribute Modula-3 software?
          + ILU, an object-oriented multi-lingual RPC-capable module
            system
     * Modula-3 for teaching
     * Modula-3 In Industry
     * Work In Progress
          + The SRC Compiler
          + Modula-2 To Modula-3 Converter
          + Integrated Development Environment
          + Windowing And User Interfaces
               o Rotated Text
               o Postscript VBTs
          + Persistent Objects
          + Abstract Syntax Tree Tools (M3 Parser)
          + Computer Assisted Learning Tools (Algorithm Animation)
          + Presentations, Tutorials And Teaching Material
          + Reports And Books
          + Parallel Programming
     * Wish List
          + M3Build
          + Coverage And Performance Analysis
          + More VBTs
          + Distributed Computing (Network Objects)
          + Interfaces To Other Libraries And Programs (Tcl, Dps...)
     * Who's Who
       
  ABSTRACT:
  
   This document contains references to most of the material available
   on the Modula-3 language, compiler, tools and libraries. It should
   answer all the most frequently asked questions about Modula-3. The
   FAQ was originally written by Eric Muller. Send corrections,
   suggestions, additions to the current maintainer, Michel Dagenais
   dagenais@vlsi.polymtl.ca.
   
   The postscript version is available on
   ftp.vlsi.polymtl.ca:pub/m3/m3-faq.ps.
   
   An hypertext WWW version is found on
   http://froh.vlsi.polymtl.ca/m3/m3-faq.html.
   
   
   
   
   
                                 WHAT IS NEW?
                                       
   
   
   The FAQ answers several new questions, lists new binaries available
   and lists the ports under way.
   
                                 THE LANGUAGE
                                       
   
   
What is Modula-3?

   
   
   Modula-3 is a systems programming language that descends from Mesa,
   Modula-2, Cedar, and Modula-2+. It also resembles its cousins Object
   Pascal, Oberon, and Euclid.
   
   The goal of Modula-3 is to be as simple and safe as it can be while
   meeting the needs of modern systems programmers. Instead of exploring
   new features, they studied the features of the Modula family of
   languages that have proven themselves in practice and tried to
   simplify them into a harmonious language. They found that most of the
   successful features were aimed at one of two main goals: greater
   robustness, and a simpler, more systematic type system.
   
   Modula-3 retains one of Modula-2's most successful features, the
   provision for explicit interfaces between modules. It adds objects and
   classes, exception handling, garbage collection, lightweight processes
   (or threads), and the isolation of unsafe features.
   
Is Modula-3 a superset of Modula-2?

   
   
   No; valid Modula-2 programs are not valid Modula-3 programs. However,
   there is a tool to help convert Modula-2 programs to Modula-3.
   
                               THE DOCUMENTATION
                                       
   
   
Where can I get a description of Modula-3?

   
   
   The language definition and most electronically available Modula-3
   information can be accessed on:
   
   Modula-3 Home
   
   The definition of Modula-3 is contained in:
   
     * System Programming with Modula-3 Edited by Greg Nelson Prentice
       Hall Series in Innovative Technology ISBN 0-13-590464-1 L.C.
       QA76.66.S87 1991
       
   
   
   also known as SPwM3. Here is the table of contents:
   
    1. Introduction
    2. Language Definition
    3. Standard Interfaces
    4. An Introduction to Programming with Threads
    5. Thread Synchronization: A Formal Specification
    6. I/O Streams: Abstract Types, Real Programs
    7. Trestle Window System Tutorial
    8. How the Language Got its Spots
       
   
   
   Chapters 2 and 3 have been reprinted in Sigplan Notices, Volume 27,
   Number 8, August 1992, pp 15-42.
   
   Sam Harbison has written a more tutorial book about Modula3:
   
     * Modula-3 Samuel P. Harbison Prentice Hall, 1992 ISBN 0-13-596396-6
       
   
   
   The table of contents is as follows:
   
    1. Introduction
    2. Declarations
    3. Statements
    4. Basic Types
    5. Structured Types
    6. Procedures
    7. Exceptions
    8. Interfaces and Modules
    9. Generics
   10. Dynamic Programming
   11. Objects
   12. Threads
   13. Low-Level Programming
   14. Programming Conventions
   15. SRC Modula-3
   16. Modula-3 Syntax
   17. Answers to Selected Exercises
       
   
   
   The errata sheet is available via anonymous ftp from
   gatekeeper.dec.com in pub/DEC/Modula-3/errata.
   
   Errata
   
   If you cannot find these books at your favorite bookstore, here are
   bookstores connected to the net known to carry them:
   
   UCI carries both books:
   
   UCI Bookstore
   
   While Roswell is known to at least carry the language definition
   (SPwM3):
   
   Roswell Electronic Computer Bookstore (rjames@fox.nstn.ns.ca)
   
   Roswell Bookstore
   
Where can I get other information on Modula-3?

   
   
   There is a Usenet newsgroup, comp.lang.modula3. The archives of that
   group are available via anonymous ftp from gatekeeper.dec.com in
   pub/DEC/Modula-3/comp.lang.modula3. If you do not have access to
   Usenet, there is a relay mailing list; send a message to
   m3-request@src.dec.com to be added to it.
   
   Comp.lang.modula3 archive
   
   There are a couple high-level overview articles available:
   
     * ``Modula-3'', Sam Harbison, Byte, Vol. 15, No. 12, November 1990,
       pp 385+.
     * ``Safe Programming with Modula-3'', Sam Harbison, Dr. Dobb's
       Journal, Vol. 17, No. 10, October 1992, pp 88+.
       
   
   
   A description of the Modula-3 type system is in
   
     * ``The Modula-3 Type System'', Luca Cardelli, Jim Donahue, Mick
       Jordan, Bill Kalsow, Greg Nelson, Conference Record of the
       Sixteenth Annual ACM Symposium on Principles of Programming
       Languages (POPL), Austin Texas, January 11-13 1989, pp 202-212.
       
   
   
   The Modula-3 treatment of floating-point values is described in
   
     * ``The Design of Floating-Point Data Types'', David Goldberg, ACM
       Letters on Programming Languages and Systems (LOPLAS), June 1992,
       Vol 1, no.2, pp 138-151
       
   
   
   The core library interfaces are described and indexed in
   
     * ``Some Useful Modula-3 Interfaces'', Jim Horning, Bill Kalsow,
       Paul McJones, Greg Nelson, SRC Research Report 113. Available via
       anonymous FTP from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-113.ps.Z
       
       Libm3
       
     * ``Pickles: a system for automatic serialization of typed values'',
       Andrew Birrell, Greg Nelson, Susan Owicki, Edward Wobber, Systems
       Research Center, Digital Equipment Corp., in preparation.
       
   
   
   The Trestle window system toolkit, higher-level FormsVBT toolkit, and
   Zeus animation system available with Modula-3, are documented in the
   following reports:
   
     * ``Trestle Reference Manual'', Mark S. Manasse and Greg Nelson, SRC
       Research Report 68, December 1991.
     * ``Trestle Tutorial'', Mark S. Manasse and Greg Nelson, SRC
       Research Report 69, May 1, 1992.
     * ``VBTkit Reference Manual: A toolkit for Trestle'', edited by Marc
       H. Brown and James R. Meehan. (to be a SRC Research Report) A
       draft version is available via anonymous FTP from
       gatekeeper.dec.com in
       pub/DEC/Modula-3/contrib/vbtkit.25Mar93.ps.Z.
       
       VBTKit
       
     * ``The FormsVBT Reference Manual'', Marc H. Brown and James R.
       Meehan, (to be a SRC Research Report). A draft version is
       available via anonymous FTP from gatekeeper.dec.com in
       pub/DEC/Modula-3/contrib/formsvbt.25Mar93.ps.Z and
       pub/DEC/Modula-3/contrib/formsvbt.AppC.26Mar93.ps.Z.
       
       VBTKit library
       
       VBTKit applications
       
     * ``Zeus: A System for Algorithm Animation and Multi-View Editing'',
       Marc H. Brown, SRC Research Report 75, February 28, 1992.
       Available via anonymous FTP from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-075*.ps.Z.
       
       Zeus
       
     * ``Color and Sound in Algorithm Animation'', Marc H. Brown and John
       Hershberger, SRC Research Report 76a, August 30, 1991. Available
       via anonymous FTP from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-076a*.ps.Z.
       
       Color and Sound
       
     * ``The 1992 SRC Algorithm Animation Festival'', Marc H. Brown, SRC
       Research Report 98, March 27, 1993. Available via anonymous ftp
       from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-098*.ps.Z.
       
       Animation Festival
       
   
   
   Network objects are described in the following reports:
   
     * ``Network Objects'', Andrew Birrell, Greg Nelson, Susan Owicki,
       and Edward Wobber, SRC Research Report 115, February 28, 1994.
       Available via anonymous FTP from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-115*.ps.Z.
       
       Network Objects
       
     * ``Distributed garbage collection for Network Objects'', Andrew
       Birrell, David Evers, Greg Nelson, Susan Owicki, and Edward
       Wobber, SRC Research Report 116, December 1993. Available via
       anonymous FTP from gatekeeper.dec.com in
       pub/DEC/SRC/research-reports/SRC-116*.ps.Z.
       
       Distributed GC
       
   
   
   While the Obliq embeddable interpreter is documented in:
   
     * ``Obliq: A lightweight language for network objects'', Luca
       Cardelli, User's Manual, Systems Research Center, Digital
       Equipment Corp., 1994. Available via anonymous FTP from
       gatekeeper.dec.com in pub/DEC/Modula-3/contrib/Obliq.ps.
       
       Obliq
       
   
   
   Hardcopy versions of these reports can be ordered by e-mail; send your
   request including a postal mail address to src-reports@src.dec.com.
   
   SRC research reports
   
   Sedgewick's classic text on computer algorithms is presented in
   Modula-3 in:
   
     * Algorithms in Modula-3 Robert Sedgewick Addison-Wesley, 1993 ISBN
       0-201-53351-0
       
   
   
                              THE IMPLEMENTATIONS
                                       
   
   
Where can I get an implementation?

   
   
   Two implementations are available, SRC Modula-3 and a PC version of it
   (m3pc).
   
   As far as we know, implementations are not available for VMS,
   Macintosh.
   
What is SRC Modula-3?

   
   
   SRC Modula-3 was built by the DEC Systems Research Center and is
   available via anonymous ftp from gatekeeper.dec.com in
   pub/DEC/Modula-3. The most recent version is release 3.3. The previous
   release, 3.1, was a major new release intended mostly for porting to
   architectures other than DEC. A list of known problems and patches is
   available in:
   
   patches
   
   This release is known to work on at least on the DS3100
   (m3-request@src.dec.com), HPPA (laverman@cs.rug.nl), LINUX
   (dagenais@vlsi.polymtl.ca), NeXT 68000 (tom@smart.ruhr.de),
   (nayeri@gte.com) SPARC architectures. Work is under way to port to the
   Macintosh (George Andre dat94gan@ludat.lth.se), OS/2 (Hendrik Boom
   hendrick@CAM.ORG), AIX 3.2.5 for RISC/6000 (Bob Barton
   barton@chopin.eche.ualberta.ca), FreeBSD (Olaf Wagner
   olaf@logware.de). The SPARC release notes may be found on
   ftp.gte.com:pub/m3 while the LINUX ones are available on
   ftp.vlsi.polymtl.ca:pub/m3/linux/README and the HPPA notes are in
   ftp.vlsi.polymtl.ca:pub/m3/hppa/README.
   
   SRC-Modula-3
   
   SPARC release notes
   
   LINUX release notes
   
   HPPA release notes
   
   The compiler implements the language defined in SPwM3. There are
   versions for the architectures listed below. While SRC can test on
   DS3100, ALPHA/OSF and LINUX, it can only rely on what users on other
   platforms tell them to integrate all the platform specific code.
   
   Because of the improved portability of the 3.* release, ports to non
   Unix platforms are easier. A port to Windows NT and/or Windows 3.1 may
   be available in the future. The Windows NT port, in progress, uses
   native threads. This should be a good model for other implementations
   of Thread using native threads.
   
     * AIX386 IBM PC running AIX/PS2,
     * AOSF DEC Alpha AXP running OSF/1
     * AP3000 Apollo DN4500 running Domain/OS
     * ARM Acorn R260 running RISC iX 1.21
     * DS3100 DECstation 3100 and 5000 running Ultrix 4.0 and 4.2
     * HP300 HP 9000/300 running HP-UX 8.0
     * HPPA HP 9000/700, 9000/800 running HP-UX 8.0
     * IBMR2 IBM R6000 running AIX 3.1,
     * IBMRT IBM RT running IBM/4.3,
     * LINUX Intel 386 running LINUX
     * NEXT NeXT running ??
     * NT386 Intel 386 running Windows NT
     * OKI Okidata 7300 (i860) running UNIX SVR4.0
     * SEQUENT Sequent computers running ??
     * SOL2 Sparc running Solaris 2.x
     * SPARC SPARCstation running SunOS 4.1.x
     * SUN3 SUN3 running SunOS
     * SUN386 Sun 386i running SunOS 4.0.1
     * UMAX Encore Multimax running UMAX 4.3 (R4.1.1)
     * VAX VAX running Ultrix 3.1
       
   
   
   The new native compiler is based on GCC and should be fairly easy to
   port. Except for the very lowest levels of the thread implementation,
   the entire system is written in Modula-3.
   
   The DEC SRC Modula-3 release 3.3 contains the following:
   
     * A native code compiler: uses the GCC backend; on
       machines/operating systems that have self-describing stacks, an
       optimized exception handling mechanism is provided, on other
       architectures, setjmp/longjmp is used.
       
       The compilation system provides for minimal recompilation. Only
       those units that depend on the modified interface item will be
       recompiled.
     * m3utils/m3build: tool that performs dependency analysis and builds
       the Modula-3 programs and libraries.
     * A large standard library (libm3) providing
       
          + A multithread, incremental, generational, conservative
            garbage collector
          + Text manipulation.
          + Generic Containers: Lists, Sequences, Tables, SortedLists,
            SortedTables
          + Atoms and Symbolic expressions (Lisp like lists)
          + An extensible stream IO system
          + Typesafe binary object transcription (persistent objects)
          + Operating system interfaces
          + Portable interfaces to the language runtime
   
       
       All standard libraries are thread-friendly. Modula-3 can readily
       link with existing C libraries; many libraries including X11R4 and
       various UNIX libraries are available as part of libm3.
     * m3gdb: a Modula-3 aware version of GDB.
     * trestle: a multi-threaded window system interface that sits on top
       of X windows. It is not unlike InterViews and comes with several
       sample programs.
     * trestle/tcp: a library for simplified access to TCP/IP.
     * vbtkit: a higher level toolkit on top of Trestle. It offers
       buttons, menus, editors, file choosers... and has a Motif-like
       look and feel.
     * formsvbt: an interactive user interface builder. A symbolic
       expression representing the user interface is edited and the
       graphical view is immediately produced.
     * tools/coverage: tool to determine the number of times each
       statement is executed.
     * tools/pp: pretty printer for Modula-3 programs.
     * tools/gnuemacs: emacs lisp files to help editing and debugging
       Modula-3 programs in emacs.
     * tools/m3bundle: tool to bundle data files into an executable to
       produce standalone programs.
     * tools/m3totex: extract TeX documentation from Modula-3 programs
       for a form of literate programming.
     * tools/showheap: tool to graphically see the behavior of the
       garbage collector.
     * tools/shownew: tool to graphically see the allocation behavior of
       a running program.
     * tools/showthread: tool to see the activation of threads in a
       running program.
     * zeus: framework to develop graphical animations of algorithms
       (heapsort, quicksort, LRU cache replacement, network protocols...)
       for visualization and teaching purposes.
     * mentor: a dozen of animations developed using Zeus.
     * netobj: network objects that allow the transparent execution of
       methods across process and machine boundaries. A simple yet very
       effective way to build distributed applications.
     * obliq: simple, interpreted, lexically scoped, object oriented,
       distributed programming language that can be embedded in Modula-3
       programs and call/be-called by Modula-3 procedures. The Obliq
       object model is based on prototypes and delegation.
     * A framework for parsing and analyzing Modula-3 programs. This is a
       complete AST toolkit for Modula-3. This can parse arbitrary
       Modula-3 sources (input isn't required to be a complete unit) and
       produce detailed ASTs representing the input. The ASTs can be used
       to do a variety of semantic analysis tasks, or program generation
       tasks similar to Lisp environments. (m3tk).
     * pkgtools/smalldb: library to store objects on disk with logging
       and recovery capabilities.
     * pkgtools: distribution tool that insures that several copies of a
       package (software, document...) are updated simultaneously.
     * postcard: mail and news reading environment.
     * visualobliq: a graphical user interface builder coupled with a
       simple yet powerful interpreted language, Obliq, for rapid
       development of interactive distributed applications.
     * This is a rather new component and is undergoing a fair amount of
       evolution; however, it is still very useful and exciting. Visual
       Obliq provides an application builder similiar in nature to Visual
       Basic. However, it uses Obliq as its scripting language. This
       makes it easy to build and prototype interesting distributed and
       groupware applications. It can be used for building
       non-distributed applications as well.
     * misc/tcl: interface to access the Tcl language from Modula-3.
     * misc/dps: interface to access Display Postscript from Modula-3.
     * games: more sample Trestle applications.
       
   
   
What is m3pc?

   
   
   A newer version of m3pc, code named EX32 in the README file, is
   available via anonymous ftp from gatekeeper.dec.com in
   pub/DEC/Modula-3/contrib/M3forDOS.
   
   PC Modula-3
   
   From the README, written by Klaus Preschern:
   
   EX32 ("A 32-bit Extension of DOS") is a environment for the
   developement and execution of 32-bit applications with DOS.
   
   EX32 is a collection of DOS programs (drivers + kernel). It provides
   services for applications executed in protected mode. It does process
   management, virtual memory management, interprocess communication via
   pipes and it offers a file system with 32 character filenames.
   
   EX32 runs on MS-DOS 5.00, 6.00 and 6.02. You need a i386/i387
   (coprocessor required) or upward (i486, Pentium). EX32 supports DOS
   XMS memory (but not EMS, VCPI or DPMI). No support for the i286. You
   should have at least 4 MB memory (8 MB or more recommended). The whole
   package occupies unzipped and untared approximately 44 MB of disk
   space.
   
   EX32 comes with GNU C++ (version 2.4.5), SRC Modula-3 (version 3.1,
   including threads), two C libraries, a graphics library for VGA and a
   number of commands (i.e. ls, cp, rm, mkdir, make, ...).
   
   Note: This is a system for experienced programmers! They should be
   familiar with Unix and DOS.
   
                            SOME SPECIFIC QUESTIONS
                                       
   
   
Why is "Hello World" so large?

   
   
   Modula-3 programs are larger than C programs for the following
   reasons:
   
    1. The fixed runtime is substantially larger. It contains a garbage
       collector, a thread runtime, and exception support. Note that
       "Hello World" is virtually all runtime. For larger programs the
       runtime is not an issue.
    2. The generated code includes runtime checks for out-of-bound array
       references and NIL pointer. Many of these checks could be removed
       by a more sophisticated compiler.
       
   
   
Why objects and interfaces?

   
   
   Allan Heydon on comp.lang.modula3, May 4th 1993:
   
   Modula-3 provides two separate mechanisms for data-hiding: one for
   hiding details about how interfaces are implemented, and the other for
   hiding details about how objects are implemented.
   
   The first data-hiding mechanism is realized by the distinction between
   interfaces and modules. Clients can only import interfaces, so the
   names declared in the modules implementing those interfaces are hidden
   from clients. Note that this mechanism has only two levels; a name is
   either declared in an interface, or it isn't. If a name is only
   declared in a module, it can't be used by a client.
   
   The second data-hiding mechanism is realized by opaque types and
   revelations. A Modula-3 interface may declare an object type to be
   opaque, in which case only a subset of the fields and methods of that
   object are revealed to clients importing the interface. Furthermore,
   the Modula-3 revelation mechanism allows a designer to reveal
   successively more fields and methods of an object in a series of
   interfaces. The fields and methods visible to a client then depends on
   which interfaces the client imports.
   
   The latter mechanism is quite flexible. As opposed to the
   interface/module data-hiding mechanism, opaque types allow you to
   define an arbitrary number of levels at which more and more
   information about the implementation of your object is revealed.
   
   See Sections 2.2.10, 2.4.6, and 2.4.7 of ``Systems Programming with
   Modula-3" for more information about opaque types and about partial
   and complete revelations.
   
Comparisons between Modula-3 and other languages?

   
   
   From: laszlo@post.ifi.uni-klu.ac.at (Laszlo BOESZOERMENYI)
   
   "A Comparison of Modula-3 and Oberon-2" by myself in "Structured
   Programming" 1993, 14:15-22
   
   From: nayeri@gte.com
   
   Robert Henderson, Benjamin Zorn, A Comparison of Object-Oriented
   Programming in Four Modern Languages, Department of Computer Science,
   University of Colorado, Boulder, Colorado, Technical Report
   CU-CS-641-93. Available by anonymous FTP and e-mail from
   ftp.cs.colorado.edu in the file
   pub/cs/techreports/zorn/CU-CS-641-93.ps.Z
   
   The paper evaluates Oberon, Modula-3, Sather, and Self in the context
   of object-oriented programming. While each of these programming
   languages provide support for classes with inheritance, dynamic
   dispatch, code reuse, and information hiding, they do so in very
   different ways and with varying levels of efficiency and simplicity. A
   single application was coded in each language and the experience
   gained forms the foundation on which the subjective critique is based.
   
   
What is the story with Trestle and OpenWindows?

   
   
   Mark Manasse says:
   
   I think that the OpenWindows release should be enough (no need to get
   the MIT X release), although there are a few things in Trestle that
   trigger devastating bugs in OpenWindows. But the only library we
   depend on is Xlib, R4 or later.
   
   The main thing I know that crashes OW 2.0 is the code where we call
   GrabKey specifying AnyKey. You can either loop over all of the keys,
   or you can just comment out the call; programs won't run exactly the
   same, but you probably won't notice the difference.
   
Linking with C++ code

   
   
   Apparently there is no problem to call C++ functions declared as
   extern "C".
   
   From: gwyant@cloyd.East.Sun.COM (Geoffrey Wyant - Sun Microsystems
   Labs BOS)
   
   You must use your C++ compiler as the linker, rather than /bin/cc or
   /bin/ld.
   
   You need to call the function '_main'. The easiest way to do this is
   to have the following set of interfaces and implementations:
   

        INTERFACE CXXMain;
          <*EXTERN "_main"*> CxxMain;
        END CXXMain;

        MODULE CXXMain;
        BEGIN
          CxxMain();
        END;

   
   
   and then import CXXMain into your M3 main module. This will ensure
   that the C++ function "_main" gets called.
   
Flushing writers to see the output immediately

   
   
   Modula-3 Writers are buffered. Thus, you need to issue a Wr.Flush when
   the output should appear immediately, for instance to prompt the user
   for some input. Since this can become annoying, libraries in other
   languages sometimes offer the option of unbuffered writes. In
   Modula-3, an equivalent behavior is obtained with AutoFlushWr which
   gets a background thread to flush a writer at a specified interval.
   
Problems with threads and VTALARM

   
   
   The threads are implemented using the virtual timer interrupt.
   Normally, the run time environment will catch the interrupt and
   determine if thread switching is appropriate. However, if a new
   process is created with fork, it will have the virtual timer activated
   and no interrupt handler to receive it, resulting in a core dump. If
   you use the standard procedure Process.Create to fork new processes,
   this will be handled automatically for you. If you insist on using
   fork, you need to disable the timer, fork and then reenable the timer.
   
   
What is the purpose of BRANDED and REVEAL

   
   
   Allan Heydon writes:
   
   These two keywords are necessary because of two quite different
   features of the language. REVEAL is necessary because Modula-3 has
   opaque types and partial revelations. BRANDED is necessary because the
   Modula-3 type system uses structural equivalence instead of name
   equivalence.
   
   In Modula-3, the concrete structure of a type can be hidden from
   clients in an interface. A common idiom is:
   

  INTERFACE I;

  TYPE
    T <: TPublic;
    TPublic = OBJECT
      (* fields *)
    METHODS
      (* methods *)
    END;

  END I.

   
   
   The line "T <: TPublic" introduces the type "I.T" as an opaque subtype
   of the type "I.TPublic". It does not reveal any of the other details
   of the concrete structure of "I.T" to clients. Hence, "I.T" is said to
   be an opaque type. Put another way, the structure of "I.T" is only
   partially revealed to clients.
   
   In addition, it is possible to reveal more of "I.T"'s structure in
   other interfaces, like this:
   

  INTERFACE IRep;

  IMPORT I;

  TYPE
    TPrivate = I.TPublic OBJECT
      (* more fields *)
    METHODS
      (* more methods *)
    END;

  REVEAL
    I.T <: TPrivate;

  END IRep.

   
   
   This interface declares a type "IRep.TPrivate" that is a subtype of
   "I.TPublic". It also asserts that "I.T" is also a subtype of
   "IRep.TPrivate". A client that imports only the interface "I" has
   access only to the fields and methods in "I.TPublic" when accessing an
   object of type "I.T", but a client that imports both "I" and "IRep"
   also has access to the fields and methods in "IRep.TPrivate" when
   accessing an object of type "I.T".
   
   The "REVEAL" statement in this module simply asserts a subtype
   relation. Unlike type declarations, revelations introduce no new
   names. Hence, we could not have used the "TYPE" keyword in this case
   because the type "I.T" has already been declared once (albeit
   opaquely) in interface "I".
   
   Every opaque type must have a complete revelation. A complete
   revelation has the form:
   

  REVEAL
    T = TConcrete;

   
   
   The revelation specifies that "TConcrete" is the concrete type for the
   opaque type "T".
   
   The Modula-3 type system uses structural equivalence instead of name
   equivalence. This means that two types are equal iff they have the
   same structure. One consequence of this rule is that two types you
   might intend to be distinct may actually be equal. This can have
   unintended effects on the run-time behavior of your program. For
   example, if both types that you expect to be distinct are actually
   structurally equivalent and the two types guard two arms of a TYPECASE
   statement, the arm for the second type will never be taken.
   
   If you want to avoid accidental equalities between two types, you can
   brand one (or both) of them with the BRANDED keyword. A branded type
   is equivalent to no other type, even if it is structurally equivalent
   to some other type. In essence, the BRANDED keyword adds a bit of
   virtual structure to the type that guarantees it will be distinct from
   every other type.
   
   The Modula-3 syntax allows you to supply a text constant as a name for
   the brand. If you don't supply an explicit brand, the compiler will
   make one up; however, the implicit brand invented by the compiler is
   not guaranteed to be chosen deterministically. Hence, explicit brands
   are useful if you are communicating types from one process to another
   and if you want to be sure that the branded type written by one
   process matches the branded type read in by the other.
   
   Any two opaque types in a program must be distinct. Otherwise, it
   would be too easy for clients to accidentally trip over type
   collisions like the TYPECASE example mentioned above. To enforce the
   restriction that all opaque types are distinct, the language requires
   that the type "TConcrete" in the complete revelation above must be a
   branded type.
   
Why uppercase keywords

   
   
   Some people prefer uppercase keywords others hate them. Another
   possibility is to accept both forms for keywords. This topic has been
   discussed at length and there is no solution that will completely
   satisfy everyone's tastes. Fortunately this is a very minor issue and
   you can easily have lowercase keywords automatically converted for you
   using a macro package like m3su (pion.lcs.mit.edu:/pub/m3su) for
   emacs.
   
   lowercase keywords macro
   
M3build versus Make or why m3 does not work

   
   
   The Modula-3 compiler m3 does a much finer grained dependency analysis
   than possible with make. For this reason, a very flexible front end,
   m3build, reads the program description files, m3makefile, and
   generates the commands required to compile and link Modula-3 programs
   and libraries. The m3makefile content is documented in the m3build
   documentation. Calling the m3 compiler directly is difficult and thus
   not recommended.
   
Missing RTHooks or similar messages

   
   
   The standard library, libm3, is not included by default. You need in
   your m3makefiles to import(``libm3'') or to import a library which
   imports libm3. Otherwise, messages about run time procedures such as
   RTHooks not being available are produced.
   
   m3build
   
The program receives a SEGV signal under the debugger

   
   
   The garbage collector on some platforms uses the SEGV (segmentation
   violation) signal to detect modified portions of the dynamically
   allocated space. It is possible to disable this feature or to inform
   the debugger to let these signals propagate. See the tips on how to
   use the debugger.
   
   debugging
   
What is M3-lite, MS-Windows support

   
   
   M3-lite is a research project at DEC SRC to see how fast Modula-3
   programs could be compiled and linked. It uses an integrated m3build,
   m3 compiler and code generator (based on Burs) and is targeted at
   Win32 (Windows NT or Windows Chicago). Research projects, by
   definition, do not have release dates. Part of this work, when ready,
   may also serve on other platforms, especially LINUX and FreeBSD since
   they are intel based.
   
                                      FTP
                                       
   
   
How To Obtain Pre-Compiled Binaries

   
   
   The following binaries are available for FTP. If you are willing to
   provide binaries for other architectures, please contact
   dagenais@vlsi.polymtl.ca; they may be put on his FTP server or links
   to your server can be included in the FAQ. The full exploded source
   code tree is available along with the SPARC binaries.
   
     * Release 3.3 SPARC binaries. Contains most of the 3.3 release and
       comes with static and shared libraries. If you have problems
       building the 3.3 release for SPARC, you may want to look at the
       lude/modula3-3.3/src/poly directory as it contains all the locally
       modified files. The original source code is available in
       lude/modula3-3.3/src/orig and may be browsed to see examples of
       m3makefiles amd Modula-3 code. Requesting a directory with .tar.Z
       added to its name will automatically generate the corresponding
       compressed tar file.
       
       It can be retrieved from
       ftp.vlsi.polymtl.ca:lude/modula3-3.3/run/poly.tar.Z and should be
       placed in /usr/local/soft/modula3-3.3/run/poly... Then,
       /usr/local/soft/modula3-3.3/run/poly/sun4.1_sparc/bin must be
       added to your path. Compiled by Michel Dagenais.
       
       SPARC Modula3-3.1
       
     * Release 3.3 LINUX binaries. It can be retrieved from
       ftp.vlsi.polymtl.ca:pub/m3/linux/src-m3-3.3l0.tar.gz and should be
       placed in /usr/local/soft/modula3-3.3... Then,
       /usr/local/soft/modula3-3.3/run/bin must be added to your path.
       Compiled by Michel Dagenais.
       
       LINUX Modula3-3.3
       
     * Release 3.3 HPPA binaries. It can be retrieved from
       ftp.vlsi.polymtl.ca:pub/m3/hppa. Compiled by Bert Laverman.
       
       HPPA Modula3-3.3
       
     * Release 3.3 68000 NeXT binaries. It can be retrieved from
       ftp.vlsi.polymtl.ca:pub/m3/next. Compiled by Thomas Neumann.
       
       NeXT Modula3-3.3
       
   
   
What if I don't have ftp access?

   
   
   Unfortunately, DEC SRC cannot deliver Modula-3 other than by anonymous
   ftp.
   
   Fortunately, Prime Time Freeware (PTF) includes Modula-3. PTF is a set
   of two ISO-9660 CDroms filled with 3GB of freeware, issued
   semi-annually. The latest issue, Volume 1, Number 2, July 1992,
   contains SRC Modula-3 2.07. PTF is distributed via bookstores and
   mail. You can reach PTF using:
   

        Email:  ptf@cfcl.com
        Fax:    [1] (408) 738 2050
        Voice:  [1] (408) 738 4832
        Mail:   Prime Time Freeware
                415-112 N. Mary Ave., Suite 50
                Sunnyvale, CA 94086
                USA

   
   
                                 CONTRIBUTING
                                       
   
   
Can I contribute Modula-3 software?

   
   
   Certainly. Send to m3-request@src.dec.com what you are willing to
   share, be it programs, libraries or other things. They will be put in
   the distribution.
   
   Right now, the pub/DEC/Modula-3/contrib directory contains:
   
   Contrib
   
     * m3rpc a Sun RPC system from Xerox Parc
     * M2toM3 a translator from Modula-2 to Modula-3
     * m3pc an implementation of Modula-3 for PCs.
       
   
   
   You will also find on ftp.vlsi.polymtl.ca in pub/m3:
   
   Modula-3 contributions
   
     * present-src-m3 slides for presenting the Modula-3 tools and
       libraries.
     * cache-anim a zeus graphical animation of the computer memory
       hierarchy.
     * realgeometry a floating point geometry package.
     * sequences sequences allowing insertions in the middle.
       
   
   
ILU, an object-oriented multi-lingual RPC-capable module system

   
   
   The following was recently announced by Xerox PARC:
   
   Version 1.6.4 of the Xerox PARC Inter-Language Unification (ILU)
   system is now available for general use.
   
   WHAT'S ILU?
   
   ILU (pronounced eye'-loo) is a system that promotes software
   interoperability via interfaces. Interfaces between what? Whatever
   units of program structure are desired; we call them by the generic
   term "modules". They could be parts of one process, all written in the
   same language; they could be parts written in different languages,
   sharing runtime support in one memory image; they could be parts
   running in different memory images on different machines (on different
   sides of the planet). A module could even be a distributed system
   implemented by many programs on many machines. Calls across ILU
   interfaces involve only as much mechanism as necessary for the calling
   and called modules to interact. In particular, when the two modules
   are in the same memory image and use the same data representations,
   the calls are direct local procedure calls - no stubs or other RPC
   mechanisms are involved.
   
   ILU modules are known by their interfaces. A module interface is
   specified once in ILU's object-oriented Interface Specification
   Language (called, simply, ISL). For each of the particular programming
   languages supported by ILU (currently Common Lisp, ANSI C, C++, and
   Modula-3; Python, Tcl, and GNU Emacs-Lisp are in the works), a version
   of the interface in that particular programming language can be
   generated. The ILU kernel library provides services which may be used
   by the language-specific interface to overcome intermodule language or
   address space differences.
   
   GETTING THE RELEASE
   
   The release is only available via FTP from the PARC ftp server.
   Perhaps the simplest way is to go through our World Wide Web home
   page,
   
   ILU
   
   CONTRIBUTORS
   
   Antony Courtney, Doug Cutting, Bill Janssen, Denis Severson, Mike
   Spreitzer, Mark Stefik, Farrell Wymore
   
                             MODULA-3 FOR TEACHING
                                       
   
   
   Modula-3 is very well suited for teaching: simple yet powerful, and
   safe. It avoids the complexity of legacy languages. It can be used to
   demonstrate modules and interfaces, object oriented programming,
   multi-threading (concurrency issues), graphical user interfaces
   (Trestle, VBTKit, FormsVBT) and even distributed programming (Network
   Objects, Obliq). Since less time is spent by students and teaching
   assistants chasing dangling pointers and corrupted data, more time is
   available for learning the important concepts.
   
   It is used for teaching in a number of universities. This list is far
   from complete, send corrections and additions to
   dagenais@vlsi.polymtl.ca.
   
   From: Carsten Whimster (bcrwhims@undergrad.math.uwaterloo.ca)
   
   University of Waterloo:
   
   CS246 - Third introductory course in computer science. Software
   engineering and software systems. Medium size projects. Uses Modula-3
   to demonstrate proper OO programming, as well as general programming
   practices.
   
   CS241 - Fourth and final intro course to CS. Focuses mainly on
   compilers and languages. Various assignments has students create most
   of the different parts of a compiler. Also introduces Scheme (lisp).
   
   From: Peter.Robinson@cl.cam.ac.uk
   
   University of Cambridge, England.
   
   The Computer Science course at the University of Cambridge teaches ML
   as an introductory language at the beginning of the freshman year, and
   then uses Modula-3 to develop imperative programming at the end of
   that year. Further lectures on advanced features of the language are
   given early in the second year, together with separate lectures on
   other, specialised languages.
   
   The course has been given to about 70 students each year since 1990,
   and has developed with the language. It ties in with other lectures on
   data structures and algorithms, software engineering and concurrency.
   Modula-3 is used for student group projects in the second year and for
   about a quarter of individual projects in the final year (where,
   interestingly, students using Modula-3 tend to earn higher grades than
   those using C/C++).
   
   Modula-3 is also used in the Computer Laboratory at Cambridge for a
   number of research projects on distributed computing, human-computer
   interaction and electronic CAD.
   
   From: Matthew.Huntbach@dcs.qmw.ac.uk
   
   We have used it for three years here at Queen Mary and Westfield
   College, London. The main problem I find with the language is the slow
   compilation speed on our teaching machines (Macs running A/UX),
   otherwise it's a nice language to teach with.
   
   From: laszlo@ifi.uni-klu.ac.at (Laszlo BOESZOERMENYI)
   
   University Klagenfurt
   
   Modula-3 is used at the following courses: Undergraduate:
   Softwaretechnology-1 (actually an introduction into programming) (on
   PCs) Softwaretechnology-2 (data structures and algorithms) (on PCs)
   Graduate: Computer Networks (on a network of DECs and SUNs) Parallel
   Programming (on an DEC-Alpha Farm)
   
   Modula-3 has been in use since ca. one year, with very good
   experiences.
   
   From: pk@i3.informatik.rwth-aachen.de (Peter Klein)
   
   Lehrstuhl fuer Informatik III, RWTH Aachen, Germany: Software
   Development Projects, now held for the second time using Modula-3. Aim
   of these projects is to introduce different aspects of software
   development to graduate students. This includes project planning,
   supervision, design, and cooperative implementation of small but
   usable software systems. Central ideas of software design and
   object-oriented implementation are presented and discussed with the
   concepts of Modula-3, which is also the implementation language.
   
   Future plans: Maybe Modula-3 will replace Modula-2 in some
   undergraduate programming lectures in the future.
   
   From: rro@cs.colostate.edu (Rod Oldehoeft)
   
   In the Computer Science Department at Colorado State University, M3 is
   envisioned as a vehicle for several courses.
   
   M3 is introduced in the second course (data structures) to implement
   the ADT concept, including generics. In the sophomore languages
   course, it is an example of an O-O language. In the junior software
   engineering course, additional relevant features are brought in, and
   threads are added in the junior operating systems course.
   
   From: viggo@nada.kth.se
   
   Royal Institute of Technology. Several courses at the computer science
   department use Modula-3. The courses contain programming projects, and
   many students choose to use Trestle. (Dr. Viggo Kann,
   viggo@nada.kth.se)
   
   From: "Dave Snelling" (snelling@cs.man.ac.uk)
   
   Department of Computer Science, University of Manchester, Manchester
   U.K. We have a small, interdisciplinary collection of people using
   Modula-3 for a variety of activities. Our major production code is a
   hardware architecture simulator (about 120 modules). Smaller projects
   include a Lattice Gass model and a Shallow Water model.
   
   At: University of Massachusetts at Amherst
   
   Modula-3 is used as an input language for the Computer Science course
   on Compilation techniques. The professor is Eliot Moss.
   
   From: Michel Dagenais (dagenais@vlsi.polymtl.ca)
   
   Modula-3 is used as the main example in a graduate course on
   ``Algorithmic Aspects of CAD'', which includes a large portion on OO
   programming and databases.
   
   From: pbh@cs.sunysb.edu (Peter Henderson)
   
   Modula-3 is currently used for teaching Computer Science I and
   Computer Science II at SUNY at Stony Brook. We are currently
   developing a sequence of laboratory assignments and case studies
   introducing OO techniques and software reuse in these two courses.
   
   The first course for computer science majors at Stony Brook is
   "Foundations of Computer Science" which emphasizes general problem
   solving, mathematics and the relationships between mathematics and
   computer science. There is an extensive laboratory component using
   theorem provers, Prolog and Standard ML.
   
                             MODULA-3 IN INDUSTRY
                                       
   
   
   A number of programming teams in industry selected Modula-3 for their
   project. It encourages good programming practices and comes with
   excellent libraries for distributed programming and graphical user
   interfaces.
   
   From: gwyant@cloyd.East.Sun.COM (Geoffrey Wyant - Sun Microsystems
   Labs BOS)
   
   Sun Microsystems Laboratories, Inc. (East) is using Modula-3 (Network
   Objects, FormsVBT) as the basis for its research in large scale
   distributed object systems.
   
   From: Farshad Nayeri (nayeri@gte.com)
   
   Distributed Object Computing, GTE Labs, Waltham, Massachusetts USA
   Modula-3 (FormsVBT, Sx, Netobj libraries) is used to prototype
   distributed object management. (Farshad Nayeri nayeri@gte.com).
   
   Report
   
                               WORK IN PROGRESS
                                       
   
   
   The purpose of this section is to let everyone know what is being
   worked on. This is not a commitment to a quick release or even to
   completion. However it may enable parties interested in the same
   topics to pool their efforts, avoid duplication or better integrate
   their packages.
   
   To find more information about the names mentioned, see the Who's Who
   section.
   
The SRC Compiler

   
   
   The compiler already implements the full language and runs on several
   platforms. Speed enhancements and support for some popular non-Unix
   platforms may be expected.
   
Modula-2 To Modula-3 Converter

   
   
   A better Modula-2 to Modula-3 converter (99%conversion...) is in the
   works under the supervision of Peter Klein.
   
Integrated Development Environment

   
   
   A number of groups have made experiments in this area. Tools such as
   VBTkit for the user interface, m3tk for syntax and dependency
   analysis, dynamic linking... could be used to produce such an
   environment. It is worth noting that precompiled interfaces are much
   easier to achieve in M3 than in several other popular languages.
   
   Peter Klein is working on a Modula-3 development environment and
   associated user interface. See the paper entitled ``Designing Software
   with Modula-3'', it describes a software architecture description
   language based on Modula-3.
   
   Report
   
   Klaus Preschern, Carsten Weich, Laszlo Boszormenyi have made the port
   of Modula-3 to the PC. The M3-PC environment will be enhanced,
   especially with threads and graphics, including a student-friendly
   environment.
   
   David N. Gray of Lucid Inc. has been experimenting with connecting the
   Modula-3 compiler with the Lucid Energize Programming System
   (currently sold as a development environment for C and C++ on Sun
   SPARCstations). The modified compiler is available as an unsupported
   as-is hack, to accompany the new Energize release that it works with.
   
   Energize Modula-3
   
   Geoff Wyant is experimenting with FormsVBT/VBTKit to build a simple
   friendly development environment.
   
Windowing And User Interfaces

   
   
  ROTATED TEXT
  
   
   
   Currently, there is no VBT to show non horizontal text, because of X
   windows limitations. This would be desirable and can be implemented in
   one of the following ways: a) open a pipe to the ghostscript
   Postscript interpreter and use it as a font renderer, cache and
   display the character bitmaps produced; b) have Bezier curves for the
   most popular Postscript fonts, Trestle handles Bezier curves; c) use
   the new text facilities in X11R6 that remove previous limitations. A
   prototype implementation of a) has been implemented by Alain Dube
   (contact Michel Dagenais); the performance with the cache is good but
   this remains a relatively complex solution. The b) solution would be
   relatively easy to implement but the resulting quality may not be as
   good as a real font renderer. The c) solution may not be available for
   some time since many workstation vendors take a long time before
   integrating the new X windows facilities.
   
  POSTSCRIPT VBTS
  
   
   
   It is often useful to display Postscript files in a VBT, for example
   for an included diagram in a document editor.
   
   This can be achieved by using the ghostscript Postscript interpreter
   as a rasterizer. A prototype has been programmed by Alain Dube
   (contact Michel Dagenais) but the performance is not too good when
   large color bitmaps are handled. An alternative implementation is to
   convert Postscript files into display lists (Bezier curves and text)
   as a preprocessing step. Further displaying and even editing becomes
   very simple. A prototype implementation of this has been done by
   Benoit Poirier (contact Michel Dagenais).
   
Persistent Objects

   
   
   With Pickles to store objects in files, the implementation of
   persistent objects is simplified. Furthermore, with the m3tk library
   it is not too difficult to read a type description and to write the
   needed methods to handle that type. Combined with FormsVBT, network
   objects and Obliq, all the ingredients are there to have a nice
   environment for developing graphical distributed applications with
   persistent state and querying facilities.
   
   Peter Klein has a specialized database for annotated graphs, GRAS,
   that is being re-implemented in Modula-3.
   
   Eliot Moss is working on persistent Modula-3 objects. The main
   features are persistence through reachability, load on demand and a
   very low overhead for using persistent objects. The high performance
   is obtained by modifying the compiler and run-time. Initially a
   modified version of GCC, GNU M3, was being worked on. However, with
   the release of the SRC native compiler, the modifications are being
   moved to the SRC compiler instead.
   
   Persistency
   
Abstract Syntax Tree Tools (M3 Parser)

   
   
   The m3tk library can be used to analyze Modula-3 source code in order
   to find specific constructions (use of OBSOLETE facilities, un-handled
   exceptions), build source code browser and analysis tools, stubs
   generators for network or persistent objects... Mick Jordan is
   preparing the 3.2 release of m3tk and finishing the documentation, in
   his spare time.
   
   From: hudson@yough.ucs.umass.edu (Rick Hudson)
   
   If anyone is interested we have developed a Bison grammar that parses
   the Modula-3 language input. If interested please feel free to contact
   me hudson@cs.umass.edu.
   
Computer Assisted Learning Tools (Algorithm Animation)

   
   
   The Zeus Algorithm Animation package may be used to quickly develop
   graphical and animated teaching aids. Most of the algorithms described
   in Robert Sedgewick's Algorithms book have been animated at DEC SRC
   through the work of Marc H. Brown.
   
   Animation of compilation techniques have been produced by students at
   University of Illinois with the help of Marc Najork.
   
   From: "Arnulf Mester" (mester@ls4.informatik.uni-dortmund.de)
   
   As part of a studental project advised by a college of mine and me a
   Mentor-like collection of Zeus-based animations of typical distributed
   algorithms and communication protocols (termed ZADA) has been
   compiled. Hopefully I'll get to include more information and access
   during the next weeks into our ZADA WWW home page
   
   ZADA
   
Presentations, Tutorials And Teaching Material

   
   
   Modula 3 is used for teaching in a number of Universities. Some
   Modula-3 related teaching material may be shared between interested
   parties.
   
   Michel Dagenais has a French presentation about the Modula 3 language
   that could be distributed.
   
   Geoff Wyant is preparing a tutorial on Modula-3 for the upcoming
   OOPSLA conference.
   
Reports And Books

   
   
   Sam Harbison is preparing a revised version of his existing book on
   Modula-3. He may include more material on the new libraries.
   
   Laszlo Boszormenyi, Roland Mittermeir and Carsten Weich are working on
   a book (it will be published in German and in English) with the
   work-title:
   
   "Programming in Style - An Introduction into Programming with
   Modula-3"
   
   The book will be published at Springer (in German in October 1994, in
   English maybe or December, or January 1995). For the book, the M3-PC
   environment will be enhanced, especially with threads and graphics,
   including a student-friendly environment.
   
   A book about writing distributed object oriented applications, using
   Modula-3, m3build, m3gdb, analyze_coverage, FormsVBT, Obliq and
   Network Objects is being planned by Geoff Wyant, Farshad Nayeri and
   Michel Dagenais.
   
   From: BERGINF@PACEVM.DAC.PACE.EDU (Joseph Bergin)
   
   I am also at work on a Modula-3 college level textbook. It will cover
   the data structures course and will stress data abstraction. It will
   be similar to my current book: Data Abstraction: The Object-Oriented
   Approach using C++, published by McGraw Hill. Status: The software has
   been built and I am currently writing the text itself. Joe Bergin,
   berginf@pacevm.dac.pace.edu, Pace University
   
Parallel Programming

   
   
   From: Ernst A. Heinz, University of Karlsruhe, F.R. Germany (email:
   heinze@ira.uka.de)
   
   I would like to inform you about our ongoing Modula-3* project here at
   the University of Karlsruhe. At the moment, we are actively involved
   in adding sophisticated dependence and data flow analysis to DEC's
   Modula-3 compiler (release 3.x!). The Modula-3* compiler will be able
   to generate code for real parallel machines, for networks of
   workstations, and for standard sequential execution. (Our new IPD
   Modula-2* system available by anonymous ftp from ftp.ira.uka.de in
   "pub/programming/modula2star" may give you an initial feeling about
   it!)
   
   For all interested folks I have made my JSPP'93 paper publicly
   available by anonymous ftp. The title of the paper reads as follows:
   
   "Modula-3*: An Efficiently Compilable Extension of Modula-3 for
   Problem-Oriented Explicitly Parallel Programming".
   
   Paper
   
   More recent work includes
   
   E.A. Heinz. Sequential and parallel exception handling in Modula-3*: A
   unifying semantics specification. In P. Schulthess (editor). Advances
   in Modular Languages: Proceedings of the Joint Modular Languages
   Conference, pages 31-49, Ulm, Germany, September 28-30, 1994.
   
   Paper
   
                                   WISH LIST
                                       
   
   
   The Modula-3 development environment now contains a large number of
   very good tools and libraries that work nicely together. The purpose
   of this section is to help contributors determine what additions would
   be helpful to others. It may get you in contact with people that would
   like to use your contribution or with people that may provide some
   items on your wanted list or team with you for their development.
   
M3Build

   
   
   The descriptions of programs and libraries stored in m3makefiles are
   simple and efficient. It would be interesting to be able to specify
   different m3-options for some files (debugging, performance
   analysis...), and to have the dependency analysis take into account
   previously used options when determining modules to recompile (Michel
   Dagenais).
   
   Although makefiles cannot perform the same consistency checks as
   m3build and are more cumbersome to use, it may be useful to be able to
   drive the compiler through makefiles for training purposes (i.e. learn
   Modula-3 and Makefiles at the same time)
   (bwbecker@watdragon.uwaterloo.ca).
   
Coverage And Performance Analysis

   
   
   Tools already exist for coverage analysis, pretty printing,
   performance analysis, viewing the threads and the garbage collected
   heap. It would be nice to have these easily accessible through an
   integrated development environment (Michel Dagenais).
   
More VBTs

   
   
   An editor widget with multiple fonts (fixed and proportional character
   spacing) perhaps even with direct support for HTML (item lists,
   centered headings...) (Geoff Wyant, Farshad Nayeri).
   
   A diagram editor widget (Farshad Nayeri).
   
   A split VBT that positions NxM childs in aligned rows and columns
   (Geoff Wyant).
   
   A Graph VBT that displays arbitrary graphs (such as call trees, cross
   references...). This could be implemented adding a placement module
   (to determine the vertex positions) to work on the existing GraphVBT
   module (Geoff Wyant).
   
   Some of the VBTs implemented in miscellaneous libraries (such as
   GraphVBT in Mentor/Zeus) could be placed in a more visible location
   such as VBTKit (Michel Dagenais).
   
   MIME extensions to Postcard (Farshad Nayeri).
   
   Submit Trestle to a graphical designer (Farshad Nayeri).
   
Distributed Computing (Network Objects)

   
   
   Network objects are an exciting recent addition. The underlying model
   is very simple and effective. Authentication and access control will
   be required in many applications.
   
   A network object daemon that starts specific programs upon need, like
   inetd does using inetd.conf for most network services, would be very
   useful (Michel Dagenais).
   
Interfaces To Other Libraries And Programs (Tcl, Dps...)

   
   
   C functions are easily called from Modula 3. Thus, stubs have been
   produced to access John Ousterhout's Tcl and also Display Postscript
   from Modula 3.
   
   An automatic tool to produce such stubs from .h C files would be very
   useful (Geoff Wyant).
   
   Stubs to access the Motif X Windows library would be useful (Geoff
   Wyant).
   
   Similar stubs would be desirable to access databases such as Postgres
   or Exodus and access/provide World Wide Web information using the
   hypertext transfer protocol libraries (HTTP) (Geoff Wyant).
   
                                   WHO'S WHO
                                       
   
   
   Modula-3 enthusiasts, users or contributors. Please notify me for
   additions, corrections or removals.
   
     * Robert Ayers, Adobe, (ayers@Mv.Us.Adobe.Com), the Display
       Postscript to Modula-3 interface
     * Andrew Birrell, DEC SRC, (birrell@src.dec.com), Network objects.
     * Laszlo Boeszoermenyi, Universitaet Klagenfurt, Austria,
       (laszlo@ifi.uni-klu.ac.at), PC port (m3pc), Programming in style
       book.
     * Marc H. Brown, DEC SRC, (mhb@src.dec.com), VBTKit, FormsVBT, Zeus.
     * Luca Cardelli, DEC SRC, (luca@src.dec.com), Modula-3 definition,
       Obliq.
     * Michel Dagenais, Ecole Polytechnique de Montreal,
       (dagenais@vlsi.polymtl.ca), LINUX and SPARC M3 binaries, M3 FAQ.
     * John D. DeTreville, DEC SRC, (jdd@src.dec.com), Incremental
       garbage collector.
     * David N. Gray, Lucid Inc., Menlo Park, (gray@Lucid.Com), interface
       between the Lucid environment and the M3 compiler.
     * Sam Harbison, Tartan, harbison@tartan.com, Modula-3 book.
     * Ernst A. Heinz, University of Karlsruhe, F.R. Germany
       (heinze@ira.uka.de)
     * Allan Heydon, DEC SRC, (heydon@src.dec.com), IP, Lex, Fmt, PQueue,
       DblBufferVBT modules.
     * Jim Horning, DEC SRC, (horning@src.dec.com), Useful Modula-3
       interfaces.
     * Rick Hudson, University of Massachusetts at Amherst,
       (hudson@cs.umass.edu), GNU Modula-3.
     * Mick Jordan, Sunlabs near Palo Alto, mick.jordan@eng.sun.com,
       Modula-3 definition, M3TK and related tools.
     * Bill Kalsow, DEC SRC, (kalsow@src.dec.com), Modula-3 definition,
       M3 compiler and run-time.
     * Peter Klein, Lehrstuhl fuer Informatik III,
       (pk@i3.informatik.rwth-aachen.de). Modula-2 to Modula-3 converter.
     * Bert Laverman, Groningen University, (laverman@cs.rug.nl), HPPA
       support.
     * Mark S. Manasse, DEC SRC, (msm@src.dec.com), Trestle.
     * Paul McJones, DEC SRC, (mcjones@src.dec.com), Useful Modula-3
       interfaces.
     * James R. Meehan, Adobe (jmeehan@mv.us.adobe.com), VBTKit,
       FormsVBT.
     * Roland Mittermeir, Universitaet Klagenfurt, Austria,
       (mittermeir@ifi.uni-klu.ac.at), Programming in style book.
     * Eliot Moss, University Of Massachusetts At Amherst,
       (moss@Cs.Umass.Edu), GNU Modula-3.
     * Eric Muller, DEC SRC (moved?), (muller@src.dec.com), M3 compiler
       and run-time.
     * Marc Najork, DEC SRC, (najork@src.dec.com), 3D animation.
     * Greg Nelson, DEC SRC, (gnelson@src.dec.com), Modula-3 definition,
       Systems Programming with Modula-3 book editor, Trestle, Network
       objects.
     * Farshad Nayeri, GTE Labs Near Boston, (nayeri@Gte.Com), m3-sparc
       mailing list.
     * Frode Odegard, (frode@Odegard.Com), commercial Modula-3 support.
     * Susan Owicki, Stanford University, (owicki@mojave.stanford.edu),
       Network objects.
     * Klaus Preschern, Universitaet Klagenfurt, Austria,
       (preschern@ifi.uni-klu.ac.at), PC port (m3pc).
     * Robert Sedgewick, Princeton University, Algorithms in Modula-3
       book.
     * Jorge Stolfi, University of Campinas, Brazil,
       (stolfi@dcc.unicamp.br), Computational geometry procedures.
     * Carsten Weich, Universitaet Klagenfurt, Austria,
       (weich@ifi.uni-klu.ac.at), PC port (m3pc), Programming in style
       book.
     * Edward Wobber, DEC SRC, (wobber@src.dec.com), Network objects.
     * Geoff Wyant, Sunlabs Near Boston, (gwyant@East.Sun.COM), SPARC
       port.
       
   
   
   
     _________________________________________________________________
   
   
   
    Michel Dagenais, dagenais@vlsi.polymtl.ca, Mon Nov 14 11:38:58 GMT
    1994
--

Prof. Michel Dagenais			    dagenais@vlsi.polymtl.ca
Dept of Electrical and Computer Eng.
Ecole Polytechnique de Montreal		    tel: (514) 340-4029


