Nick Plante

I'm actually one of the authors, so I don't need to win a copy. But thanks!

Although I haven't personally read it, Ola Bini's JRuby on Rails book might be a good start. I actually have a copy but just haven't found the time to dig in!

http://www.apress.com/book/view/1590598814

I agree that Rails apps still aren't as easy to deploy as simple single-page PHP scripts. But that's what happens when you've got a whole framework to deploy, right? I would argue that these days, a Rails-based application isn't much more difficult to deploy than a comparative PHP framework-based application, though (like CakePHP, Symfony, etc)...

The Passenger Apache Module has made it pretty easy to get started with Rails on the deployment side of things. Check it out if you're unfamiliar with it. Simply gem install passenger, then run the command to compile and install the module and edit your vhost directive. Things get even easier once you learn and start using Capistrano as part of your deployment routine.

Btw, NetBeans is available free of cost. I'd start there if you're looking for a traditional IDE. Rails.vim is also free, of course.

There are a number of options. Most Rails developers seem to prefer lighterweight options like TextMate. There's also a great Rails.vim plugin if you're a Vi sorta guy.

If you're looking for a more heavyweight traditional IDE, I can heartily recommend NetBeans, which has evolved to have phenomenal Ruby/Rails support. Other options include Aptana/RadRails (Eclipse-based), IntelliJ, and Komodo.

The book is *mostly* about leveraging pre-existing third party plugins in your Rails projects, although we also discuss how to develop your own. It's well suited to developers that are new to the framework but does assume that you understand basic Ruby syntax and Rails conventions.

See the other current threads for a description of exactly what plugins are!

That's a loaded question . I can't really say for sure, and it changes from week to week and project to project. That's what's great about plugins and OSS in general -- there are extensions that can help you with pretty much any task.

In general, I find the following to be applicable to just about every project and completely indispensable:

- Rick Olson's Restful Authentication
- http://svn.techno-weenie.net/projects/plugins/restful_authentication/
- RSpec (also available as a Gem and usable outside of Rails, of course!)
- http://rspec.info/rdoc-rails/

Other candidates:

- One of the many file attachment handling plugins. Attachment-Fu is great (and David covers it in the book) but Thoughtbot's Paperclip plugin is also excellent.
- http://svn.techno-weenie.net/projects/plugins/attachment_fu/README
- http://github.com/thoughtbot/paperclip

- Matt McCray's Comatose plugin; this one gives you a whole micro-CMS subsystem 'for free'. Really powerful and can save a lot of time.
- http://github.com/darthapo/comatose

- Exception Notifier; You do want to know when your production app is throwing exceptions, right? Just install this. Or, you can use Hoptoad, a new (and free) hosted service that provides a plugin to log exceptions.
- http://svn.rubyonrails.org/rails/plugins/exception_notification/README
- http://hoptoadapp.com

Hi Dave,

There is a single chapter at the end of the book dedicated to the art of plugin development itself. It walks the reader through the creation of a typical plugin and illustrates how to use the hooks that Rails provides and some Ruby metaprogramming practices to graft new features on to Rails itself. This isn't really the focus of the book (which is on using pre-existing plugins), but we felt it was important to at least address it, and also talk about testing and distributing your plugin code as well.

Although its existence is addressed, the Rails Engines plugin is not used specifically in any of the projects. We had a really tough time of narrowing down the list of plugins we started with to those that felt most practical for beginning to intermediate Rails developers, so it's not that we don't think it's an important one .

The book is targeted at beginning to intermediate Rails developers. You'll need at least a passing familiarity with Rails and Ruby to get the most out of it -- not much time is spent on Ruby syntax, for example.

It's purpose really is to demonstrate to new developers how they can leverage the vast sea of powerful third party plugins to accelerate their development projects. In this way, it's a lot like a typical recipes book. The difference is that each recipe is used within the context of a real-world application and uses one or more plugins to develop some significant feature.

Personally I think your choice of a language comes down to many factors. For me, Ruby is probably the most fun I've had developing in any language, and that means a lot. I've also received dramatic productivity boosts since moving over. There are certainly a few things that aren't perfect, but that's true of any language.

If you're coming from a Java background and interested in getting your feet wet with Ruby you may also want to take a look at JRuby. It runs in the JVM, can leverage existing Java classes, and deployment will be familiar -- it can be packaged and served as a WAR. And yes, it can run Rails.

Unfortunately I haven't had the time to play around with Groovy, so I can't make an informed comparison. I'd love to hear other peoples' thoughts on the matter though!

Also, you may want to check out this link to the Redmine wiki:

http://www.redmine.org/wiki/redmine/Plugin_Tutorial

Looks like it might be helpful!

To be honest I'm not all that familiar with Redmine's use of plugins, but other "pre-existing" OSS Rails applications certainly do make use of plugins in a number of ways. Rick Olson's Mephisto blogging package leverages plugins to handle extensions to the core functionality, for instance.

Other applications, such as Radiant (CMS) and Spree (e-commerce) have their own extensions architecture that differs from plugins, and makes it easier to extend them in ways that make sense to their domain. In Radiant, for example, the extensions system allows you to easily add new Radius tags, page elements, and administrative sections to manage custom models.

It's certainly possible to create conflicts if unique module/class names aren't used. My advice would be to use nested modules in your plugin code to create a namespace. Then, in your init.rb hook, you can graft these methods onto ActiveRecord (or any other pre-existing piece of Rails) by referencing them thusly:

ActiveRecord::Base.class_eval do include MyCompanyName::RailsPlugins: :-P luginName end