Abstract
========
-The Muddle programming language began existence in late 1970 (under
-the name Muddle) as a successor to Lisp (Moon, 1974), a candidate
-vehicle for the Dynamic Modeling System, and a possible base for
-implementation of Planner (Hewitt, 1969). The original design goals
-included an interactive integrated environment for programming,
-debugging, loading, and editing: ease in learning and use; facilities
-for structured, modular, shared programs; extensibility of syntax,
-data types and operators: data-type checking for debugging and
-optional data-type declarations for compiled efficiency; associative
-storage, coroutining, and graphics. Along the way to reaching those
-goals, it developed flexible input/output (including the ARPA
-Network), and flexible interrupt and signal handling. It now serves as
-a base for software prototyping, research, development, education, and
-implementation of the majority of programs at MIT-DMS: a library of
-sharable modules, a coherent user interface, special research
+The Muddle programming language began existence in late 1970 as a
+successor to Lisp (Moon, 1974), a candidate vehicle for the Dynamic
+Modeling System, and a possible base for implementation of Planner
+(Hewitt, 1969). The original design goals included an interactive
+integrated environment for programming, debugging, loading, and
+editing: ease in learning and use; facilities for structured,
+modular, shared programs; extensibility of syntax, data types and
+operators: data-type checking for debugging and optional data-type
+declarations for compiled efficiency; associative storage,
+coroutining, and graphics. Along the way to reaching those goals, it
+developed flexible input/output (including the ARPA Network), and
+flexible interrupt and signal handling. It now serves as a base for
+software prototyping, research, development, education, and
+implementation of the majority of programs at MIT-DMS: a library of
+sharable modules, a coherent user interface, special research
projects, autonomous daemons, etc.
This document was originally intended to be a simple low-level
There are no "practice problems"; you are assumed to be learning
Muddle for some purpose, and your work in achieving that purpose will
-be more useful and motivated than artificial problems. In several
+be more useful and motivating than artificial problems. In several
cases, the examples contain illustrations of important points which
-are not covered in the text. Ignore examples as your peril.
+are not covered in the text. Ignore examples at your peril.
This document does not assume knowledge of any specific programming
language on your part. However, "computational literacy" is assumed:
-------------------------
First, catch your rabbit. Somehow get the interpreter running -- the
-program in the file `SYS:TS.Muddle` in the ITS version or
-`SYS:Muddle.SAV` in the Tenex version or `SYS:Muddle.EXE` in the
+program in the file `SYS:TS MDL` in the ITS version or
+`SYS:MDL.SAV` in the Tenex version or `SYS:MDL.EXE` in the
Tops-20 version. The interpreter will first type out some news
relating to Muddle, if any, then type
IMLAC, ARDS, Datapoint), it firsts clears the screen.
Typing `^G` (`CTRL`+`G`) causes Muddle to stop whatever it is doing
-and act as if an error had occurred ([section
-1.4](#14-errors-simple-considerations-1)). `^G` is generally most
-useful for temporary interruptions to check the progress of a
+and act as if an error had occurred (section 1.4). `^G` is generally
+most useful for temporary interruptions to check the progress of a
computation. `^G` is "reversible" -- that is, it does not destroy any
of the "state" of the computation it interrupts. To "undo" a `^G`,
type the characters
(This is discussed more fully far below, in section 16.4.)
Typing `^S` (`CTRL`+`S`) causes Muddle to **throw away** what it is
-currently doing and return a normal "listening" state. (In the Tenex
-and Tops-20 versions, `^O` also should have the same effect.) `^S` is
-generally most useful for aborting infinite loops and similar terrible
-things. `^S` **destroys** whatever is going on, and so it is **not**
-reversible.
+currently doing and return to a normal "listening" state. (In the
+Tenex and Tops-20 versions, `^O` also should have the same effect.)
+`^S` is generally most useful for aborting infinite loops and similar
+terrible things. `^S` **destroys** whatever is going on, and so it is
+**not** reversible.
Most expressions in Muddle include "brackets" (generically meant) that
must be correctly paired and nested. If you end your typing with the
projects / mudman.git / blobdiff