Scheme Resources:

Manuals:

• The DrRacket reference manual is a great place to check on the syntax/usage of many functions. As a student, I often used the index of such a manual to quickly learn a bunch of potentially useful functions and syntax, just by browsing and looking up likely/interesting names.
• There is also a neat section on debugging in the DrRacket manual that you might want to check out. The Trace function described below, for example, is documented there.
• A Scheme Tutorial, organized like a manual...walks you through all the basics, explaining each with examples.
• There is a very convenient quick reference "Cheat Sheet" for Scheme that summarizes the important functions and facts about Scheme...very handy for learners until you massage the basics into your brain!
• As an alternate/additional resource, you can consult the original MIT Scheme Reference Manual on-line. This version of Scheme is slightly different than DrScheme/Racket, but only in minor ways -- mainly Racket implements all of MIT Scheme...and then extends it with a bunch of stuff. In some ways I find this manual somewhat easier to read than the DrRacket one...but it's your call, all just good resources to have access to.
• Also available is a PDF of the Scheme Manual (version 7.7) for those who like to print things out on paper or have a local copy.

Books:

There are also numerous books on Scheme available, as this language is often used in intro to computer science courses (e.g. at MIT). A textbook may give you a more complete understanding of the language than reading the manual. A decent one is "Scheme and the Art of Programming" by Springer and Friedman. --- but there must be dozens of other alternatives. Check the library.

DEBUGGING:

One of the hardest things as you learn to think recursively is to *visualize* what's happening in the recursive call stack, i.e., what's calling what, and what the arguments are to each call. You can fall back of putting in print statements (or (display "msg") statements in Scheme), and I do agree that this works as well as it does anywhere. But there are a couple of modern tools you might want to add to your repetoire:

Use the DrRacket debugger. As of DrRacket version 5.3, the debugger in the DrRacket IDE isn't half bad...way better than early attempts. Just click on "debug" (instead of Run) as you go to execute your code file, and watch the debugger window pop up. It's basically just like your usual interactive scheme window, except that you can type commands and the step through their execution, one step and a time, and even set breakpoints. Each time it stops, it shows the current value of known parameters and variables. If you just hit "Go" and let 'er rip, it will show you the value of params and variables at the time it crashes. Very useful.

Use the Scheme built-in Trace facility. The debugger can be nice, but it sort of just gives you snapshots of execution state. If you want to give yourself a nice mental picture of what's going on in recursive execution, use Scheme's "trace" facility. You remember those diagrams I drew in class showing how a recursive call proceeds, first recursing down to a base case, then bubbling/building the return value back up the call stack? Well, trace does this automatically...and a lot nicer than a human. Here is a detailed intro on how to utilize trace effectively.