🚀 go-pugleaf

C.A.R. Hoar was amazingly correct, and the shadow of the Emperor's Clothes
falls heavily on Modula-2.  But I thought you might be amused by a piece in
a lighter vein, written for the Tuebingen WG13 meeting over a year ago by
Modula-2's great friend Professor Terry.

Date: Wed, 26 Jun 91 22:47:53 PDT
From: cspt@giraffe.ru.ac.za (Pat Terry)
Subject: Nursery rhyme thyme


                    And then there were ....
                    ========================

We start our tale with some Poetry:

   "Ten little Modulans, keen to toe the line,
    One went to Nottingham, and then there were nine.

    Nine little Modulans thought casting sounded great,
    One pressed for cast, old style, and then there were eight.

    Eight little Modulans said "COMPLEX will be heaven".
    One stayed with FORTRAN code, and then there were seven.

    Seven little Modulans the FOR loop tried to fix,
    Sixteen pages VDM - and then there were six.

    Six little Modulans, exceptions felt should thrive.
    One weakly RAISED a "no", and then there were five.

    Five little Modulans, keen to add yet more,
    Built five I/O libraries and then there were four.

    Four little Modulans, on a formal spree,
    Couldn't freeze the VDM, and then there were three.

    Three little Modulans, Strings libraries did view,
    One cried "still not enough!" and then there were two.

    Two little Modulans said "Coroutines are fun"
    HALT wouldn't terminate, and then there was one.

    One little Modulan, dreadfully alone,
    Soon he discovered C, and then there were none."

    (Naughty Nineties Nursery Rhyme)

And follow with some Prose:

"We have erred and strayed from thy ways like lost sheep.  We have followed
too much the devices and desires of our own hearts ... we have left undone
those things which we ought to have done; and we have done those things
which we ought not to have done"  (Cranmer, 1662)


"Every one agrees that Modula-2 would be a great language if it had one
more feature.  Trouble is, everyone has a different idea about what that
one feature should be" (Attributed to Sue Eisenbach, 1985)


And round it off with some History:

Way back in about 1979 there was this great idea for a new computer
language.  It was called Modula-2.  Like all languages it grew, and
breathed, and excited poets and scientists alike, and never really settled
down.  By 1985 there was a little grey book describing what it had become.
The book used 33 pages to describe the language in a strange
incomprehensible language called English, and the language described had:

     40 reserved words
     29 pervasive identifiers
     1  system module with 2 types and 6 procedures
     A  small library with
          Terminal   with  6 procedures
          InOut      with 15 procedures and 2 variables
          RealInOut  with  3 procedures and 1 variable
          FileSystem with  5 types, and 18 procedures
          Storage    with  3 procedures
          MathLib0   with  8 procedures
          Processes  with  5 procedures and 1 type

Of course, vendors added a few more libraries.  Most had those mentioned plus

          Strings          with about 9 procedures
          NumberConversion with about 6 procedures
          RealConversions  with about 2 procedures

because by then there were ...

      Quite a number of implementations and compilers, and quite a number
      of lines of production code, and even quite a number of places where
      the language was used to teach students, and quite a few books that
      tried to help do this.  All seemed to predict a rosy future.

And Real Historians will recall that the Little Book had some funny
suggestions for other modules for a strange machine that they stopped
making, so nobody noticed them.



But, in spite of this, by then there were ....

      A whole lot of knotty points that language lawyers started to argue
      over.

They decided to try to untie the knots.  This was fun, and soon attracted
support from various organizations who thought it would be a Good Idea to
standardize the language at the same time.

And, mirabile dictu, then there were ....

      Other language lawyers who were invited to join in.

These language lawyers were real nice guys.  They travelled the world,
visited exciting places like Nottingham, Nice, Portland, Linz, Milton
Keynes and Tuebingen.  Everywhere they went they heard new languages, and
nearly every one soon thought of a New Idea.  And another New Idea.  And
another ...

But then, it must be remembered, there were ....

      No guidelines for Language Law, for those were thought to be a Bad
      Idea.

This wasn't really noticed, because there were so many Good Ideas that the
few bad ones went largely unnoticed.  Some of these Good Ideas arose from
suggestions for tidying up the Small Book.  The Small Book had, you see,
its own share of Bad Ideas.  Like, for example

      An idea that one could do type casting with syntax like Type(x)
      An idea that one could do CARDINAL arithmetic on ADDRESS types
      An idea that identifiers like LONGINT might be useful
      An idea that SIZE(P^) was useful
      A default BITSET type
      The possibility of using HIGH(OrdinaryArray)

It was time, it was argued, that all these Bad Ideas should be purged, and
in their place other Good Ideas should rise triumphant.  Of course, it was
hard to distinguish the Good from the Bad.  Some things were obviously Bad,
like

      A Really Simple way of defining IMPORT/EXPORT rules
      A Really Simple I/O Library
      A Really Useful STRING type
      A Really Useful BCD type
      A Really Useful way of introducing opaque types
      A Validation Suite
      Revision bars
      A NULPROC type
      Object oriented extensions
      Module constants
      Allowing inline assembly code
      Constant parameters
      Specifying a number of places for PI
      Trojan Horses
      Letting INTEGER and CARDINAL be compatible
      Read-only limitations on exported variables
      Specifying the order of evaluation
      Requiring portability of SYSTEM on a single platform
      Variable initialization
      Variable number of parameters
      Dereferencing or indexing the results of function calls
      Operator overloading
      Proper generics
      Letting WITH apply to modules
and
      Keeping It Simple

Most other ideas were obviously Good.  There were a few, however, that took
folk a long time to decide were actually Bad, like

      The first four I/O library proposals
      Listening to the views of implementors as well as academics
      Optional system modules

In fact, it all took a long time.  But in the stages near the end (or was
it near the beginning?) a big party was planned in Germany to celebrate.

And then there were ...

     A few who looked at this language that some still called Modula-2, and
     observed that the book that now described it had more than 570 pages,
     and used an exciting language for this purpose called VDM that
     everyone would understond very well because a new standard for VDM was 
     being produced Real Soon Now.  Some, who still had the energy, counted:

     42 reserved words (or maybe 45)
     43 pervasive identifiers (or maybe 46) or about 14-17 more than before
        (11 procedures, 4 types and 2 constants)
     A new possibility for Making_Pompous_Identifiers__Even____Longer
     A new way of specifying compiler directives
     A clever way of specifying initialization order
     A whole new era of programming with recursive procedure types
     A whole new coroutine model
     A nice way of (! bracketing !!!!) for squares
     A great new idea for string catenation
     A special pervasive for finding the LENGTH of a piece of string
     A valuable idea for value constructors
     A new way of protecting modules from interrupts
     A new and safer way of doing type casting
     A lot of much nicer ways of doing type conversions
     A long awaited method of handling multidimensional open arrays
     A new way of doing whole number division
     A new set of rules for FOR statements and their control variables
     A new way of handling declarations of mutually recursive procedures
     A new type for physicists and engineers who do COMPLEX things
     A new and never-before-implemented way of handling exceptions
     A highly intricate way of allowing programs to stop more than once
     1 SYSTEM      system module with 7 types, 9 procedures, 3 constants
     1 COROUTINES  system module with 1 type, 9 procedures
     1 EXCEPTIONS  system module with 3 types, 10 procedures
     1 Termination system module with 3 procedures
     A Really Useful Library with
          StdChans          with 10 procedures and 1 re-exported type
          ProgramArgs       with  3 procedures and 1 re-exported type
          TextIO            with  8 procedures and 1 re-exported type
          WholeIO           with  4 procedures and 1 re-exported type
          RealIO            with  5 procedures and 1 re-exported type
          LongIO            with  5 procedures and 1 re-exported type
          BinIO             with  2 procedures
          IOConsts          with  1 type
          IORes             with  1 procedure and 1 type
          STextIO           with  8 procedures
          SWholeIO          with  4 procedures
          SRealIO           with  5 procedures
          SLongIO           with  5 procedures
          SBinIO            with  2 procedures
          SIORes            with  1 procedure and 1 type
          DevConsts         with  3 types and 7 constants
          SeqStream         with  3 procedures, 3 types and 5 constants
          RewFile           with  7 procedures, 3 types and 5 constants
          RndFile           with 10 procedures, 5 types and 6 constants
          Terminal          with  3 procedures, 3 types and 5 constants
          IOChannel         with 17 procedures and 3 types
          IOLink            with  7 procedures and 17 types
          Storage           with  5 procedures, 1 type and 2 constants
          Processes         with 16 procedures and 5 types
          Semaphores        with  5 procedures and 1 type
          Strings           with 21 procedures and 3 types
          ConvTypes         with  2 types
          WholeConv         with  4 procedures and 2 types
          RealConv          with  5 procedures and 2 types
          SysClock          with  5 procedures and 8 types
          RealMath          with 12 procedures, 2 constants and 1 type
          LongMath          with 12 procedures, 2 constants and 1 type
          ComplexMath       with  7 (or maybe 15) procedures and 1 type
                                    (and maybe 3 constants)
          LongComplexMath   with  7 (or maybe 15) procedures and 1 type
                                    (and maybe 3 constants)
          LowReal           with  15 procedures and 15 constants
          LowLong           with  15 procedures and 15 constants
          CharClass         with  5 procedures

So, unhappily, then there were ...

     Those who thought that a some of this might have gone a little bit
     beyond the pale.  They probably shouldn't have done all that counting,
     because their opinions probably no longer counted.  Some even wondered
     what old Nick would have thought, but his opinion had never been worth
     much, had it?

-- 
randy@psg.com   ...!uunet!m2xenix!randy