Index: doc/manual/chapters/chuck_tutorial.tex
===================================================================
RCS file: /cvs/chuck_dev/doc/manual/chapters/chuck_tutorial.tex,v
retrieving revision 1.1
diff -u -r1.1 chuck_tutorial.tex
--- doc/manual/chapters/chuck_tutorial.tex	7 Jun 2005 03:32:36 -0000	1.1
+++ doc/manual/chapters/chuck_tutorial.tex	19 Oct 2005 17:55:56 -0000
@@ -3,17 +3,23 @@
 \section{{\it The} Chuck Tutorial}
 Hello ChucK: 
 
-The first thing we are going to do is do generate a sine wave and send to the speaker so we can hear it. We can do this easily ChucK by connecting audio processing modules (unit generators) and having them work together to compute the sound. 
+The first thing we are going to do is do generate a sine wave and send it to the speaker so we can hear it. We can do this easily ChucK by connecting audio processing modules (unit generators) and having them work together to compute the sound. 
 
-We start with a blank ChucK program, and add the following line of code: (by default, a ChucK program starts executing from the first instruction in the top-level (global) scope).
+We start with a blank ChucK program and add the following line of code:
 \begin{verbatim}
         // connect sine oscillator to D/A convertor (sound card)
         sinosc s => dac;
 \end{verbatim}
+(by default, a ChucK program starts executing from the first instruction in the top-level (global) scope).
 
-The above does several things. (1) it creates a new unit generator of type `sinosc' (sine oscillator), and store its reference in variable `s'. (2) `dac' (D/A convertor) is a special unit generator (created by the system) which is our abstraction for the underlying audio interface. (3) we are using the ChucK operator (\chuckop) to ChucK `s' to `dac'. In ChucK, when one unit generator is ChucKed to another, we connect them. We can think of this line as setting up a data flow from `s', a signal generator, to `dac', the sound card/speaker. Collectively, we will call this a `patch'. 
+The above does several things:
+\begin{enumerate}
+\item it creates a new unit generator of type `sinosc' (sine oscillator), and stores its reference in variable `s'.
+\item `dac' (D/A convertor) is a special unit generator (created by the system) which is our abstraction for the underlying audio interface.
+\item we are using the ChucK operator (\chuckop) to ChucK `s' to `dac'. In ChucK, when one unit generator is ChucKed to another, we connect them. We can think of this line as setting up a data flow from `s', a signal generator, to `dac', the sound card/speaker. Collectively, we will call this a `patch'. 
+\end{enumerate}
 
-The above is a valid ChucK program, but all it does so far is make the connection (if we ran this program, it would exit immediately). In order for this to do what we want, we need to take care of one more very important thing: time. Unlike many other languages, we don't have to explicitly say "play" to hear the result. In ChucK, we simply have to ``allow time to pass'' for data to be computed. As we will see, time and audio data are both inextricably related in ChucK (as in reality), and separated in the way they are manipulated. But for now, let's generate our sine wave and hear it by adding one more line:
+The above is a valid ChucK program, but all it does so far is make the connection -- if we ran this program, it would exit immediately. In order for this to do what we want, we need to take care of one more very important thing: time. Unlike many other languages, we don't have to explicitly say ``play'' to hear the result. In ChucK, we simply have to ``allow time to pass'' for data to be computed. As we will see, time and audio data are both inextricably related in ChucK (as in reality), and separated in the way they are manipulated. But for now, let's generate our sine wave and hear it by adding one more line:
 
 \begin{verbatim}
 
@@ -40,9 +46,9 @@
         }
 \end{verbatim}
 
-In ChucK, this is called a `time-loop' (in fact this is an `infinite time loop'). This program executes (and generate/process audio) indefinitely. Try runnig this program. 
+In ChucK, this is called a `time-loop' (in fact this is an `infinite time loop'). This program executes (and generate/process audio) indefinitely. Try running this program. 
 
-So far, since all we are doing is advancing time, it doesn't really matter (for now) what value we advance time by - (we used 2::second here, but we could have used any number of `ms', `second', `minute', `hour', `day', and even `week'), and the result would be the same. It is good to keep in mind from this example that almost everything in ChucK happens naturally from the timing. 
+So far, since all we are doing is advancing time; it doesn't really matter (for now) what value we advance time by - (we used 2::second here, but we could have used any number of `ms', `second', `minute', `hour', `day', and even `week'), and the result would be the same. It is good to keep in mind from this example that almost everything in ChucK happens naturally from the timing. 
 
 Now, let's try changing the frequency randomly every 100ms:
 \begin{verbatim}
@@ -62,12 +68,12 @@
 Go ahead and run this (again replace foo.ck with your filename):
 \chuckterm{\prompt chuck foo.ck}
 
-Play with the parameters in the program. change 100::ms to something else (like 50::ms or 500::ms), or change 400.0 to 4000.0. 
+Play with the parameters in the program. Change 100::ms to something else (like 50::ms or 500::ms), or change 400.0 to 4000.0. 
 
 Run and listen:
 \chuckterm{\prompt chuck foo.ck}
 
-Once things work, holdon to this file - we will use it again soon. 
+Once things work, hold on to this file - we will use it again soon. 
 
 Concurrency in ChucK: 
 
@@ -99,10 +105,12 @@
 Name this moe.ck, and run it:
 \chuckterm{\prompt chuck moe.ck}
 
-Now, make two copies of moe.ck - larry.ck and curly.ck. Make the following modifications. 
-1) change larry.ck to advance time by 99::ms (instead of 100::ms).\\
-2) change curly.ck to advance time by 101::ms (instead of 100::ms).\\ 
-3) optionally, change the 4000.0 to something else (like 400.0 for curly). 
+Now, make two copies of moe.ck - larry.ck and curly.ck. Make the following modifications:
+\begin{enumerate}
+\item change larry.ck to advance time by 99::ms (instead of 100::ms).
+\item change curly.ck to advance time by 101::ms (instead of 100::ms). 
+\item optionally, change the 4000.0 to something else (like 400.0 for curly). 
+\end{enumerate}
 
 Run all three in parallel:
 \chuckterm{\prompt chuck moe.ck larry.ck curly.ck}
@@ -110,7 +118,7 @@
 What you hear (if all goes well) should be 'phasing' between moe, larry, and curly, 
 with curly emitting the lower-frequency pulses. 
 
-ChucK supports sample-synchronous concurrency, via the ChucK timing mechanism. Given any 
+ChucK supports sample-synchronous concurrency via the ChucK timing mechanism. Given any 
 number of source files that uses the timing mechanism above, the ChucK VM can use the timing 
 information to automatically synchronize all of them. Furthermore, the concurrency is 
 'sample-synchronous', meaning that inter-process audio timing is guaranteed to be precise to 
