Don't let the title fool you. On the whole, I love Ruby. But, like any programming language, there are some things about it that really bug me.

Ruby is slow.

With very few exceptions, it has been my experience that Ruby is just
plain slow when compared to other interpreted languages like PHP,
Perl, and Java. There are plenty of reasons for this, but it's not hard
to find places where performance could be improved just by poking through
the source code of the Ruby interpreter for a few minutes. That's not very comforting.

Hopefully the eventual move to YARV
will improve things, but that brings me to my next point...

Ruby's development process is slow.

By which I mean that the development of the Ruby language itself is slow,
not that developing software using Ruby is a slow process (it isn't).

Ruby's development status is hard to get a handle on because there
doesn't seem to be any single source of reliable information other than
Matz himself. The fact that I don't speak Japanese makes it even more
difficult, because many of the core Ruby developers don't speak or write
in English.

Not that the communication issues really matter, because not much ever really seems to
happen with Ruby. Sometimes six months or even a year will go by between
minor releases. That can be very frustrating.

Ruby's "official" documentation is sparse and, in some cases, nonexistent.

Learning the basics of Ruby isn't very hard; there are plenty of
beginner's guides out there, including the brilliant
Why's (Poignant) Guide to
Ruby, but once you get past the basics and want to really get your
hands dirty, you're going to find yourself doing a lot of Google searches
and coming up empty a lot of the time.

Ruby (and most other programming languages) could learn a lot from PHP in
this respect. The PHP documentation isn't by any means perfect, but it's
organized in a sensible way and the user comments often provide valuable
clarifications or examples when the documentation itself falls short.

Ruby's official docs don't seem to
have been written with much care. The latest revisions have even
inexplicably removed all documentation for the
Kernel
object, which contains some of Ruby's most important and frequently-used
features. I emailed the maintainer about this several weeks ago and even
got a response, but they have yet to do anything about the problem.

Screw the Ruby Way, sometimes I just want to get things done.

Spend any time using Ruby and you'll hear a lot about the Ruby Way.
People love to talk about Ruby as if it's a religion rather than
a programming language. The term refers
to Ruby's general philosophy of simplicity, elegance, and adherence to the
Principle of
Least Surprise.

On the surface this seems like a good thing, and it really should be, but
the truth is that the Ruby Way is different depending on who you ask. And
since Ruby programmers can't stand the idea of implementing something in
any way other than the Ruby Way, they'll often end up spending days, months
or years talking about the best way to implement something without
ever actually implementing it. Spend five minutes trying to find actual
solid information in the RubyGarden wiki
and you'll see what I mean.

Ruby has shitty XML support.

There are two reasons for this. The first is that the Ruby crowd seems to
have a beef with XML. They'd much rather force you to use YAML,
even though there are plenty of situations in which YAML is absolutely
the wrong tool for the job.

The second reason for Ruby's shitty XML support is that nobody can agree
on the Ruby Way to implement XML support. So we're stuck with
REXML, a
slow, buggy, incomplete XML processor that provides an API
that bears no similarity to the XML API of any other programming language. Most languages provide out-of-the-box support for the DOM API and perhaps one or two other standard APIs, but not Ruby. You either use REXML or you use (or write) a third-party extension and make your application less portable.

My hatred of REXML is a personal matter, obviously, and there are plenty
of people who like it, but the problem is that there aren't alternatives.
At least, not as far as Ruby's standard libraries are concerned. And I
hate that, because as much as I like YAML, I often prefer to use XML, and
using XML in Ruby is a pain in the ass, so I generally end up using PHP instead.