Merge pull request #26 from source-academy/revamp-chapter-1

chapter 1 in ok shape

Author: martin-henz

xml/chapter1/section1/subsection4.xml

@@ -342,7 +342,7 @@ square(square(3));
  <JAVASCRIPT>
  <TEXT>
  We can also use <JAVASCRIPTINLINE>square</JAVASCRIPTINLINE> 
- as a building block in defining other
+ as a building block in declaring other
  functions. For example, <LATEXINLINE>$x^2 +y^2$</LATEXINLINE> 
  can be expressed as 
  <SNIPPET EVAL="no">

xml/chapter1/section1/subsection6.xml

@@ -93,10 +93,10 @@
  </SCHEME>
  <JAVASCRIPT>
  <TEXT>
- The expressive power of the class of functions that we can define at
+ The expressive power of the class of functions that we can declare at
  this point is very limited, because we have no way to make tests and
  to perform different operations depending on the result of a test.
- For instance, we cannot define a function that computes the 
+ For instance, we cannot declare a function that computes the 
  <INDEX>absolute value</INDEX>
  absolute
  value of a number by testing whether the number is negative or not,
@@ -600,7 +600,7 @@ x &gt; 5 &amp;&amp; x &lt; 10
  <JAVASCRIPT>
  <TEXT>
  <CHANGE>
- As another example, we can define a predicate to test whether one
+ As another example, we can declare a predicate to test whether one
  number is not equal to another number.
  <COMMENT>&gt;= already introduced above, so not_equal used here</COMMENT>
  </CHANGE>

xml/chapter1/section1/subsection7.xml

@@ -368,16 +368,25 @@ function sqrt(x) {
  </SPLIT>
 
  <TEXT>
- If we type these definitions to the interpreter, we can use <SCHEMEINLINE>sqrt</SCHEMEINLINE>
+ If we type these
+ <SPLITINLINE>
+ <SCHEME>
+ definitions
+ </SCHEME>
+ <JAVASCRIPT>
+ declarations
+ </JAVASCRIPT>
+ </SPLITINLINE>
+ to the interpreter, we can use <SCHEMEINLINE>sqrt</SCHEMEINLINE>
  just as we can use any
  <SPLITINLINE>
  <SCHEME>
- procedure
+ procedure:
  </SCHEME>
  <JAVASCRIPT>
- function
+ function:
  </JAVASCRIPT>
- </SPLITINLINE>:
+ </SPLITINLINE>
 
  <SNIPPET PAGE="24">
  <NAME>sqrt_example</NAME>
@@ -560,8 +569,8 @@ square(sqrt(1000));
  ordinary conditional function whose application 
  works just like conditional expressions?</QUOTE> she asks.
  Alyssa<APOS/>s friend Eva Lu Ator claims this can indeed be done, and
- she defines a <SCHEMEINLINE>conditional</SCHEMEINLINE> function
- as follows:
+ she declares a <JAVASCRIPTINLINE>conditional</JAVASCRIPTINLINE>
+ function as follows:
  <SNIPPET>
  <NAME>conditional</NAME>
  <JAVASCRIPT>

xml/chapter1/section1/subsection8.xml

@@ -16,7 +16,7 @@
  <SPLITINLINE><SCHEME><SCHEMEINLINE>Sqrt</SCHEMEINLINE></SCHEME><JAVASCRIPT>The function <JAVASCRIPTINLINE>sqrt</JAVASCRIPTINLINE></JAVASCRIPT></SPLITINLINE> is our first example of a process defined by a set of
  mutually 
  <SPLITINLINE><SCHEME>defined procedures</SCHEME>
- <JAVASCRIPT>declared functions</JAVASCRIPT></SPLITINLINE>.
+ <JAVASCRIPT>defined functions</JAVASCRIPT></SPLITINLINE>.
  Notice that the 
  <SPLITINLINE><SCHEME>definition of <SCHEMEINLINE>sqrt-iter</SCHEMEINLINE></SCHEME><JAVASCRIPT>declaration of <JAVASCRIPTINLINE>sqrt_iter</JAVASCRIPTINLINE></JAVASCRIPT></SPLITINLINE> is
  <INDEX>recursive procedure<SUBINDEX>recursive procedure definition</SUBINDEX></INDEX>
@@ -385,13 +385,14 @@ function square(y) {
  </JAVASCRIPT>
  </SPLITINLINE>
  For example, we used
- <SCHEMEINLINE>square</SCHEMEINLINE> in
- the definition of
+ <SCHEMEINLINE>square</SCHEMEINLINE> 
  <SPLITINLINE>
  <SCHEME>
+ in the definition of 
  <SCHEMEINLINE>good-enough?</SCHEMEINLINE>
  </SCHEME>
  <JAVASCRIPT>
+ in the declaration of 
  <JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE>
  </JAVASCRIPT>
  </SPLITINLINE>
@@ -528,13 +529,13 @@ function good_enough(guess, x) {
  has a very special role in the
  <SPLITINLINE>
  <SCHEME>
- procedure
+ procedure definition, 
  </SCHEME>
  <JAVASCRIPT>
- function
+ function declaration,
  </JAVASCRIPT>
  </SPLITINLINE>
- definition, in that it doesn<APOS/>t matter what name the
+ in that it doesn<APOS/>t matter what name the
  <SPLITINLINE>
  <SCHEME>
  formal
@@ -549,14 +550,13 @@ function good_enough(guess, x) {
  <SPLITINLINE>
  <SCHEME>
  a <EM>bound variable</EM>, and we
- say that the procedure
+ say that the procedure definition
  </SCHEME>
  <JAVASCRIPT>
  <EM>bound</EM>, and we
- say that the function
+ say that the function declaration
  </JAVASCRIPT>
  </SPLITINLINE>
- definition
  <INDEX>bind</INDEX>
  <EM>binds</EM> its
  <SPLITINLINE>
@@ -573,18 +573,22 @@ function good_enough(guess, x) {
  procedure definition is unchanged if a bound variable
  </SCHEME>
  <JAVASCRIPT>
- function definition is unchanged if a bound name
+ function declaration is unchanged if a bound name
  </JAVASCRIPT>
  </SPLITINLINE>
- is consistently renamed throughout the definition.<FOOTNOTE>The
+ is consistently renamed throughout the
+ <SPLITINLINE><SCHEME>definition</SCHEME><JAVASCRIPT>declaration</JAVASCRIPT></SPLITINLINE>.<FOOTNOTE>The
  concept of consistent renaming is actually subtle and difficult to
  define formally. Famous logicians have made embarrassing errors
  here.</FOOTNOTE>
 If a <SPLITINLINE><SCHEME>variable</SCHEME><JAVASCRIPT>name</JAVASCRIPT></SPLITINLINE>
 is not bound, we say that it is
  <INDEX>free variable</INDEX><INDEX>variable<SUBINDEX>free</SUBINDEX></INDEX>
  <EM>free</EM>. The
- set of expressions for which a binding defines a name is called the
+ set of expressions for which a binding
+ <SPLITINLINE><SCHEME>defines</SCHEME><JAVASCRIPT>declares</JAVASCRIPT></SPLITINLINE>
+ a name
+ is called the
  <INDEX>scope of a variable</INDEX><INDEX>variable<SUBINDEX>scope of</SUBINDEX></INDEX>
  <EM>scope</EM> of that name.
  In a
@@ -593,7 +597,7 @@ function good_enough(guess, x) {
  procedure definition, the bound variables
  </SCHEME>
  <JAVASCRIPT>
- function definition, the bound names
+ function declaration, the bound names
  </JAVASCRIPT>
  </SPLITINLINE>
  declared as the
@@ -662,7 +666,7 @@ function good_enough(guess, x) {
  </SCHEME>
  <JAVASCRIPT>
  <TEXT>
- In the definition of <JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE> above,
+ In the declaration of <JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE> above,
  <JAVASCRIPTINLINE>guess</JAVASCRIPTINLINE> and <JAVASCRIPTINLINE>x</JAVASCRIPTINLINE> are
  bound names but <JAVASCRIPTINLINE>abs</JAVASCRIPTINLINE>, and
  <JAVASCRIPTINLINE>square</JAVASCRIPTINLINE> are free.
@@ -683,19 +687,21 @@ function good_enough(guess, x) {
  meaning of <JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE> is
  not independent of the choice of its
  free names, however. It surely depends upon the fact (external to
- this definition) that the symbol <JAVASCRIPTINLINE>abs</JAVASCRIPTINLINE> names a
+ this declaration) that the symbol <JAVASCRIPTINLINE>abs</JAVASCRIPTINLINE> names a
  function for computing the absolute value of a number.
  The JavaScript function <JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE> will
  compute a different mathematical function if we substitute
  <JAVASCRIPTINLINE>math_cos</JAVASCRIPTINLINE> (JavaScript<APOS/>s cosine function)
- for <JAVASCRIPTINLINE>abs</JAVASCRIPTINLINE> in its definition.
+ for <JAVASCRIPTINLINE>abs</JAVASCRIPTINLINE> in its declaration.
  <INDEX>local name|)</INDEX>
  </TEXT>
  </JAVASCRIPT>
  </SPLIT>
 
  <SUBHEADING>
- <NAME>Internal definitions and block structure</NAME>
+ <NAME>Internal
+ <SPLITINLINE><SCHEME>definitions</SCHEME><JAVASCRIPT>declarations</JAVASCRIPT></SPLITINLINE>
+ and block structure</NAME>
  </SUBHEADING>
  <LABEL NAME="sec:block-structure"/>
 
@@ -903,9 +909,14 @@ function sqrt(x) {
  This <EM>block structure</EM>
  is basically the right solution to the simplest
  name-packaging problem. But there is a better idea lurking here. In
- addition to internalizing the definitions of the auxiliary
- <SPLITINLINE><SCHEME>procedures</SCHEME><JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>,
- we can simplify them. Since <SCHEMEINLINE>x</SCHEMEINLINE> is bound in the definition of
+ addition to internalizing the 
+ <SPLITINLINE><SCHEME>definitions of the auxiliary procedures</SCHEME>
+ <JAVASCRIPT>declarations of the auxiliary functions</JAVASCRIPT></SPLITINLINE>,
+ we can simplify them. Since <SCHEMEINLINE>x</SCHEMEINLINE>
+ is bound in the
+ <SPLITINLINE><SCHEME>definition</SCHEME>
+ <JAVASCRIPT>declaration</JAVASCRIPT></SPLITINLINE>
+ of
  <SCHEMEINLINE>sqrt</SCHEMEINLINE>, the
  <SPLITINLINE>
  <SCHEME>
@@ -917,8 +928,12 @@ function sqrt(x) {
  </SPLITINLINE>
  <SPLITINLINE><SCHEME><SCHEMEINLINE>good-enough?</SCHEMEINLINE></SCHEME><JAVASCRIPT><JAVASCRIPTINLINE>good_enough</JAVASCRIPTINLINE></JAVASCRIPT></SPLITINLINE>,
  <SCHEMEINLINE>improve</SCHEMEINLINE>, and
- <SPLITINLINE><SCHEME><SCHEMEINLINE>sqrt-iter</SCHEMEINLINE></SCHEME><JAVASCRIPT><JAVASCRIPTINLINE>sqrt_iter</JAVASCRIPTINLINE></JAVASCRIPT></SPLITINLINE>,
- which are defined internally to
+ <SPLITINLINE>
+<SCHEME><SCHEMEINLINE>sqrt-iter</SCHEMEINLINE>,
+which are defined internally to</SCHEME>
+<JAVASCRIPT><JAVASCRIPTINLINE>sqrt_iter</JAVASCRIPTINLINE>,
+which are defined internally to</JAVASCRIPT>
+ </SPLITINLINE>
  <SCHEMEINLINE>sqrt</SCHEMEINLINE>, are in the
  scope of <SCHEMEINLINE>x</SCHEMEINLINE>.
  Thus, it is not necessary to pass
@@ -930,7 +945,10 @@ function sqrt(x) {
  <INDEX>free variable<SUBINDEX>internal@in internal definition</SUBINDEX></INDEX>
  free
  <SPLITINLINE><SCHEME>variable</SCHEME><JAVASCRIPT>name</JAVASCRIPT></SPLITINLINE>
- in the internal definitions, as shown below.
+ in the internal
+ <SPLITINLINE><SCHEME>definitions,</SCHEME>
+ <JAVASCRIPT>declarations,</JAVASCRIPT></SPLITINLINE>
+ as shown below.
  Then <SCHEMEINLINE>x</SCHEMEINLINE>
  gets its value from the argument with which the enclosing
  <SPLITINLINE>
@@ -960,25 +978,24 @@ function sqrt(x) {
  bindings made by enclosing
  <SPLITINLINE>
  <SCHEME>
- procedure
+ procedure definitions;
  </SCHEME>
  <JAVASCRIPT>
- function
+ function declarations;
  </JAVASCRIPT>
  </SPLITINLINE>
- definitions;
  that is, they are looked up in
  <INDEX>environment<SUBINDEX>lexical scoping and</SUBINDEX></INDEX>
  the environment in which the
  <SPLITINLINE>
  <SCHEME>
- procedure
+ procedure was defined. 
  </SCHEME>
  <JAVASCRIPT>
- function
+ function was declared.
  </JAVASCRIPT>
  </SPLITINLINE>
- was defined. We will see how
+ We will see how
  this works in detail in chapter<SPACE/>3 when we
  study environments and the
  detailed behavior of the interpreter.</FOOTNOTE>
@@ -1022,19 +1039,23 @@ function sqrt(x) {
 
  <TEXT>
  We will use block structure extensively to help us break
- up large programs into tractable pieces.<FOOTNOTE>Embedded definitions
- <INDEX>internal definition<SUBINDEX>position of</SUBINDEX></INDEX>
- must come first in a
+ up large programs into tractable pieces.<FOOTNOTE>Embedded 
  <SPLITINLINE>
  <SCHEME>
- procedure
+ definitions must come first in a procedure
  </SCHEME>
  <JAVASCRIPT>
- function
+ declarations must come first in a function
  </JAVASCRIPT>
  </SPLITINLINE>
- body. The management is not responsible
- for the consequences of running programs that intertwine definition
+ body.
+ <INDEX>internal definition<SUBINDEX>position of</SUBINDEX></INDEX>
+ The management is not responsible
+ for the consequences of running programs that intertwine
+ <SPLITINLINE>
+ <SCHEME>definition</SCHEME>
+<JAVASCRIPT>declaration</JAVASCRIPT>
+ </SPLITINLINE>
  and use.<LABEL NAME="foot:management"/></FOOTNOTE>
  The idea of block structure originated with the
  programming language

xml/chapter1/section2/subsection1.xml

@@ -116,11 +116,9 @@ application<SUBINDEX>shape of process|(</SUBINDEX></INDEX>
  <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> 
  for computing
  factorials:<FOOTNOTE>In a real program we would probably use the
- block structure introduced in the last section to hide the definition
- of
- <SPLITINLINE><SCHEME><SCHEMEINLINE>fact-iter</SCHEMEINLINE></SCHEME>
- <JAVASCRIPT><JAVASCRIPTINLINE>fact_iter</JAVASCRIPTINLINE></JAVASCRIPT>
- </SPLITINLINE>:
+ block structure introduced in the last section to hide the 
+ <SPLITINLINE>
+ <SCHEME>definition of <SCHEMEINLINE>fact-iter</SCHEMEINLINE></SCHEME><JAVASCRIPT>declaration of <JAVASCRIPTINLINE>fact_iter</JAVASCRIPTINLINE></JAVASCRIPT></SPLITINLINE>:
 
  <SNIPPET PAGE="33">
  <EXAMPLE>factorial_example</EXAMPLE>
@@ -345,7 +343,9 @@ function fact_iter(product, counter, max_count) {
  recursive 
  <EM><SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE></EM>. 
  When we describe a <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> as recursive,
- we are referring to the syntactic fact that the <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> definition
+ we are referring to the syntactic fact that the
+ <SPLITINLINE><SCHEME>procedure definition</SCHEME>
+ <JAVASCRIPT>function declaration</JAVASCRIPT></SPLITINLINE> 
  refers (either directly or indirectly) to the <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> itself. But
  when we describe a process as following a pattern that is, say,
  linearly recursive, we are speaking about how the process evolves, not
@@ -593,8 +593,11 @@ A(3, 3);
  </JAVASCRIPT>
  </SNIPPET>
 
- Consider the following <SPLITINLINE><SCHEME>procedures</SCHEME><JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>, where <SCHEMEINLINE>A</SCHEMEINLINE> is the <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> 
- defined above:
+ Consider the following <SPLITINLINE><SCHEME>procedures</SCHEME><JAVASCRIPT>functions</JAVASCRIPT></SPLITINLINE>, where <SCHEMEINLINE>A</SCHEMEINLINE> is the
+<SPLITINLINE><SCHEME>procedure defined</SCHEME>
+<JAVASCRIPT>function declared</JAVASCRIPT>
+</SPLITINLINE> 
+ above:
 
  <SNIPPET PAGE="36">
  <NAME>fghk_definition</NAME>

xml/chapter1/section2/subsection4.xml

@@ -148,7 +148,6 @@ function fast_expt(b, n) {
  ? square(fast_expt(b, n / 2))
  : b * fast_expt(b, n - 1);
 }
-
  </JAVASCRIPT>
  </SNIPPET>
 

xml/chapter1/section2/subsection6.xml

@@ -269,7 +269,7 @@ expmod(4, 3, 5);
  <SCHEMEINLINE>random</SCHEMEINLINE>, which we assume 
  <SPLITINLINE>
 <SCHEME>is included as a primitive in Scheme.</SCHEME>
-<JAVASCRIPT>our JavaScript environment defines as a primitive function.c</JAVASCRIPT>
+<JAVASCRIPT>our JavaScript environment defines as a primitive function.</JAVASCRIPT>
  </SPLITINLINE>
  <SPLITINLINE>
  <SCHEME>
@@ -514,7 +514,8 @@ smallest_divisor(199);
  procedure,
  </SCHEME>
  <JAVASCRIPT>
- Assume that our JavaScript environment defines a primitive function called 
+ Assume that our JavaScript environment declares a
+primitive function called 
  <SCHEMEINLINE>runtime</SCHEMEINLINE>
  that returns an integer that specifies the amount of time the system
  has been running (measured in microseconds). The
@@ -654,8 +655,9 @@ timed_prime_test(43);
  should not be 2, 3, 4, 5, 6, <ELLIPSIS/>
  but rather 2, 3, 5, 7, 9, <ELLIPSIS/>.
  To implement this
- change, define a 
- <SPLITINLINE><SCHEME>procedure</SCHEME><JAVASCRIPT>function</JAVASCRIPT></SPLITINLINE> 
+ change, 
+ <SPLITINLINE>define a <SCHEME>procedure</SCHEME>
+ <JAVASCRIPT>declare a function</JAVASCRIPT></SPLITINLINE> 
  <SCHEMEINLINE>next</SCHEMEINLINE> that returns 3 if its input is
  equal to 2 and otherwise returns its input plus<SPACE/>2. 
  Modify the