Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10 5/3/83; site rochester.UUCP
Path: utzoo!linus!philabs!seismo!rochester!henry
From: henry@rochester.UUCP (Henry Kautz)
Newsgroups: net.jokes
Subject: snafu
Message-ID: <3373@rochester.UUCP>
Date: Wed, 12-Oct-83 23:17:57 EDT
Article-I.D.: rocheste.3373
Posted: Wed Oct 12 23:17:57 1983
Date-Received: Fri, 14-Oct-83 07:59:17 EDT
Sender: henry@rocheste.UUCP
Organization: U. of Rochester, CS Dept.
Lines: 522

From: Henry.Kautz
Yet another funny programming language.
This one was actually implemented.  (In franz lisp, yet.)






                   The SNAFU User's Guide
                        Version 0.00


_1.  _I_n_t_r_o_d_u_c_t_i_o_n

     SNAFU is an  elegant,  portable  programming  language,
specifically  designed  for  instruction,  system  building,
numerical analysis, data processing, artifical intelligence,
VLSI,  and  program verification.  It combines the most not-
able features of (and is expected to  soon  supplant)  PL/I,
Lisp, FORTRAN, Basic, Sail, Pascal, Ada, Forth, C, Conniver,
SNOBOL,  APL,  PLZ,  Prolog,   Mesa,  Euclid,  Algol,  Godel
Numbers, and RPG.

_2.  _A _F_o_r_m_a_l _G_r_a_m_m_e_r

     Like Pure Lisp and Algol 60, SNAFU is a  small,  easily
understood  language;  there  are  no  "redundant" features,
which could lead to conflicting conventions and  programming
styles.

            <program> := <exp>*
            <exp> := <variable>
                     <complex exp>
                     <constant>
                     <label>
                     <comefrom stmt>
                     <stop stmt>

The "semi-colon as separator" vs. "semi-colon as terminator"
dispute  is resolved by eliminating semi-colons (as in PLZ).
The following sections will precisely define  each  type  of
expression.

_3.  _V_a_r_i_a_b_l_e_s

            <variable> := <digit>+


     A variable is identified by a sequence of digits;  e.g.
374.   Languages  like  C  and Pascal, which allow arbitrary
alphanumerics to appear  in  variable  names,  permit  near-
undetectable  errors  to  occur when capital are substituted
for small letters and vice-versa:  the variable  "TOTAL"  is
not  the  same  as  "total", yet both may appear in the same
program![1] There is clearly no such problem in  SNAFU;  the
compiler/interpreter  immediately notices the error if "#&$"
____________________
9   [1] "Lowercase Considered Harmful", SigPlan  Notices,  Je
80.



9










is typed instead of 374 ! [2]

_4.  _C_o_n_s_t_a_n_t_s

            <constant> := ! <non-blank characters>+


     A constant is marked by a preceeding !; thus, if 948752
is  325431,  then  !   948752 evaluates to 848752 but 948752
evaluates to 325431.  Constants may contain letters as  well
-- so ! Hello or even ! Hello!!! are okay -- WITHOUT needing
special "escape" characters around the !!! in  Hello!!!   as
in C, or  special "doubling" rules as in PL/I, etc.

_5.  _C_o_m_p_l_e_x _E_x_p_r_e_s_s_i_o_n_s

            <complex exp> := <exp>+ <operator>
            <operator> := +
                          <
                          >
                          =
                          NAND


     Conventional Algol-like expressions  are  an  aestheti-
cally  inexcriable  conflusion  of  notation  --  some infix
operators, some  prefix,  some  "functions"  (like  "PRINT")
which are not really functions at all!  Lisp took the impor-
tant step of introducing a  uniform  notation,  but  left  a
intolerable  afterbirth of  parenthesis -- effectively elim-
inating it as a candidate language for "mainstream"  comput-
ing professionals. [3] SNAFU totally  ELIMATES  parenthesis,
by  putting  expressions  in  uniform POSTFIX notation (also
called "reverse Polish") [4] .

     Only a few basic operators are needed to make  SNAFU  a
complete and expressive language:




____________________
9   [2] FORTRAN and Sail provide the half-hearted solution of
mapping  all  identifiers  to  upper-case  --  but leave un-
resolved the confusion between O (letter oh) and  0  (zero),
as in FOO and F00!
   [3] It is well known that normal human beings (as opposed
to certain ivory-tower "types") can't  "parse"  a  statement
with more than one or two levels of nesting!
   [4] A notation tried and proven in the rough  and  tumble
world of pocket scientific calculators!



9










_6.  _A_r_i_t_h_m_a_t_i_c _O_p_e_r_a_t_o_r_s

            <exp> <exp> +


     SNAFU provides plus (+) as its basic arithmetic  opera-
tor.   Any  first-year  theory  student can demonstrate that
subtraction, multipication, and division can be  defined  in
terms of addition[5] and so are pruned  from  the  language.
Example:

            2341 324 + 10 111 + +

calculates the sum of the values of all the variables above.
(Note  that  questions  of  the "precidence" of one operator
over another are neatly sidestepped!)

_7.  _C_o_m_p_a_r_i_s_o_n _O_p_e_r_a_t_o_r_s

            <exp> <exp> <


     The < operator provides a partial ordering  on  numbers
and strings.  For example,

            ! 42 ! 87 <  is true
            ! DOG ! CAT < is false

An important point overlooked by most language designers  is
that

            ! 136 ! 18 <

is ambiguous!  Numerically it  is  false,  lexically  it  is
true!    SNAFU   recognizes   the  inherent  ambiguity,  and
forthrightly evaluates to "not sure" (see the if - statement
below).

_8.  _O_u_t_p_u_t

            <exp> >


     > prints the value of  <exp>  on  the  user's  console.
While most day-to-day computer programs are "I/O intensive",
SNAFU is the ONLY major language [6] which provides an  out-

____________________
9   [5] The author of this paper,  unfortunately,  is  not  a
first-year  theory student, so the derivation is left to the
reader.



9










put operator in a single  keystroke!   (Output,  incidently,
returns no value whatsoever.  The usefulness of this feature
is demonstrated by the following program fragment:

            ! 1 ! 2 ! is ! answer ! the > > > + >

prints out, "the answer is 3".)

_9.  _A_s_s_i_g_n_m_e_n_t

            <exp> <exp> =
            <exp> ! <variable> =


     The second form above is the simpliest way  to assign a
value to a variable, as is ! Hello ! 10 = , so that later on
10 > prints out Hello.  Putting the = on the RIGHT  hand  of
the  equation  (i)  makes  it easy to spot assignment state-
ments, and (ii) is more consistant than the convention  fol-
lowed  by nearly every other language, which normally evalu-
ate left-to-right but perform a left-most  assignment  last!
[7]

     Assignment returns nothing as well. Example: ! 10 !  10
= 10 > prints 10.

_1_0.  _L_o_g_i_c_a_l _O_p_e_r_a_t_o_r_s

            <exp> <exp> NAND


     Logicians have long observed that the mixed bag of log-
ical  connectives  commonly  used  --  not,  and, etc. -- is
excessive, and a single  logical  operator  (of  the  proper
kind) suffices. [8] Therefore, SNAFU includes "NAND" as  its
sole logical operator. [9]

     Futhermore,  as  hinted  above,  SNAFU  replaces   old-
fashioned  binary  logic  with TERNARY (three-valued) logic,
producing a language 50% more powerful than Prolog.

_1_1.  _F_l_o_w _o_f _C_o_n_t_r_o_l

     SNAFU is a high-level structured-programming  language.
User's  agree that its unique control structures combine the
____________________
9   [6] APL requires two.
   [7]  APL  is consistent, but only if you like to read He-
brew or Arabic.
   [8] See note above about first-year theory students.
   [9]  This choice should lead to great efficiencies in im-
plementing SNAFU interpreters directly in VLSI.


9










power of FORTRAN with the perspicuousness of a  Planner-like
backward-chaining regime.

_1_2.  _I_f _S_t_a_t_e_m_e_n_t

            <if stmt> := if <exp> then <exp>
                                {else <exp>}
                                {maybe <exp>}
                                neht


     As one would suspect, if the test  <exp>  yields  true,
the  first  branch is executed; false, and the second branch
is; otherwise, the third is.  A profusion of BEGIN  ENDS  is
eliminated  in  favor  of unique delimeters, ala Algol.  The
choice of "fi" (Algol) or "endif" (Ada) as a terminator  has
led  to  terrific controversies over the proper indenting of
the symbol:  does it go under the last  indented  statement,
or directly under the "if"?[10] Our choice of  "neht"  makes
it  clear that the proper indenting places it directly under
the "then"!

_1_3.  _L_a_b_e_l_s

            <label> := <characters>+


     A label may appear absolutely  anywhere,  on  anything,
and is simply any sequence of characters containing at least
one non-numeric.  The importance of explicit names is one of
the  few  concrete  results of all  the hours spent building
enormous A.I.  systems.   The  author  suggests  that  EVERY
statement be proceeded and followed by a label -- or perhaps
SEVERAL labels.

_1_4.  _C_o_m_e_f_r_o_m _S_t_a_t_e_m_e_n_t

            <comefrom stmt> := comefrom <exp> morfemoc


     The ubiquitous "go to" statement has been banished from
SNAFU,  if  not from certain other hoity-toity Department of
Defense languages![11] Instead, SNAFU provides the  comefrom
statement, with the following semantics: whenever the execu-
tion sequence comes to a label, the body of  every  comefrom
statement  in  the program is evaluated; execution then con-
tinues after the first comefrom (if any) whose  body  equals
____________________
9   [10] See -- any issue of SigPlan Notices
   [11] See "Goto considered harmful", SigPlan  Notices,  Ma
1979



9










the label.

     A simple example makes this all clear.   The  following
program prints a common word five times:

            ! 1 ! 33 =
            comefrom
                     if 33 ! 5 < then ! yapyap
                                 else ! nowhere
                                 neht
            morfemoc
            ! smegma >
            ! 1 33 + ! 33 =
            yapyap
            stop



_1_5.  _S_t_o_p _S_t_a_t_e_m_e_n_t

     The previous example also served to introduce the  stop
statement;  namely  the  word "stop". The so-called "halting
problem", which has been the worry of so many poor  graduate
students,  has been completely solved by the implementors of
the SNAFU system.  During syntactic analysis  of  the  input
program,  the  code  is searched for the word "stop".  If it
does not appear, the system types, "Program does not  halt",
and immediately terminates.

_1_6.  _P_r_o_c_e_d_u_r_e_s

     Procedures are  a  bad  idea.[12]  SNAFU  doesn't  have
them.[13]

_1_7.  _A_b_s_t_r_a_c_t _D_a_t_a _T_y_p_e_s

     The implementation of abstract data types in  SNAFU  is
considerably  simplified by the elimination of functions, as
mentioned above.  Abstract data types thus reduce to  simple
arrays or records.  SNAFU, however, bans explicit arrays and
records as well![14] Instead, the system  of  numeric  vari-
ables  SIMPLY  and CLEANLY allows ANY variable to be used in
situations  in  which  out-dated  languages  would   require
arrays, pointers, lists, records, etc, etc.

____________________
9   [12] See "Procedures  considered  harmful",  SigPlan  No-
tices, last week.
   [13] See A Discipline of Programming, Diiijjjkstra.
   [14] And in doing so, bans  the  anguish  the  programmer
faces in trying to decide how to "structure" the data!



9










     For example:  suppose we desire to use the variable  83
as  an array.  The i-th element is simply 83 plus i !  E.g.,
FORTRAN style X(J) = 13  becomes

         ! 13 ! 83 77 +  =

where, of couse, the variable 83 is used for X and 77 for J.

     The semantics of the assignment statement eliminate the
need  for  special pointer variables.  If the value of vari-
able 32 is 18, then we assign "hello" to variable 18  simply
by

        ! hello 32 =


_1_8.  _T_h_e _S_P_L_A_T _P_a_c_k_a_g_e

     The latest addition to SNAFU  is   SPLAT,  a  state-of-
the-art  artifically intelligent associative memory/database
package.[15]  In  its  simpliest  use,  the   "%"   function
retrieves  the name of the variable whose value is its argu-
ment:

        ! hello ! 12 =
        ! hello % >

prints "12".

     But SPLAT is much more than a tool for data-base  hack-
ers!   Workers  in COGNITIVE MODELING realize that the BRAIN
is  very  special  kind  of   fuzzy,   flakey,   associative
memory![16] Therefore, it not necessary that the value being
searched  for  is  EXACTLY  the same as that of the variable
returned.  Instead, it suffices that the "cognitive  metric"
between the two be less than the NEURAL THRESHHOLD.[17]

_1_9.  _I_m_p_l_e_m_e_n_t_a_t_i_o_n _N_o_t_e_s

     Alas and alack, the version of SNAFU  (0.00)  described
in this report has been declared obsolete and withdrawn from
circulation by the Standing Committee of  the  International
____________________
9   [15] SPLAT was initially  developed  for  the  "foot  and
mouth" project at the University of Iowa.
   [16] "MOPS, FLOPS, and POPS: A Messy Push-down Store", R.
Shank et al, in Isaac Asimov's Cognitive Science Journal, Se
1982.
   [17] The exact value of the neural threshhold is a matter
of some dispute.  After a careful study of pithed  frogs  we
have decided to use the value "32".



9










Standard Computer Standards Committee.  Fortunately, a  copy
of  the  interpreter  remains on the University of Rochester
Vax.  To run it,  just  type  snafu  <filename>,  where  the
designated file contains your SNAFU program.
















































9

9