X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=md%2Flanguage.md;h=5649126c82c8ac65521f49427424306b42bdf31e;hb=717609e9f470c8d671a7eb2503d30f65be49caeb;hp=fe739e63910d7b2cc36ba2e66a0b1b5e74fa72c0;hpb=0be149d7a130b2697ad8c38d165faca8c0c681c7;p=mudman.git

diff --git a/md/language.md b/md/language.md
index fe739e6..5649126 100644
--- a/md/language.md
+++ b/md/language.md
@@ -19,21 +19,21 @@ This document is free of known copyright restrictions.
 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
@@ -125,9 +125,9 @@ on.
 
 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:
@@ -175,8 +175,8 @@ especially upon reaching chapter 5 (Simple Functions).
 -------------------------
 
 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
 
@@ -231,9 +231,8 @@ except that, if your terminal is a "display" terminal (for example,
 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
@@ -243,11 +242,11 @@ 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