I’m sure I’m not the only Rails developer who missed RailsConf 2009 due to a plethora of various reasons. Well, I didn’t let that hold me back from gaining as much information as possible from the Conference. Although these resources are pretty easy to find, I thought I would help you out by providing you with some links.

First is the official RailsConf site, hosted by O’Reilly. This would be an obvious first choice for people, but I am still going to restate that there is a great deal of free content available here. Most of the keynotes and speeches are now up in pretty high-quality video and slides are available in PDF form for both the keynotes and most of the tutorials.

Next, if you’re like most people, you might not have enough time to watch the hours of videos or sort through all the slideshows available over at the RailsConf site. Well, you’re still in a great position to learn from those keynotes, as Nick Quaranto attended a ton of events at RailsConf and took great notes, which he published here on his blog litany against fear. Some highlights include the David Heinemeier Hansson keynote on the future of Rails and the secret to being productive using Rails, some great keynotes about git and github, and a speech given about testing with Webrat. Definitely worth checking out.

The final resource I’m providing related to RailsConf is from Rails Magazine. They just published their second issue and it is a special edition for RailsConf. I really am trying my best to support this magazine because I think it would be great to see this magazine grow into something great (not that it isn’t already) and be avaialable at bookstores and news stands. The big article goes over what’s coming to Rails 3 and details about the Merb and Rails merge. Oh, did I mention this magazine is free in digital form?

And while I’m at it, I thought I’d also point you over to a very, very detailed article about the benefit of building websites for projects on github and how things should be documented. I think if this is more heavily adopted, it would make life easier for developers using a lot of various gems and plugins. But at the same time I understand that this does take effort to create and most people aren’t exactly overflowing with free time. Either way, a good read that I though I’d share. I hope these resources help you to understand what happened at RailsConf and hopefully taught you something new.

Sinatra has a great homepage with plenty of examples on how to get started. To install, you can grab the sinatra gem or clone the git repository.

While the examples on the Sinatra site are great for building your first simple application, Ruby Inside has put together a great list of links and resources for people interested in Sinatra.

Check it out over at Ruby Inside

First we can use either the rails generator to create a migration or use the model generator, which will also give us a migration file. Note: you could create these files by hand, but it is less error-prone and probably more efficient to use a built-in generator.

To create a migration with the model generator we would do something like this:

ruby script/generate model post
  exists app/models/
  exists test/unit/
  exists test/fixtures/
  create app/models/post.rb
  create test/unit/post_test.rb
  create test/fixtures/posts.yml
  create db/migrate
  create db/migrate/20090113055719_create_posts.rb

To create a migration on its own we would do something similar to this:

ruby script/generate migration add_category_column
exists db/migrate
create db/migrate/20090113055952_add_category_column.rb

To run the migration we use the db:migrate task

rake db:migrate

When running the db:migrate Rake task, a schema_migrations table is looked for to keep track of migration versions. If one isn’t found it will be created on the fly. After each migration is run a row in the schema_migration table is added.

You can also use the db:migrate Rake task to force the database to a specific version by supplying it with the Version= parameter.

rake db:migrate VERSION=20090113055719

To revert the database to it’s original state supply Version= paramter with 0.

rake db:migrate VERSION=0

If you run a migration whose version is higher than the version of the current database, the migration will be applied. Somewhat differently, if you run a migration whose version is lower than the version of the current database, Rails will look for the migration file whose number matches the database version and undo it.

I hope this tutorial has helped you to begin to understand ActiveRecord and how useful migrations can be. In the next article in this series we look at what makes up a migration in more detail.

Free Resources

1. First you’ll probably want to get Ruby on Rails installed on your machine. To do this is quite simple and this website will help you along the way. If you are on a relatively new mac, you probably already have Rails installed and therefore just running the command ‘gem install rails’ from the terminal will get you the newest version of rails and all of it’s dependencies. More on this on the official Ruby on Rails website.
2. Rolling With Ruby on Rails Part 1 and Part 2 – This is a slightly outdated tutorial as it was written in 2005, but it still serves as a great introduction to the language of ruby and the framework rails provides. 
3. Really Getting Started with Rails – Amy Hoy over at Slash7 has put together a great guide that not only covers the the basics of RoR, but also introduces the reader to the basic concepts of the Ruby scripting language.
4. Getting Started With Ruby on Rails – The excellent A List Apart wrote an article not very long ago that shows the benefits of using RoR for a web project. It introduces the reader to the basics of ruby and many concepts of the rails MVC framework.
5. Using Ruby on Rails for Web Development on Mac OSX – Apple has written an article on getting started using ruby on rails with a fresh install of Mac OS X. It is a great tutorial that takes you through the creation of a basic RoR web application.
6. Ruby on Rails from Scratch – Probably my favorite of all the free tutorials I have listed. This is a four part series of very visual tutorials for learning RoR. I know most people are visual learners, so this series is great for you. In fact, parts of the series are video tutorials. Definitely worth checking out.
7. Rails Framework Documentation – This is the Rails API. Get familiar with it because it will become extremely useful the more you learn to love it.

So I would consider those the best of the best free tutorials available. But free tutorials will only get you so far. The following is a list of paid resources that I would definitely consider checking out.

Paid Resources

1. Peepcode – Definitely my favorite, favorite resource for learning the workings of Ruby on Rails. They cover many advanced topics but also basic topics as well. I would definitely check out Rails 2 from Scratch Part 1 and Part 2 if you are just getting started with Rails. Each screencast is $9, but money can be saved if you buy credit packs or a yearly subscription. It is also worth checking out some of the PDFs they have about Rails 2 and Git.
2. Agile Web Development With Rails – This is an amazing book published by the Pragmatic Programmers (well it actually hasn’t been published yet) that can be purchased as a beta pdf. What is a beta pdf you might ask? A beta pdf is a digital copy of the book that is being updated as the book is being corrected and added to (as rails changes). Each time they release a new version of the book, you can download it again and have the newest content available. Basically, the first half of the book takes you through the creation of a complete rails application and the second half is a very deep look into the rails API with examples and explanations galore.
3. The Rails Way – Another great book that teaches you tons of great things on Rails 2. For me it is second only to Agile Web Development With Rails.

Alright, I hope that gets you started with Ruby on Rails. I will be posting another list of Rails resources and tips later this week that will give you an idea of how to make the leap from novice to intermediate Rails programmer.

She asks viewers to resist the urge of putting it on Digg yet, as her server is not ready to take another “Digging” quite yet.

View Amy’s post here

View the cheatsheet directly here

I would also like to mention a blog post I found today on Rails Forum which contains five tips to help beginners really get started with Ruby on Rails. Check it out here.

That’s it for now, but be sure to check back soon as there should be a tutorial on getting started with Adobe AIR up soon. I will then move onto more advanced topics and show you how to develop a basic twitter AIR app over the next few weeks. (or when mid-terms permit me to)

Routes in Ruby on Rails allow you to map incoming URLs to specific controllers, actions, and parameters in your application. Routes are written in pure ruby and can be found in the file config/routes.rb in your application’s root directory. Upon generating a new application using rails appname, some default routes are created for you as shown below (comments have been removed):

1 2 3 4

ActionController::Routing::Routes.draw do |map| map.connect ':controller/:action/:id' map.connect ':controller/:action/:id.:format' end

Routes are created using the connect() method. For more information on the arguments connect() can take, see here. Now that you have a handle on what routes are and what they do, let’s make one of our own.

Now for lack of an example, let’s imagine that we are creating a site that let’s users post and share songs they have made. We have a controller called SongController that contains most of the logic of the application. Our controller, SongController, has an action, display(), that can search for and display songs based on assorted criteria, like the song’s author.

First, I am going to show you how to create a route that will let users display all songs created by a specific author. Let’s assume our site is called SongShare (assuming the application is installed at songshare.com) We want a URL for a user JohnD to look like this: songshare.com/johnd Because it would be off-topic to make a full application and display the code here, I am going to show a temporary version of our list action. This will raise an exception, passing any supplied parameters. This causes the application to fail and show these parameters in the browser. I won’t go into detail of how to create the search, as it doesn’t pertain to this and the parameters are really all we need for this example.

1 2 3 4 5

class SongController < ApplicationController def list raise params.inspect end end

Now, let’s create our route. Open up config/routes.rb again and add the following line after the routes already provided:

1 2 3

map.connect ':user', :controller => 'song', :action => 'list', :filter => 'user'

If you start your local server running on the default port of 3000, you should now be able to go to http://localhost:3000/johnd and see an error page with the heading RuntimeError in SongController#list. This is a good thing (for our purposes at least). You now know that your page request was routed to the list action previously created. Below the heading, you should see a listing of the request’s parameters. You should see four items here: the user parameter, the action, the filter parameter, and the controller.

That’s all great, but let’s get more specific now. What if we wanted to limit our search to songs that are posted by a specific user and tagged as electro. Let’s modify the previous route declaration to look like the following (NOTE: There are multiple ways to do this, it’s up to you!):

1 2 3 4

map.connect ':user/:tag', :controller => 'song', :action => 'list', :filter => 'user', :tag => ' '

This route will match URLs such as http://localhost:3000/johnd/electro and populate both the :user and :tag parameters. If no tag is specified, the route will still match, and an empty string will be placed in the :tag parameter.

Now let’s make a route to display the top-ranked songs at http://localhost:3000/popular. We will also allow tags to be supplied as we did in the previous example. Add the following to routes.rb:

1 2 3 4

map.connect 'popular/:tag', :controller => 'song', :action => 'list', :tag => '', :filter => 'popular'

This must go above the existing routes in routes.rb or else the wrong parameters will be populated. This is because the Routes engine processes routes in the order they appear in the file and there is nothing to distinguish the word popular from a user’s name.

Finally, let’s allow you to display all the songs that were added on a specific day. Put this route before the user route:

1 2 3 4 5 6 7 8 9 10 11 12

map.connect 'daily/:month/:day/:year', :controller => 'song', :action => 'list', :filter => 'daily', :month => 'Time.now.month', :day => 'Time.now.day', :year => 'Time.now.year', :requirements => { :year => /\d+/, :day => /\d+/, :month => /\d+/ }

This route will accept URLs such as http://localhost:3000/daily/08/18/2008 and populates the :month, :day, and :year parameters. The :requirements parameter we specified that the year, day, and month must be numeric digits for the route to match.

And there you have it, how to make pretty URLs using routes in rails. If anyone has any other methods or questions, please post in the comments.

[ad#adroll-1]