From zio@netcom.com Mon Oct  4 02:06:10 1993
Newsgroups: alt.best.of.internet
From: zio@netcom.com (James Elkinton)
Subject: [from zer.z-netz.magazine.allgemein] Babbage
Summary: Babbage Programming Language
Keywords: babbage programming language humor technology
Organization: Netcom - Online Communication Services (408 241-9760 guest)
Date: Fri, 1 Oct 1993 09:51:19 GMT

What next?!?

- Newsgroups: zer.z-netz.magazine.allgemein
- Message-ID: <59bAhJl01k@TRAVELER.zer.sub.org>
- From: tom@traveler.zer.sub.org
- Organization: Z-NETZ BBS NetWork, FRG
- Subject: Babbage



         -----  Babbage:  The Language of the Future   -----

        by Tim McDonough, Rensselear Polytechnic Institute
        (reproduced without permission, but thanks anyway)

      The are a few things in this business that  are  more  fun  than
 designing a new computer language, and  the  very  latest  is  Ada  -
 the Department of Defense's new  supertoy.  Ada,  as  you  know,  has
 been designed to replace outmoded  and  obsolete  languages  such  as
 COBOL and FORTRAN.

      The problem is  that  this  cycle  takes  20  to  30  years  and
 won't start until we're really  convinced  present  languages  aren't
 any good. we can short-circuit this  process  by  starting  on  Ada's
 replacement  right  now.    Then,  by  the  time  we  decide  Ada  is
 obsolete, its replacement will be ready.

      The new generation of language designers  has  taken  on  naming
 its brain children after real people rather  than  resorting  to  the
 usual acronyms. Pascal is named  after  the  first  person  to  build
 a calculating machine and Ada  is  named  after  the  first  computer
 programmer.  As our namesake, we  chose  Charles  Babbage,  who  died
 in poverty while  trying  to  finish  building  the  first  computer.
 The new language is thus  named  after  the  first  systems  designer
 to go over budget and behind schedule.

      Babbage is based  on  language  elements  that  were  discovered
 after  the  design  of  Ada  was  completed.  For  instance,   C.A.R.
 Hoare, in his 1980 ACM Turing Award lecture,  told  of  two  ways  of
 constructing a software design:

      "One way is  to  make  it  so  simple  that  there  are
      obviously  no deficiencies and the other way is to make
      it  so  complicated  that  there    are   no    obvious
      deficiencies."

      The designers of Babbage have chosen a third  alternative  -  a
 language  that  has  only  obvious  deficiencies.  Babbage   programs
 are  so  unreliable  that   maintenance   can  begin  before  systems
 integration is  completed.  This  guarantees  a  steady  increase  in
 the debug job marketplace.

      Like Pascal, Ada uses 'strong typing,  to  avoid  errors  caused
 by mixing data  types.  The  designers  of  Babbage  advocated  "good
 typing" to avoid errors caused  by  misspelling  the  words  in  your
 program.   Later  versions  of  Babbage  will   also   allow   "touch
 typing", which will fill a long-felt need.

      A  hotly  contested  issue  among  language  designers  is   the
 method  for  passing  parameters  to  subfunctions.   Some   advocate
 "call by name", other prefer "call by  value".  Babbage  uses  a  new
 method  "call by  telephone".     This is  especially  effective  for
 long-distance parameter passing.

      Ada stresses the concept of software  portability.       Babbage
 encourages  hardware  portability.    After  all,  what  good  is   a
 computer if you can't take it with you?

      It's  a  good  sign  if  your  language  is  sponsored   by   the
 government.   COBOL  had  government  backing,  and   Ada   is   being
 funded by the department  of  defense.  After  much  negotiation,  the
 Department of Sanitation has agreed to sponsor Babbage.

      No  subsets of  Ada  are  allowed.      Babbage   is   just   the
 opposite.   None of Babbage is  defined  except  its  extensibility  -
 each user must define his own version.     To  end   the   debate   of
 large languages  versus  small,  Babbage  allows  each  user  to  make
 the language  any  size  he  wants.  Babbage  is  the  ideal  language
 for the "ME" generation.  The examples  that  follow  will  give  some
 idea of what Babbage looks like.

      Structured  languages  banned     GOTOs   and    the     multiway
 conditional   branches    by   replacing   them   with   the   simpler
 If-Then-Else structure.  Babbage  has  a  number  of  new  conditional
 statements  that  act  like  termites  in  the  structures   of   your
 program:

 What if

      Used in simulation languages.     Branches   before    evaluation
      test conditions.

 Or Else  -

      Conditional Threat, as in "Add these two numbers or else!"

 Why Not?

      Executes the code that follows in a devil-may-care fashion.

 Who else?

      Used for polling during I/O operations.

 Elsewhere

      This is  where  your  program  really  is  when  you  think  it's
      here.

 Going Going Gone

      For writing unstructured  programs.  Takes  a  random  branch  to
      another part of your program.  Does the work of 10 GOTOS.

 For years, programming languages have used  "FOR",  "DO  UNTIL",  "DO
 WHILE",  etc.   to  mean  "LOOP".  Continuing  this  trend,   Babbage
 offers the following loop constructs:

 Don't Do While Not

      This loop is not executed if the test  condition  is  not  false
      (or if it's Friday afternoon).

 Didn't Do

      The loop executes once and hides its traces.

 Can't Do

      The loop is pooped.

 Won't Do

      The CPU halts because  it  doesn't  like  the  code  inside  the
      loop.   Execution can be resumed  by  typing  "MAY  I?"  at  the
      console.

 Might Do

      Depends on how the CPU  is  feeling.  Executed  if  the  CPU  is
      "UP",  not executed if the CPU is  "DOWN"  or  if  its  feelings
      have been hurt.

 Do Unto Others

      Used to write the main loop  for  timesharing  systems  so  that
      they will antagonize the users in a uniform manner.

 Do-Wah

      Used to write timing  loop  for  computer-generated  music  (rag
      timing).


 Every self-respecting structured language has  a  CASE  statement  to
 implement multiway  branching.     ALGOL  offers  an   indexed   CASE
 statement and Pascal has a labeled CASE  statement.  Not  much  of  a
 choice.  Babbage offers a variety of statements:

 The Just-in-Case Statement

      For handling afterthoughts and  fudge  factors.  Allows  you  to
      multiply  by  zero  to  correct  for  accidentally  dividing  by
      z e r o .

 The Brief Case Statement

      To encourage portable software.

 The Open-and-Shut-Case Statement

      No proof of correctness is necessary with this one.

 The In-Any-Case Statement

      This one always works.

 The Hopeless-Case Statement

      This one never works.

 The Basket-Case Statement

      A really hopeless CASE.

      The Babbage language Design  Group  is  continuously  evaluating
 new features that will keep its users  from  reaching  any  level  of
 effectiveness.   For  instance,  Babbage's  designers      are    now
 considering  the  'Almost  Equals'  sign,  used  for  comparing   two
 floating point numbers. This new feature  "Takes  the  worry  out  of
 being close".

      No language, no matter how bad, can stand on  its  own.       We
 need  a  really  state-of-the-art   operating   system   to   support
 Babbage. After trying  several  commercial  systems,  we  decided  to
 write  a  "virtual"  operating  system.     Everybody has  a  virtual
 memory operating  system, so  we decided to try  something  a  little
 different.    Our  new  operating  system   is  called  virtual  Time
 Operating System (VTOS).   While  virtual  memory  systems  make  the
 computer's memory the virtual resource,  VTOS  does  the  same  thing
 with CPU processing time.

      The result is that the computer can  run  an  unlimited  number
 of jobs at the same time.  Like  the  virtual  memory  system,  which
 actually keeps  part  of  the  memory  on  disk,  VTOS  has  to  play
 tricks to achieve its goals.  Although  all  of  your  jobs  seem  to
 be running  right  now,  some  of  them  are  actually  running  next
 week.

      As you can see,  Babbage  is  still  in  its  infancy.       The
 Babbage  language  design  group  is  seeking  suggestions  for   his
 powerful new language, and as the sole  member  of  this  group  (all
 applications for membership will be accepted), I  call  on  the  data
 processing community for help in making this dream a reality.

      Here is a small programming example in Babbage for others to
 use as a programming template:

 Program babbage_template
  by who else
  what if no_program_variables_exist then create_some Or Else!
  Might Do loop
     Just-in-Case
       program_runs_perfectly   : Delete_source_ files;
       user_wants_modifications : Ask for raise;
       user_wants_demo          : Crash_gracefully;
       user_wants_lobotomy      : Continue;
       Or Else!
     Why Not Do Unto Others until user_panicks?
     Basket-Case
       user_pulls_out_hair      : Do_wah until Elsewhere;
       user_pulls_out_terminal  : Going Going Gone;
       user_enters_data         : Can't Do input_data;
       user-wants-more          : append_random_code_to_program
                                  _and_recompile;
       Or Else!
     Won't Do loop
       Windows;
       Diapers;
       Documentation;
     Loop-De-Doop.
  Loop-De-Doop.
 Margorp.






