Rubinius X, an experiment in modernizing Ruby (opens in new tab)

It is, at least, about making Ruby more concurrent. Rubinius eliminates the global interpreter lock, which helps, but Ruby's execution model is still very much thread-oriented; Ruby's fibers are very slow, and are not good enough for Node-style concurrency.

It is also about wiping the slate clean. Ruby still has some ugly stuff inherited from Perl (globals for regex results, or the use of unreadable "magical" globals such as $:). There are many areas where years of experience can help us design a better language.

Most of us rubyists aren't actually "hipster broprogrammers", but hard-working devs who like to get things done -- just like everyone else. It's unfortunate that the Ruby world is being painted with that kind of brush, when it's really down to just a few bad apples.

You're probably not serious, but for the OP this was the reason to start Rubunius X, as you can see here: http://rubini.us/2013/10/15/introducing-rubinius-x/

discussion: https://news.ycombinator.com/item?id=6553767

Personally I believe in "the best tool for the job".

It's not really extreme. You can, and should, easily provide globals through attributes on classes and modules (which are globals themselves):

    module Foot
      @size = 10
      class << self
        attr_accessor :size
      end
    end

    Foot.size = 8

ActiveSupport gives you "mattr_accessor" and "class_attribute" to accomplish the same thing with less code.

In my opinion, class/module-level attributes are useful enough that it ought to be provided by the language itself.

Edit: Come to think of it, most people, that I have seen, use globals to set constants. That currently has perfectly good syntax:

    module Foot
      SIZE = 10
    end

    print Foot::SIZE

As far as I can see, this is all Brian Shirai (aka brixen), who is the current maintainer of Rubinius.

It's not the point to fork, but to experiment and see which features are worth porting back into Ruby core.

I think it's great.

Because that's what Rubinius non-X is for. This is about an experimental Ruby-based language that has the freedom to make breaking changes. It's not just another implementation of Ruby, it's about creating a new language that learns from Ruby and other languages. I expect that we'll see some of these ideas percolate back to Ruby proper, and others will be created and/or wither on their merits within Rubinius X, so long as it remains experimental.

All that said, this simplifies the language spec and implementation by eliminating features that have long been on-the-outs in the Ruby community. Note that the proposals on that page don't break regexes, they just break code that uses the old Perl-esque $1, etc. magic variables. This is almost mechanically trivial to port to use Regexp methods, MatchData, etc. IME, it's rare to see this used in Ruby code in the wild. I find it kind of startling when it does show up.