(bear with me if you want; this is a personal informal kind of case study =)
Yesterday, I got the idea that I would like to get back into finishing 
Bonkle, a game like the board game Bo**le, e.g.

Trying Bonkle::Board#to_s... 
+---+---+---+---+
| P | T | O | B |
+---+---+---+---+
| O | E | E | H |
+---+---+---+---+
| L | O | E | G |
+---+---+---+---+
| E | S | R | Z |
+---+---+---+---+

I started it last year and let it go for a while because I decided I wanted 
to finish it into a full-fledged, networked game with a server and unlimited 
clients.  Starting this evening, I spent about four hours with a vague 
design of how I wanted to do it.  In fact, I changed completely my idea on 
how I'd do it three times during the implementation.  However, I kept going 
and shuffled things around a bit when they seemed they needed to be to form 
a vague architecture of:

Bonkle
 \-- RandomDice  \
  -- Board        +
   \-- Internal
  -- Dict
  -- Server +                                   # here and below new stuff
   \-- User  +
  -- Game     \
  -- Message

If that diagram makes sense, I think that's the best way to show that I have 
a Board object which contains RandomDice (and can reset/"shake" itself), a 
Game which contains game state, the dictionary word lookup, the Server which 
acts as an asynchronous "gamesmaster" that spawns User threads that each 
handle a user and communicate with the Game backend.

The architecture, I am pleased to say, seemed to simply flow together because
the simple genius of Ruby is exemplified here.  I can do rapid prototyping 
because I don't have to spend the entire time doing difficult code 
relocation -- if I feel something should go somewhere else, I can merely cut 
and reformat the code and make no real changes, and it will work just as 
well anywhere else in the program.

The upshot of the simplicity of threading, beauty of syntax, and huge base 
library is that it made it simple to spend four hours, build a backend into 
a threaded game server, and then (here's the real beauty): I only had to 
spend about 10 minutes debugging after implementing the deal and not having 
tested at all until then before I had everything major working and a bit 
longer to hunt the couple difficult typos that were left over.

Thank you, Matz, and also everyone else who helps to make Ruby what it is today 
for making a language so elegant that I can be as productive as 10% maximum 
time spent debugging!  For people who are interested in seeing my example
-in-progress of sheer productivity of this great language, try Bonkle 0.4 at:

	http://people.FreeBSD.org/~green/bonkle-0.4.tar.gz

(note right now it's mostly meant to be used inside irb, and tab indentation is 
 meant to be set to 4 spaces)

Comments/questions welcome, but what I'd really love to hear is about other 
near-miraculous cases of Ruby success!

-- 
 Brian Fundakowski Feldman           \  FreeBSD: The Power to Serve!  /
 green / FreeBSD.org                    `------------------------------'