I just started looking at Ruby (reading Dave Thomas' book), and I'm puzzled 
as to why you have both rescue/raise  and catch/throw. I can't see what the 
distinction is, other than somewhat different syntax. Are they used for 
different purposes?

Also, I note with some disappointment that Ruby doesn't seem to have 
"resume" semantics on its exceptions like Smalltalk does. I'm coming to 
Ruby from Smalltalk and Perl, and though Ruby's exceptions are obviously 
much better than Perl's, they don't seem to offer some of the strengths of 
Smalltalk's.

One of the reasons that resume semantics are interesting in Smalltalk is 
that you can (for instance) pop up a debugger on an exception, interact 
with the system, and then resume execution of the program.

I guess that Ruby isn't yet aimed at the kind of long-running and 
interactive systems that Smalltalk excels at. For instance, I used to write 
factory machine control software in Smalltalk. Without stopping the 
machine, we could load new versions of methods into the system, stop 
threads, debug them, and resume them, and otherwise maintain the system 
without bringing it down.

Does Ruby offer this ability? It seems that the debugger hooks are in an 
inconvenient place (via a command-line option); does this mean that one 
cannot debug a running system that has not been started with the debug 
flag? I realize that you could have a thread in which you could do evals, 
but can you (for instance) pause a running thread, step through it a bit, 
and then resume it?