Don't Panic!

• Advantages:
  • Very little setup required
• Disadvantages:
  • Requires internet connection or physical presence at an Athena cluster.

Log in to your MIT Athena account. If you're at an Athena cluster, then skip this next step. If you're using your personal machine, then connect via ssh with:

ssh -Y [your_kerberos]@athena.dialup.mit.edu

You can always access Athena by using ssh from any operating system, so you can have the convenience of Athena and the convenience of using your own machine. For Windows, use PuTTY to access Athena. For Macs, you can just use ssh.

Now in your Athena account, to get access to the course's software, execute:

add -f 6.945

Now you have access to MIT/GNU Scheme, which you can run with:

scheme

• Advantages:
  • Use your own computer
  • Easy to set up if the repositories have an up-to-date version of mit-scheme
• Disadvantages:
  • Many distributions do not have up-to-date versions

Use your distribution's package manager to install mit-scheme.

Make sure that the version of mit-scheme is >=10.1.10.

• Advantages:
  • Use your own computer
• Disadvantages:
  • More complicated to set up

Be sure to download the latest version (>=10.1.10).

Note about Mac Support: http://www.gnu.org/software/mit-scheme/ provides a pre-packaged Mac OS X application binary that includes MIT/GNU Scheme and a Mac GUI version of Edwin. Section 2.3.2 describes installation instructions for this binary. Alternatively, if you have the correct tools (XCode, make, etc.), the "Unix Binary" can be downloaded, compiled and installed on Mac with only slight variations of the instructions in Section 2.3.1.

Note about Windows Support: While it is certainly possible to install MIT/GNU Scheme and edwin/emacs on Windows, we don't offer support for those systems. Look into using the Windows subsystem for Linux or a VM.

• edwin
  • entirely written in mit-scheme (you can extend it using stuff you learn in 6.945)
  • offers a better integrated scheme debugger than emacs
  • based on an older version of emacs (version 19) and has not been developed much since.
  • fairly anemic library – edwin is probably not that good a choice for editing python code, for example.
  • no online presence or community
  • Prof. Sussman uses edwin and he can help you with your edwin related problems
• emacs
  • MUCH larger online community than edwin. If you get stuck on something there is likely someone on the internet who has already developed a solution.
  • Vast library of already-written code to customize emacs for almost any usage. org-mode alone is one of the many additional tools that comes with emacs that might make you want to consider it over edwin.
  • Still in active development, so is more "modern" than edwin, including things like Unicode support and integration with almost every language and version control system.
  • uses elisp, a fairly kludgy dialect of lisp, as an extension language
  • not as much integration with mit-scheme than edwin
  • I use emacs and can help you with your problems

Edwin is well suited for learning scheme and has been a traditional part of 6.001 and 6.945 at MIT for decades. If you choose it you'll be using a system that was specifically created to empower you to hack mit-scheme, whether you're a novice or an expert.

If you choose emacs, then you'll be putting in time learning an editor that many expert programmers consider to be the best programming tool in the world. It is likely that you will be able to use emacs for programming projects outside of 6.945, and for many more use cases than writing code in mit-scheme.

We support both editors in 6.945.

If you chose edwin, then you don't really have to do anything – it comes with mit-scheme. You can start edwin with:

mit-scheme --edit

The version of emacs doesn't really matter. After getting access to emacs, run it with:

emacs

Scheme has functions to inspect itself. You can execute apropos on a symbol to find all the bound names in the environment containing that string. For example:

(apropos 'vector)

finds all the bound names with "vector" in their name.

You can also get the source for a function using pp, as in:

(pp +)

What's the source of apropos and pp?

Edwin has a lot less configuration options available than emacs, because there are less library files available. Here are the settings that Sussman uses:

.edwin

They provide firefox-like font resizing and some good default colors.

Emacs has many configuration options. As you use Emacs more and more, your init.el will become more customized to your uses. There are also many packages available through MELPA.

How do you know what sort of things you can do in your editor? For example, how do you figure out that C-M-x will evaluate the scheme form at your cursor if you don't already know that? The answer is to use the following invaluable discovery commands:

C-h m

describes all the key bindings of the current mode you are using. You should read all the key bindings of both the scheme source code mode and the scheme REPL mode so you know what you can do.

C-h k

Each keyboard shortcut in emacs/edwin is bound to a longer, named function. If you know the keyboard-shortcut but don't know the name of the function the shortcut uses, this will tell you the long version if you enter the keyboard shortcut. (Question: what function does C-h k itself call?)

C-h v

This shows you the documentation of any variable and provides a link to the source.

C-h f

This shows you the documentation of any function and provides a link to the source.

C-h l

This displays the last 200 keystrokes you have typed. If you just accidentally did something cool and want to repeat it again, see what you typed with this.

Now seriously, use C-h m and take a look at all the different things you can do in your scheme mode and at the repl.

In edwin or emacs, open a scheme file with:

C-x C-f

and type in the file name. The file should end in ".scm" so that emacs and edwin can recognize that it is a scheme file and provide syntax highlighting and REPL integration.

Then type:

C-x 3

to split the window side-by-side.

To switch from screen to screen, type:

C-x o

In emacs, type:

M-x run-scheme

to start scheme.

You can try using the REPL right now!

Go to the REPL and type:

(fib 5)

And press <enter>.

You will see that you get an error, because the variable fib is not yet defined.

Now go to your scheme file and define fib with

(define (fib n)
  ;; Calculate the nth Fibonacci number recursively
  (if (< n 2)
      1                                 ; base case
      (+ (fib (- n 1)) (fib (- n 2)))))

While the cursor is inside this form, press C-M-x (in emacs) or M-z (edwin) to evaluate the form and send it to the REPL. You can also press C-x C-e to evaluate the form to the left of the point. Now go back to the REPL and enter (fib 5) again and you will see the function you defined in your scheme file evaluated and printed to the screen. This is really cool! If this were a C or Java program you would have to write a small test-harness, re-compile and then run the program again to do what you have just done. As you work on building more complicated programs, you will begin to see the power of this method.

You can always start the debugger at a scheme REPL by evaluating

(debug)

When you do, you will see something like this:

There are 4 subproblems on the stack.

<stuff...>

You are now in the debugger.  Type q to quit, ? for commands.

2 debug>

Try typing ? and familiarizing yourself with the different options.

Let's debug the following scheme function:

(define (factorial n)
  (if (< n 2) 
      1 
      (* n (factorial (dec n)))))

At first glance this seems to be a reasonable definition – we return 1 if we are given 1 as input, otherwise we return n times the factorial of n decremented by 1.

Evaluate this definition and then try to evaluate

(factorial 3)

at the REPL.

You will see:

1 ]=> (factorial 3)

;Unbound variable: dec
;To continue, call RESTART with an option number:
; (RESTART 3) => Specify a value to use instead of dec.
; (RESTART 2) => Define dec to a given value.
; (RESTART 1) => Return to read-eval-print level 1.

2 error>

Whenever an error is encountered during the course of evaluating an expression, mit-scheme puts you into this mode. These options give some limited access to the debugger. You can either choose one of these options, type C-c C-c to exit from the error, or type (debug) to enter the debugger proper.

Here's an example transcript where I fix the problem of dec not actually being defined, and repair the original factorial call while it is still being executed.

2 error> (debug)

There are 8 subproblems on the stack.

Subproblem level: 0 (this is the lowest subproblem level)
Expression (from stack):
    dec
Environment created by the procedure: FACTORIAL

 applied to: (3)
The execution history for this subproblem contains 1 reduction.
You are now in the debugger.  Type q to quit, ? for commands.

Now that we're in the debugger, we can view the chain of procedure calls which led us to this situation.

3 debug> h
h
SL#  Procedure-name          Expression

0    factorial               dec
1                            ;undefined expression
2    factorial               (factorial (dec n))
3    factorial               (* n (factorial (dec n)))
4    %repl-eval              (let ((value (hook/repl-eval s-expression envi ...
5    %repl-eval/write        (hook/repl-write (%repl-eval s-expression envi ...
6                            (begin (if (queue-empty? queue) (let ((environ ...
7    loop                    (loop (bind-abort-restart cmdl (lambda () (wit ...

This is a stack trace like you might know from java or C. Each line in this list is called a subproblem, because scheme works by expanding and evaluating forms until it determines a value. Lines 4-7 are procedures involving the REPL itself. Line 3, (* n (factorial (dec n))), leads to the subproblem of figuring out what (factorial (dec n)) is, which leads to trying to evaluate (dec n) which is where our trouble starts.

We can view all the current bindings in the little environment created by the call to factorial. This is like exploring the values of local variables in any other debugger.

3 debug> a
a
----------------------------------------
Environment created by the procedure: FACTORIAL
Depth (relative to initial environment): 0
 has bindings:

n = 3


----------------------------------------
Environment named: (user)
Depth (relative to initial environment): 1


----------------------------------------
Environment named: ()
Depth (relative to initial environment): 2

This is a very simple environment, with only n, which is set to the value we entered into factorial, 3.

Let's fix the problem – dec isn't defined, but we want it to be equal to the function (lambda (x) (- x 1)). Using P in the debugger we can move out of the environment of factorial and back to the user environment, where we can define dec.

3 debug> p
p
Environment named: (user)
Depth (relative to initial environment): 1

3 debug> v
v

Evaluate expression: (define (dec x) (- x 1))

Value: dec

Now, we re-evaluate the original problematic subproblem and continue the original call to factorial.

3 debug> z
z

Expression to EVALUATE and CONTINUE with ($ to retry): $

;Value: 6

1 ]=>

Note that if you are using edwin, you will be given an option to "start the debugger" in addition to the other options. If you start the debugger in this way, then you will get a very nice looking window that constantly displays many of the things you could otherwise access through the commands you have just been shown. Try it out; it's neat!