From: jeff@aiai.edinburgh.ac.UK (Jeff Dalton)
Subject: Re: wots going on here!?
Organization: The Internet
Date: Tue, 1 Sep 1992 12:18:08 GMT

First, I'd agree that a number of Lisp systems do something that is
too complex and confusing when an error occurs -- especially for
people learning the language, but often even for experienced
programmers.  I'd also agree that error messages are sometimes
absurdly obscure.

But this just isn't true for all Lisps.

I don't know which Lisps Brian Harvey has used, but they don't sound
like the ones I've been using.

> Date: 31 Aug 1992 16:51:43 GMT
> From: Brian Harvey <bh@anarres.cs.berkeley.edu>
> 
> jeff@aiai.edinburgh.ac.UK (Jeff Dalton) writes:
> >However, I think it's important for the break look (debugger) to be
> >as much like the top level as possible.  In particular, it should
> >work to type expressions in the usual way.  Popping back one level
> >should be easy, such as typing a single character.
> 
> I think the last two sentences of that paragraph contradict each other.
> Either the debugging language is Scheme, or it's something else.  If
> it's Scheme, there aren't any "hot key" characters.  If it isn't Scheme,
> then it's another language you have to learn, at the same time that you're
> having enough trouble learning Scheme.

Brian, I don't know whather you've never seen the kind of Lisp I'm
talking about or whether you think details like whether ^d does
something are ultra-important.

If you don't want to use the debugger, it doesn't matter what the
debugging language is.  What matters is that you don't end up in
some mystery mode after an error.  In many Lisps, what you end up
in is a loop that's just like the top level except that some 
(additional) commands have useful effects.  The user doesn't 
have to know about these commands or what their syntax is or
anything.  The only _extra_ thing the user has to know is how
to get back to the real top-level.  And in some cases, you don't
even need to know that.  For instance, in KCL the normal behavior
is to enter a break loop only if you're not already in one.
Beginning users can stay in the first break loop forever if
they want.

In every Lisp I've used, there are always some "hot keys".  For
instance, you can type the interrupt character (usually ^c) and
eof (usually ^d or ^z).  There is no need for any additional
hot keys, because <eof> can be used to exit a break loop.

> My experience as a teacher is that it's really hard to enable students
> to think about Scheme intellectual issues for the first week or two,
> because they have to learn *so many* languages:
> 
>         - Scheme
>         - EMACS
>         - shell
>         - Annex terminal concentrator
> 
> Perhaps with all that baggage to deal with it's foolish for me to draw
> the line at adding "Scheme debugger" to the list.  But I still think
> that one's worse than the others because it's part of the same context.
> I mean, you have to ASK to get from the shell to Scheme, and vice versa.
> But finding yourself in the debugger is something that happens to you.

I've used lots of different Common Lisps w/o knowing anything about
their debuggers.  I don't even have to know how they want me to exit a
break loop because, thought the wonders of Emacs and ilisp, it can be
the same in all of them.  In most cases, it doesn't even look like
I'm "in a debugger" after an error.  It looks like I'm in a loop
just like the top level.

Of course, you may think that even this sort of loop is too much for
beginning students, but I hope you don't think it's completely
unreasonable of me to disagree.

-- jd