COMP 210 Lab 1: Getting Started: DrScheme, Design Recipe

This will show you a few UNIX basics you'll need to know, and prepare you for using DrScheme.

1. From your home directory, type the UNIX command

               ls -l
               

   You should see a directory called comp210, created by the previous step. If you don't, tell one of the lab assistants.

2. Change directory into the comp210 directory with the UNIX command

               cd comp210
               

3. Make a directory called labs by typing

               mkdir labs
               

4. Change directory into the labs directory.

5. Make an lab01 directory for this lab.

6. Change directory into the lab01 directory.

1. Enter

               drscheme
               

   at a UNIX prompt. (If this complains about a file not found, then register didn't work. Use ~comp210/bin/drscheme instead.)

2. If this is the first time you've run DrScheme, it will ask you your preferred language, and the Scheme language level; the latter should be "Beginning Student".

   This level makes DrScheme catch more errors for you: namely, errors which are technically legal Scheme, but are probably not what you really want early in the course.

1. Enter (or cut/paste) the following into definition window, including:

               (+ 2 7)
               (* (+ 2 7) 3)
   
               ; owe: nonneg-num -> nonneg-num
               ; Return the amount owed for eating slices slices.
               ;
               (define (owe slices)
                  (* (/ 12 8) slices))
               

   Observe that DrScheme helps you with the indentation if you use the Return key in appropriate places. It also "bounces" the cursor to visually match the closing parenthesis with the corresponding opening parenthesis.

2. We included comments before each function definition, explaining what it is supposed to do. DrScheme ignores the comments, but you, your grader, your boss, etc., can read them. Soon, we'll provide more guidance on what to say in your comments.

               ; One form of comments is anything following a semicolon
               ; up to the end of the line.
               

               #|
               Another form of comments is anything between these
               two matching markers.
               |#
               

   You can also go to the Special menu, choose Insert comment box. You are welcome to do this, but one caveat: if DrScheme saves a file which includes a fancy comment box, the file will not be saved in plain-text format. (Only an issue if you want to open or print the file with a different program later.)

3. Edit your definitions or comments some. You can use the mouse, the arrow keys, backspace, and standard keyboard shortcuts to move the cursor around.

   In DrScheme for UNIX, some handy the keyboard shortcuts include:

   • Control-p (previous line),
   • Control-n (next line),
   • Control-b (back character),
   • Control-f (forward character),
   • Control-a (start of line), and
   • Control-e (end of line).
   The PC and Mac versions of DrScheme use their respective standard keyboard shortcuts instead. (You can look in the Edit menu under Keybindings for the complete list.)

4. Load the definitions into the interaction window by clicking on the Execute button.

   If DrScheme detects any syntactic errors, it will give you an error message in the interactions window and highlight the error in the definitions window.

5. Use those definitions by typing in the interaction window some Scheme expressions using those definitions. E.g.,

               (owe 5)
               (owe 7)
               

6. Save your work in your ~/comp210/labs/lab01/ directory. Be sure to use a filename that has a .ss extension.

   You don't need to turn in your lab work, but it's useful to save it so that you can look at it again.

7. Finally, intentionally introduce an error (or, what you think will be an error), press Execute, and see what error message is given. We'll go around the room to see what different error messages people get. Do the error messages tend to make sense?

1. Place an example use or two of your functions in the definitions window, after the appropriate definitions. For example,

               (owe 10)
               

2. Click on the Step button.

   This brings up a new stepper windows which will show how DrScheme calculates the answer.

3. Use the stepper's button to look through the evaluation. At each step, it shows what part of the code needs to be evaluated next, and what the result is.

"Hand-evaluation" is just you doing the same thing as DrScheme's stepper. It is useful to convince yourself that you know what is supposed to happen, independently of having DrScheme help you.

1. Hand-evaluate a few example expressions, and type in each of the small steps you would make to calculate the result. Type these in the definitions window after your definitions. For example,

               ; Hand-evaluation:
               (owe 10)
               (* (/ 12 8) 10)
               (* 3/2 10)
               15
               

   This is just high school algebra, successively simplfying expressions, until you reach a final, simple value.

   What do you hope to see, when you Execute all these expressions? What would you see if there were a mistake?

   While you are doing this, it is often helpful to copy the previous step, and edit this copy for the current step. This can save you some typing, and it helps eliminate mistakes. You'll want the Copy and Paste features in the Edit menu. Alternatively, there are keyboard equivalents listed in this menu.

2. Verify your steps by clicking Execute.

3. Once you've used this to verify your steps, put the steps in comments, rather than deleting them. (You'll find that later you might fix a bug, and you want to re-use these as test cases.)