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

Index: DrScheme Basics, Step-by-step Evaluation, Design Recipe, Other Basics

The main goals of this lab are to ensure that you can

use the basic functionality of DrScheme and
start to write (simple) programs in a systematic manner.

Outside of lab, don't forget to get a homework partner and sign up for a lab section, if you haven't already.

"Register" for COMP 210

This has nothing to do with the registrar. This will change your programming environment slightly to access course software more easily.

After you have logged in, type at a Unix prompt,
register comp210
(followed by the Return key, like any UNIX command), and answer yes to the questions.
Logout and login again, so that the changes take affect.

"Register" for COMP 210
This has nothing to do with the registrar. This will change your programming environment slightly to access course software more easily. After you have logged in, type at a Unix prompt, register comp210 (followed by the Return key, like any UNIX command), and answer yes to the questions. Logout and login again, so that the changes take affect.

DrScheme Basics

Make a new directory (folder), for today's work.

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

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.
Change directory into the comp210 directory with the UNIX command
cd comp210

Make a directory called labs by typing
mkdir labs

Change directory into the labs directory.
Make an lab01 directory for this lab.
Change directory into the lab01 directory.

Make a new directory (folder), for today's work.
This will show you a few UNIX basics you'll need to know, and prepare you for using DrScheme. 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. Change directory into the `comp210` directory with the UNIX command cd comp210 Make a directory called `labs` by typing mkdir labs Change directory into the `labs` directory. Make an `lab01` directory for this lab. Change directory into the `lab01` directory.

That's almost all you will need to know about the UNIX operating system for this course. But, if you would like to learn more, you can take a UNIX short course offered by Information Technology. Also, COMP 212's labs will describe some UNIX basics.

Start DrScheme

Type
drscheme
in an xterm window. (If this complains about a file not found, then register didn't work. Use ~comp210/bin/drscheme instead.)

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.

Start DrScheme
Type drscheme in an `xterm` window. (If this complains about a file not found, then `register` didn't work. Use `~comp210/bin/drscheme` instead.) 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.

The DrScheme window is divided into two halves. The lower half, or interaction window, is the Scheme "calculator". The top half, or definition window is nothing but a text editor which is smart about indenting Scheme, and such. The execute button sends the contents of the definition window down to the interaction window, where they are actually evaluated.

For home use, you can download DrScheme.

Simple example of using DrScheme

Enter (or cut/paste) the following into definition window, including:
(+ 2 7) (* (+ 2 7) 3) ;; owe: number -> number ;; 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.

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.)

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.)

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.

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

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.

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?

Simple example of using DrScheme
Enter (or cut/paste) the following into definition window, including: (+ 2 7) (* (+ 2 7) 3) ;; owe: number -> number ;; 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. 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.) 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.) 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. Use those definitions by typing in the interaction window some Scheme expressions using those definitions. E.g., (owe 5) 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. 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?

DrScheme has lots of other features, including a complete manual. We'll explore more of DrScheme in later labs, and we encourage you to explore, but there's no need to learn all its features. Read the DrScheme Tips and Traps page for helpful information on common mistakes, error messages, etc.

Step-by-step Evaluation

While DrScheme evaluates our Scheme programs for us, it is also important for us to understand the process of evaluation. The details of evaluation will be covered in class. Here in lab, we want to explore two useful tools to help us:

DrScheme's stepping tool that illustrates evaluation.
A technique for the programmer to illustrate and check evaluation "by hand".

Using DrScheme's stepper

Place an example use or two of your functions in the definitions window, after the appropriate definitions. For example,
(owe 10)

Click on the Step button.

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

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.

Using DrScheme's stepper
Place an example use or two of your functions in the definitions window, after the appropriate definitions. For example, (owe 10) Click on the `Step` button. This brings up a new stepper windows which will show how DrScheme calculates the answer. 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
Hand-evaluate some 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, (owe 10) = (* (/ 12 8) 10) = (* 3/2 10) = 15 Note that these things are all equal to 15; on your papers, express this with the standard "=", not some nonstandard symbol like "-->" or "=-=>-magically-morphs-into-=-=\|>>". This is just high school algebra, successively simplfying expressions, until you reach a final, simple value. One caveat: when typing the above in, we can't have `=` sitting by itself; `=` is actually a function (which we'll talk about soon). So when typing in DrScheme, you can omit the `=`s. 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 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. Or, there are keyboard equivalents listed in this menu. Verify your steps by clicking "Execute". You should see the same answer multiple times, once for each step, separate by the equals signs. 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 test cases.)

Design Recipe

We will discuss these in class this coming week, but here's a preview. Programming methodology is a very important component of this course, and you will be required to follow these ideas, so the earlier you get into the habit of using them, the better.

When writing programs, there are lots of things we need to think about. It helps if we have some guidelines to follow that remind us to do these things in the proper order. While following some strict rules can seem annoying at first, in the end it will save you lots of errors and grief. These guidelines will be our design recipes.

Working with unstructured data, like the integers or booleans that we've seen, is relatively simple:

Write the function's contract, purpose, and header.

The contract specifies the function name and what kind of values the function will use as input and output. The purpose is a short statement describing what (not how) the function will calculate. The header is the part of the function definition specifying the function and parameter names.

Type these in the definition window. Put the contract and purpose in comments. E.g.,
```
     ; owe : nonneg-num -> nonneg-num
     ; Purpose: owe returns how much money you owe for the given number of
     ; pizza slices.
     (define (owe slices) ...)
     
```
or
```
     #|
       owe : nonneg-num -> nonneg-num
       Purpose: owe returns how much money you owe for the given number of
       pizza slices.
     |#
     (define (owe slices) ...)
     
```
Make some examples of what the function should do. You need to make sure you understand what the function is supposed to do before you define it. When applicable, use some of the example data.

Put these in comments also, e.g.,
```
     #|
     (owe 0)    0
     (owe 10)  15
     |#
     
```
or, if you want it to print out:
```
     "owes examples:"
     (owe 0)  0
     [etc...]
     
```
Helpful hint: you can actually type (= (owe 0) 0) (= (owe 10) 15) if you like. We'll explain the output after explaining = in class.
Write the function body.

For programs on "unstructured" data like numbers, this is very straightforward, because we are typically given an equation, e.g.,
```
     (define (owe slices)
        (* (/ 12 8) slices))
     
```
For sets of intervals or other conditional functions, there should be exactly one condition clause per option.
Test the function. Make sure the previous examples really work.

If you wrote the tests as suggested above, you can test them by uncommenting them, and executing the program again. You'll see the results of the tests together with the expected answers. If your program doesn't work, either fix it now or put that in comments too, to remind yourself to fix it later, and to let your grader/boss/customer/whomever know also.

Later, we will have additional design recipes for more complicated data and program styles.

Using the design recipe
Follow these steps to define a function calculating the area of a circle, as discussed in class.

Using the design recipe
Follow these steps to define a function calculating the area of a circle, as discussed in class.

Other Basics

These things probably won't be covered in lab. Make sure you're familiar with

email,
a Web browser (to access the course Web pages), and
an electronic newsgroup reader (to access the course newsgroup).

We assume that you already know how to use email and a Web browser. If you have any trouble, ask a labbie during office hours, or contact the staff of the information desk in Mudd.

Newsgroups are electronic bulletin boards where everybody can post and read articles on certain topics. There is a newsgroup specifically for this course, rice.owlnews.comp210. You should read the newsgroup every day, as helpful hints and clarifications are posted there regularly. Also, if you have a question relating to the course, post it to the newsgroup. Similarly if you have an answer for somebody else's question!

In newsgroups, the idea is that once you've read a message, you probably don't ever want to see it again. So your newsreader "marks" an article as read, and next time you read news it only presents you with unmarked articles. (You also have options such as unmarking read articles or looking at all articles.) Most newsgroup-reading programs also group articles by thread, i.e., grouping articles with any replies. A common problem is to "lose" a message by reading it and then not marking it as unread. There are many different news-reading programs you can choose from. Two leading contenders are Netscape and Pine, each of which makes reading news analagous to their way of reading email.
[trouble accessing newsgroup?]

Always "log out" from your UNIX account when you are done and leaving. Otherwise, someone can use your account, e.g., to copy or delete your assignments. One way is to type logout in the "console window" which is labeled. You do not need to exit any other programs first, but be sure to save any important changes first.