>
>    puts "The number of tokens is: %d." % File.open(ARGV[0]){|f|
>    f.inject(0){|a,l| a+l.split.length } } ,
>       "It took #{(Time.now - start) * 1000} ms"
> I find it intellectually stimulating and admirable at the power of what
> is accomplished in such a short statement.
>
> Understanding it however takes time and thought - and a certain level of
> skill.
>
> Perhaps your experiences are different - but most development teams have
> a lot of more junior and intermediate developers than senior - and the
> more verbose, easy to read, simple to understand code is far more
> preferable - even for myself when I must review, debug and profile the
> code of dozens of others - as opposed to something that looks like an
> academic puzzle to unravel.
>

Hello, Ben,
I apologize if my solution turns you off to Ruby (because of the joy, and
excitement you'll miss ;) Ruby is supportive of many paradigms, and so I
adapt my code to my preference. I also write my Java like this, as much as
the language allows. Certainly you can write code which is much more
straightforward than mine. Due to the way I read my code later, I like to
get as much accomplished in as little room as possible (I'm perfectly happy
to let it run off the end of the screen), and then supply a comment telling
me what it does, and if it is esoteric, explaining how it does this. This
allows me very quickly quantify chunks of code, and narrow my attention to
only the relevant portions. If those portions are complex, my comment helps
me quickly figure it out. If your junior developers read code differently,
then perhaps a less terse style would be more fitting. Ruby also adapts
itself very well to legibility, if you choose to write it that way (in
Rails, people often remark that the code documents itself).

Choosing the right tool for the job is a relevant cliche here, and it sounds
like your job, being so performance oriented, requires a tool well suited to
meet these performance needs. If that need is so pressing that you've had to
replace Java with C, then Ruby is probably not the tool you need. You can do
things in Ruby that will make your head spin (these simple examples do not
even hint at the power Ruby grants you), but that doesn't make it the right
tool for this job. If Java is better suited to your needs for this project,
then that would certainly be the responsible choice.

However, I'd encourage you to keep evaluating the language, even if it is
not the best choice for this particular project, because it can take a
little time to figure out 'the Ruby way'. And as Pharrington pointed out
"Different languages express solutions to different problems in
different ways". I think that once you play with it to the point of comfort,
then you should see how Ruby addresses various patterns, (consider
http://www.amazon.com/Design-Patterns-Ruby-Addison-Wesley-Professional/dp/0321490452),
you may begin to feel that same love some of us here do. And then, I suspect
that instead of seeing how well Ruby can pretend to be Java, you'll find
yourself wondering if Java can't be a bit more like Ruby. Perhaps at that
time, a solution like JRuby would look very desirable. Also, great strides
are being made in regards to speed, which would significantly alleviate the
most relevant objection.

Anyway, regardless of your choice, thank you for taking the time to educate
yourself about Ruby.