Ruby

The Rails team has released version 2.3 of its popular and ground-breaking web application framework for Ruby.

Features:

• Support for Ruby 1.9.1. Caveat: not all the data adapters and plug-ins have moved to Ruby 1.9 yet, so migrator beware.
• Templates: customize your default Rails skeleton with your favorite set of plug-ins, gems, initializers, etc.
• Full Rack integration. CGI is now a thing of the (proxied) past.
• ActiveRecord gets support for nested attributes, nested transactions, batch processing (find_in_batches), dynamic scopes, and more.
• Action Controller gets smarter rendering, a file rename (application.rb to application_controller.rb), HTTP Digest Authentication Support, more efficient routing, and more.
• Introduced Rails Metal, a way of bypassing the controller for speed (it is a subset of Rack middleware).
• Renewed support for Rails Engines allows the sharing of re-usable application components.
• Support for nested forms.

A full list of all the changes in 2.3.2 (the final version of 2.3) is here.

As usual, you can install via Gems: gem install rails

The first stable build of Ruby 1.9.1 has been released. Ruby 1.9 represents some significant changes over 1.8, including internationalization support, many syntactic changes to the language, and new features such as fibers.

A list of changes is here.

This release also has significant impact on alternative implementations of Ruby as well. As Charles Nutter noted in the thread following the release announcement:

Congratulations! Now that the stable release is out, we will pull 1.9.1 stdlib into JRuby. We'll ship our 1.9.1-compatible (mostly? hopefully?) release of JRuby 1.2 in late February.

The release packages can be downloaded (files "ruby-1.9.1-p0.*") from the ftp directory here. (Note these packages are not pre-built binaries but source drops that require the appropriate C++ compiler.)

Update: the binary distribution of Ruby-1.9.1 has hit the official download page.

Yesterday the Ruby on Rails team broke the news: the alternative Ruby web application framework, Merb, will be merged into Ruby on Rails 3.0. Merb, which was already closely patterned after Rails, brings performance, modularity, and better integration with alternative JavaScript and ORM frameworks to the table. The default Rails configuration will still be the "full stack" framework, which uses ActiveRecord and Prototype, but there will also be a "Rails Core" with the ability to opt into specific other (e.g. JavaScript or ORM) frameworks as desired.

You can read the announcements by DHH here and Yahuda Katz here.

The web application framework that broke the mold (and made Ruby famous in the process) has released version 2.2.

Key features in the update include:

• Ruby 1.9 compatibility. Among the key features that Ruby 1.9 brings (at least for users of the "main" C-based implementation) is a single native thread for every Ruby thread. Finally. Now Rails applications can run with much less memory consumption and better processor utilization. Will you miss all those extra Mongrel instances? Probably not.
• Thread safety. Important updates to the framework have been made to ensure thread safety. This will be a big boon to JRuby users (who have been dreaming of this for a long time), but C Ruby users will have to wait for certain dependencies to be updated before they can really enjoy its benefits (most notably those--ahem--with large amounts of C code). To enable mutli-threading, add config.threadsafe! to your config/environments/production.rb. (Note, however that this will disable automatic loading by ActiveSupport::Dependencies.) Plan on becoming more familiar with Mutex.
• Internationalization. i18n has been baked into the framework, making localization of your application much easier.
• ActiveRecord now has a proper connection pool.

The release notes are here.

Rails 2.2 now requires RubyGems 1.3.1, so you'll want to make sure to update it (gem update --system) first. To install the new version, do something like the following:

gem install rails
rake rails:update

Arun Gupta from Sun also gives a nice overview of how to run Rails 2.2 on GlassFish v3 Prelude and JRuby 1.1.5.

In the tradition of "Release early, release often", the Netbeans team has released version 6.5, continuing the rapid release cycle the project set with 5.5, 6.0, and 6.1. There many new features, most notably support for Groovy /Grails and PHP. Here's a short list of the other "new and notables":

• A new "Compile and Deploy on Save" feature for Java applications.
• Support for the Nimbus look and feel in the Swing GUI builder (Matisse)
• Big improvements in the JavaScript support, particularly in the area of debugging.
• Support for Ruby on Rails 2.1 (JRuby 1.1.4 is bundled)
• Improved SQL support, including SQL history and editor auto-completion.

There is also an early access release of Python support in Netbeans that is available as a separate download.

Get Netbeans 6.5 here.

After two years of development, the first serious contender to challenge Ruby on Rails in the area of Ruby web application frameworks has reached 1.0 status: Merb. Created by Ezra Zugmuntowicz, Merb is built to be lightweight, less monolithic than Rails--i.e., you have your own choice of ORM, JavaScript, and templating frameworks--as well as thread-safe (which Rails, prior to the upcoming version 2.2 at least, was not).

You can get the gem from RubyForge with (something like) the following :

$ sudo gem install merb --include-dependencies


(Alternative site: —source http://edge.merbivore.com)

You can then generate your first Merb project and run it with the following:

$ merb-gen app my_application
$ cd my_application
$ merb


Then, of course, you'll want to read the documentation.

The JRuby project, an implementation of the Ruby language on the JVM, has released version 1.1.4. Though a minor (maintenance) release, the new version introduces a number of improvements, including:

• A substantially re-written Ruby-Java integration layer.
• Big improvements in performance: about 2-20x.
• Reduction of garbage collection cycles (efficient memory usage).
• Experimental support for Ruby 1.9 (via the --1/9 flag)
• Started support for the win32 API
• Ported Rubinius' FFI subsystem for integrating with C libraries
• Addition of OSGi metadata to the jruby.jar
• Lots of bug fixes (72 issues resolved since version 1.1.3)

The full release notes are here.

You can download the new version here.

Tucked inside the somewhat innocuous announcement that a new committer has joined the Rails core team (Josh Peek, who had worked on Rails via the Google Summer of Code) was the surprising revelation that Ruby on Rails 2.2 will be thread safe. Even more surprising was the statement:

The actual thread safety won’t really matter much to most people, but it’ll surely look nice on your enterprisey check list of Features Your Framework Must Have To Get Play Around Here.

Huh? Thread safety not important? As much as I sometimes feel nostalgic about 1990's CGI programming (ah, signing bonuses...*sniff*), statements like that are just plain embarassing, and don't do much to promote Ruby or Ruby on Rails. And before anyone counters that stable versions of Ruby still don't use native (kernel) threads, think again: JRuby does. It may well turn out that JRuby + RoR 2.2 will be the the power combo for Ruby developers in 2008 and beyond...those that are serious about concurrency, at least.

Actually, the title should be "The Next Great Mid-Level Language", but doesn't sound quite as snappy...

There has been a lot of talk in the last year or two about Java losing ground to newer languages and about which language is going to replace Java as the dominant language going into the next decade. Various factions from the Ruby and Scala camps have weighed in on the debate in earnest, leaving even some die-hard Java programmers wondering if they should be learning a new language (and soon). After all the smoke clears, what should the reasonable person conclude? Is it time to move on?

Recently announced at the Ruby on Rails Weblog, Rails 2.1 has been released.

The new major features are:

• Time zones (by Geoff Buesing): Tutorial | Introdction | Railscast
• Dirty tracking: Introduction (partial updates) | Railscast
• Gem Dependencies: Introduction | Railscast
• Named scope (by Nick Kallen): Introduction | Railscast
• UTC-based migrations: Introduction | Railscast
• Better caching: Introduction

Read More