I use RVM with gemsets and Bundler to manage my Ruby environment and dependencies.  Some people question that.  "Isn't RVM over-complicated?" they say. Or, "why are you using gemsets when you have bundler?" There are even some ethical objections: "I don't like how RVM overrides shell commands!"

Allow me to address these questions, starting with the easy one: RVM overrides shell commands, mainly the cd command so that it can detect environment files when we change directories. So what!? It just works and unless you're some kind of Shell Puritan that's all you should care about.  Besides, many other apps and utilities use all kinds of shims and proxies and no-one bats an eyelid. Get over it!

But what about complexity? Installing RVM involves a single command, two if you include downloading the gpg key. The vast majority of the RVM commands that I use daily are just a combination of the words use, gemset and create with a couple of list and install thrown in for good measure. Pretty simple really.

Finally, why use gemsets? Surely, with Bundler there is no need to use gemsets any more, is there? Well, from a deployment point of view, this is correct. We can just deploy our Gemfile and Gemfile.lock and Bundler will ensure that the right versions of our gems are installed. Furthermore, Bundler can also tell us whether our gems are outdated or if we can upgrade the version of a specific gem without breaking others and other such wonderful stuff.  However, from a development POV using gemsets is the cleanest and safest way to manage our environment. Consider a non-gemset set-up:

​s = ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '!']
  => ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '!']
world = proc {|x | x.slice(5, 10)}
world[s]
 => ["w", "o", "r", "l", "d", "!"]

​so we can do things like:

first = proc { |x| x.slice(0) }
first[s]
=> "h"

or even things that we can't do with Python's named slicing, since it doesn't allow us to pass the receiver as an argument to the block (x in our case)

last = proc {|x| x.slice x.length-1, x.length}
last[%w(dog rabbit fox cat)]
=> ["cat"]

or

median = proc {|x| x.slice(x.length / 2) }
median[%w(dog rabbit cat)]
=> "rabbit"

and of course we're not just restricted to slicing arrays,

domain_extractor = proc { |x| x.gsub(/.+@([^.]+).+/, '\1') }
domain_extractor["joe@bootstrap.co.uk"]
=> "bootstrap"
​
and since it's a proc,  we can use it with any method that accepts procs and blocks
​
email_list = ["fred@bootstrap.me.uk", "john@gmail.com", "mary@yahoo.co.uk"]
=> ["joe@bootstrap.co.uk", "john@gmail.com", "mary@yahoo.co.uk"]
email_list.map(&domain_extractor)
=> ["bootstrap", "gmail", "yahoo"]

Proc objects can be wonderful for some quick , reusable functionality or for when defining a method would be too much, as well as for more serious uses such as callbacks. If you use them regularly, l'd love to know your use-cases and hints & tips! 

Most of us use Resque and the Resque or Rufus schedulers to schedule tasks in an effective, controlled manner. However, we sometimes need to schedule jobs on machines that don't have a queue installed. We then have to fall back on good ol' raw Cron scheduling. The problem here is that Cron jobs usually run under the root user's environment, which means that the RVM environment variables necessary for running our Ruby script aren't being loaded, so the Cron job will fail.  

The solution is to explicitly load the RVM environment in the cron user's context, before we can invoke our Ruby code. Luckily, RVM provides environment files for each configuration, that we can use to load the right context. These files are essentially a list of exported env variables that point to the right locations for the selected Ruby and gemsets.

1.   Find the RVM environment file for your ruby version and gemset. You can do so by running:

Jared Friedman, founder of Scribd, recently wrote a blog post titled "Why I wouldn’t use Rails for a new company".  In it, he makes three points as to why Rails is 'past it' and why new start-ups should look to some other framework or language for their products:

1. Rails isn't the hottest thing any more.
2. Other frameworks have caught up with Rails. Rails is static.
3. Ruby is slow

He then draws on these points to make a startling conclusion:
"If you want to future-proof your web application, you have to make a bet on what engineers will want to use in three years. That’s more important than what framework lets you be most productive right now."


The myth of 'hotness'
Points 1 and 2 are unarguably correct. Rails isn't hot any more and is not evolving at the pace it used to be.  But this isn't a bad thing. It's a sign that Rails has matured, it's now an adult framework and not the spotty teenager who grows taller by an inch every month.  Its growing pains are behind it, the rough spots have been ironed out and all Rails needs to do now is position itself in a changing technological environment. With Rails 5 it seems this process has already begun. That's partly what maturity is about: the ability to assess a changing scenery and see your place within it. Not playing catch up with the Joneses. Let's leave that to all the other frameworks which have been 'inspired' by Rails over the years. This is by itself a testament to the success and influence of the framework.  As the saying goes: 
"Imitation is the sincerest form of flattery."

The myth of 'speed'
Ruby is slow. I know it, you know it, the world knows it. The question is : 'Does it matter?'

Let me tell you a secret. I was around in 1996, in my first job as a C++ engineer (yes, I'm that old).  It was when Java first came out. I was one of the many C++ developers who had a good laugh about it.  'It will never catch on', we said, 'it's just sooo slow!'.

And it was. This was Java release 1, way before the JIT optimisations and the HotSpot. It was an order of magnitude slower than anything we built in C++. Even today, after all the Java performance improvements, C++ natively-optimized code is still faster than its Java counterpart. Did that stop Java from becoming, arguably, the most popular language on the planet? Nope.  Did that stop Java from replacing C++ as the language of choice for enterprise back-end and desktop applications? Nope.  

So why didn't Java's lack of speed  stop it from spreading like a virus? The answer is simply: 'context'. In the context where Java apps were being used, Java's slow performance didn't make a difference. Think about it, the average HTTP request takes about 0.5 secs.  Many database transaction times are measured in seconds (PS: you should optimise these, BTW).  Why would I put in the time and effort to re-write my 250ms Java applet to a more performant 50ms C++ DLL, when it will make no difference at all to the end result?  Oh, and also did I mention that my Java code would crash half as often as my C++ equivalent? (no explicit memory management mistakes, see)


So what about when you needed that extra performance boost or this explicit memory management in your app?  Well, then you just didn't use Java, you used C++. As simple as that. Ease-of-use, productivity and safety are usually valued over app performance. As someone famous (I forget who) once said: "Developer cycles cost more than processor cycles".


Now replace 'Java' with 'Ruby' in the above paragraphs and 'C++' with <your-choice-of-fast-language> and you'll see that the principle still stands. Ruby is a wonderfully expressive, flexible and highly-productive language (much more so than Java ever was). That's why you should be using it in your start-up. Ruby gets out of your way and lets you be creative. Rails is a tried-and-tested framework that's proved itself in the field. Yes it has its bad points- too much magic and some un-OO practices- but as a start-up you want to put your product out there as quickly and efficiently as  possible and there are few better tools than Rails to help you achieve that. 


Epilogue
If your main worry is about what engineers are likely to be using in three years time, instead of the best way to make your product available to your customers, then chances are you'll be joining the 90% of start-ups that fail within their first year.  If you don't want to go down that route then use Rails to maximise your chances.