Getting started with SBCL & Slime:

 1. Install Emacs or XEmacs. 

 2. Install the latest released version of SBCL.

 3. Get the current CVS HEAD for Slime, under eg. ~/elisp/slime/.

 4. Add the following to your ~/.emacs:

     (add-to-list 'load-path "~/elisp/slime")
     (require 'slime)
     (setq inferior-lisp-program "sbcl")
     (setq slime-net-coding-system 'utf-8-unix)
     (slime-setup)

 5. Start Emacs.

 6. If you are unfamiliar with Emacs, press "Control" and "h" keys at
 the same time, release both, then press "t". If you already know
 Emacs basics, go to step 7.

 You will be taken to the Emacs tutorial: follow the instructions
 on the screen.

 If you ever get frustrated with Emacs remember that almost everything
 is also accessible from the menus, and that there is no need to learn
 everything at once.

 7. Use the command "M-x slime" to start things upo. The first time
 you run Slime it will take a while when everything gets compiled, so
 be patient. Eventually a buffer will open, and you should be
 looking at a prompt looking like this:

  CL-USER> 

 T

 Type "(+ 1 2)" (without the double quotes) and press enter.
 Voilà! Your buffer should now look like this:

  CL-USER> (+ 1 2)
  3
  CL-USER>


 8. Use the command "C-x C-f ~/scratch.lisp" to open a file to work
 in. You can use a different file if you wish, but do use the ".lisp"
 suffix: without it Emacs will not know that your file should be
 edited using the lisp-mode and Slime.
    
 9. Enter the following definition in the new buffer that opens
 up:

  (defparameter *hello-counter* 0)

 Now, use the command "C-x C-e" (slime-eval-last-expression) while the
 point is after the closing paren to evaluate it. Notice the text "=>
 *HELLO-COUNTER*" in the minibuffer. Whenever you evaluate anything
 with slime-eval-last-expression the value it evaluates to appears in
 the minibuffer. Let's test that. Type the following expression in the
 buffer:

  (+ *hello-counter* 1)

 Now use the command "C-x C-e" to evaluate that. "=> 1" should appear in
 the minibuffer.

 10. Type the following in the buffer, and evaluate it with "C-x C-e".

  (/ 1 *hello-counter*)

 Whoa! What happened?! You tried to divide one by zero, and a debugger
 looking approximately like this popped up:

  arithmetic error DIVISION-BY-ZERO signalled
  Operation was SB-KERNEL::DIVISION, operands (1 0).
     [Condition of type DIVISION-BY-ZERO]

  Restarts:
    0: [ABORT-REQUEST] Abort handling SLIME request.
    1: [ABORT] Exit debugger, returning to top level.

  Backtrace:
    0: (SB-KERNEL::INTEGER-/-INTEGER 1 0)
    1: (/ 1)
    2: (SB-INT:SIMPLE-EVAL-IN-LEXENV (/ 1 *HELLO-COUNTER*) #<NULL-LEXENV>)
    3: ((LAMBDA NIL))
    4: ((LAMBDA (SWANK-BACKEND::FN)) #<CLOSURE (LAMBDA NIL) {B52DDED}>)
  --more--

 Later on, once you have more experience under your belt you can use the debugger
 to figure out what went wrong, and even fix it. For now, you need to know how to
 read the error message and get out of the debugger.

 The topmost lines of the debugger buffer show the error message,
 which should be pretty self-evident in this case. The 'restarts'
 listed after it are points of recovery that you can select -- in this
 case the both listed restarts are essentially the same. You can
 either select a restart by entering the corresponding number, or just
 type "q", which will always select the "ABORT-REQUEST" restart.

 The backtrace that appears at the bottom is the stack trace of from
 the point where the error occurred, but never mind that now. If you
 didn't do it yet, press "q" to exit the debugger -- just remeber that
 later on if you land in the debugger by accident you can always exit
 it by pressing "q".

 11. That covers the basics of basics. Read the Slime manual for more
 information: ~/elisp/slime/doc contains the manual sources, which
 you can build by entering the shell command "make" in that directory.

 For more on Common Lisp in general, read a good book, like "Practical
 Common Lisp" by Peter Seibel (Apress), available at

   http://www.gigamonkeys.com/book/

 Good luck!