Watch Me Learn Ruby On Rails

After completing my first walkthrough and rails application, it is time for a little more intensive walkthrough to make sure I am understanding the architecture of ruby and rails.  

The guide starts right away with the traditional guide question of "What is Rails?"  I'm starting to see some themes in ruby/rails descriptions like DRY (Don't Repeat Yourself), "Ruby is, most of all, FUN!" but this is the first time I've seen Rails referred to as an opinionated language.  Interesting.  Rails seems to be about using conformity and strict standards to solve problems as opposed to hacking away and finding the quickest solution.  This sections best sums up why I am so excited to start using Rails:

Convention Over Configuration – means that Rails makes assumptions about what you want to do and how you’re going to do it, rather than requiring you to specify every little thing through endless configuration files.

I have essentially taught myself any programming languages I know (C, Java, Flex/Flash, PHP, etc) so learning new ones often means finding ways for my brain to make associations to things I already know or understand.  For example, if we were in the 60's and PHP is the land of anything goes (damn hippies), then Rails would be the land of faceless corporate suits.  This is how my brain works.  Anyways, back to the walkthrough, you were saying something about MVC?

Ahh, here we go.  I kept noticing in the other walkthrough references to "Action ..." or "Active ..." but never really knew what they were talking about.  We start to break down each of these components now.  The Action Pack (Action Controller, Action Dispatch, Action View) seems well thought out to me.  I'll probably have to keep referencing this until I blindly know where everything should be stored but that is a minor speedbump.  The Action Mailer seems useful as well and can't possibly be worse than PHP's mail().  I can't wait to have all my CRUD functionality taken care of automatically by the Active Record component and using Active Resource for any web services should be fun too.  Active Support is a great concept, I'm curious to see how well it is implemented.  And finally, Railties.  Really?  If you are going to walk that line of clever names for components, you should just own it. Don't drop one in here and there to be cute.

The walkthrough does a quick overview of REST and how it applies to Rails but they link to an article that does a much better job of giving you a full overview of REST if you are in need of something like that.  I highly suggest reading it for fun as you may pick up one or two new things like I did.

Alright, coding time!  Let's make a web blog!

Moochacha:~ $ rails new blog

One command and my new app is already framed. Man, I'm not sure that will ever get old.  I think I like this walkthrough better than the first as I feel like I'm learning more "why" than "how".  For example, I now am fully aware of the purpose of a Gemfile, understand the purpose of each folder in directory structure, and the difference between what is supposed to be in the README.rdoc and what is supposed to be in the doc.  All of this can probably be assumed but explicitly stating it is always useful for beginners like me.

Something else that slipped by me before is the automatic breakout of development, test, and production database environments.  I think of all the time I've wasted in previous projects getting this setup (usually after the fact) and it makes my head hurt.

Even though "-T" seems counterintuitive for essentially a help command, this is a very useful list:

Moochacha:blog $ rake -T (in ~/src/rails/blog) rake about              # List versions of all Rails frameworks and the environment rake db:create          # Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config) rake db:drop            # Drops the database for the current Rails.env (use db:drop:all to drop all databases) rake db:fixtures:load   # Load fixtures into the current environment's database. rake db:migrate         # Migrate the database (options: VERSION=x, VERBOSE=false). rake db:migrate:status  # Display status of migrations rake db:rollback        # Rolls the schema back to the previous version (specify steps w/ STEP=n). rake db:schema:dump     # Create a db/schema.rb file that can be portably used against any DB supported by AR rake db:schema:load     # Load a schema.rb file into the database rake db:seed            # Load the seed data from db/seeds.rb rake db:setup           # Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first) rake db:structure:dump  # Dump the database structure to an SQL file rake db:version         # Retrieves the current schema version number rake doc:app            # Generate docs for the app -- also availble doc:rails, doc:guides, doc:plugins (options: TEMPLATE=/rdoc-template.rb, TITLE="Custom Title") rake log:clear          # Truncates all *.log files in log/ to zero bytes rake middleware         # Prints out your Rack middleware stack rake notes              # Enumerate all annotations (use notes:optimize, :fixme, :todo for focus) rake notes:custom       # Enumerate a custom annotation, specify with ANNOTATION=CUSTOM rake rails:template     # Applies the template supplied by LOCATION=/path/to/template rake rails:update       # Update both configs and public/javascripts from Rails (or use just update:javascripts or update:configs) rake routes             # Print out all defined routes in match order, with names. rake secret             # Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions). rake stats              # Report code statistics (KLOCs, etc) from the application rake test               # Runs test:units, test:functionals, test:integration together (also available: test:benchmark, test:profile, test:plugins) rake test:recent        # Run tests for recenttest:prepare / Test recent changes rake test:uncommitted   # Run tests for uncommittedtest:prepare / Test changes since last checkin (only Subversion and Git) rake time:zones:all     # Displays all time zones, also available: time:zones:us, time:zones:local -- filter with OFFSET parameter, e.g., OFFSET=-6 rake tmp:clear          # Clear session, cache, and socket files from tmp/ (narrow w/ tmp:sessions:clear, tmp:cache:clear, tmp:sockets:clear) rake tmp:create         # Creates tmp directories for sessions, cache, sockets, and pids

I'm loving the idea of the routes.rb file acting as the router for the application, very handy!  I'll have to dive into the routing guide later, that should be pretty useful to know.

Alright, now on to setting up the scaffolding.  This is probably my shakiest part so far as there seems to be a lot going on so hopefully this walkthrough goes a bit more in depth and explains the process in clearer manner.  Let's see if I have this straight:

Moochacha:blog $ rails generate scaffold Post name:string title:string content:text

Basically means that I am generating CRUD functionality (both UI and backend) for "Post" which is essentially just a database table with name, title, and content as columns.  It is also automagically generating a migration script (up AND down) for the new table, which I must run to physically create the table. Sound about right?  Please correct in the comments or via twitter if not.

Moving on, my first interaction with the link_to method.  The guide wants to link_to my posts/blog by providing the posts_path, but I cannot see where that is defined in the code.  Is this automatically handled somewhere?  Maybe just goes to the index of "posts" by default?

Looking at the app/models/post.rb file I see that "Post < ActiveRecord::Base" is syntax for inheritance.  I'm not sure yet if using symbols like "<" are better than words like "extends" but it seems like semantics at this point.

Another area that this walkthrough seems superior is how it dives into the code in the posts_controller.rb file and explains what each section is actually doing.  Very useful for me.  In the overview of the app/views/posts/index.html.erb looping, I finally get my answer from before:

edit_post_path and new_post_path are helpers that Rails provides as part of RESTful routing. You’ll see a variety of these helpers for the different actions that the controller includes.

Sweet, makes sense.  I also get this little nugget of information just after:

In previous versions of Rails, you had to use <%=h post.name %> so that any HTMLwould be escaped before being inserted into the page. In Rails 3.0, this is now the default. To get unescaped HTML, you now use <%= raw post.name %>.

Once again, crap I had to spend time dealing with before is taken care of automatically.  I think I'm beginning to swoon.

Partials is a cool concept that applied to a form seems incredibly speedy and useful.  Again, the amount of time I have spent coding up a form so it can be reused as both a "new" and "edit" form is incredible.  I appreciate all of this auto-generated stuff, but I really wonder how is automatically handled in a real-world application.  Also, what about forms that span multiple tables, how difficult is it to wire those up properly?  Any rails developers care to share a little insight there?  (update: this is mostly covered later in the walkthrough but I'm still curious about others opinions)

The Flash.  Sounds awesome, but this walkthrough glosses over it.  Must make a point of reading up on the Flash.  Also, I need to look deeper at the .find method as well as the params() call.

Time to add a second model (yay!) to the blog which is the ability to comment on posts.  This should help show how you can have relational databases with this setup and possibly even setting up foreign keys.  Ahh yes, the "belongs_to" line sets up an association.  Even better, I will apparently learn a lot about associations in the next section so lets just let that lie for now.

I'm noticing a trend in this walkthrough of repeat the phrase "Rails is smart enough to..."  Kinda refreshing to be dealing with a language that is smart enough to do things.

I now see you have to backtrack and add in a reference to the model of whatever table you are associating with.  Reading that back, it sounds really confusing but assuming you have the syntax down, its quite logical.  Having the ability to automatically call @post.comments for an array of comments is also quite amazingly easy and useful.

Now I'm wiring up the comments in the views of the blog.  It says we will be handling SPAM comments, I'm curious how this will happen as I assume it is some built-in functionality (sweeeet).

I won't rehash the example here but I will say that the walkthrough does a good job explaining the way associated tables can be utilized in rails.  I feel like more of this process could be automated but I'm very impressed with that is available out of the box. 

We are on to add functionality for deleting comments manually (no auto-spam feature in this walkthrough).  You know you are learning a good language when you can pretty much write your own "destroy" action on day 3 without having to peek at the walkthrough.  Also, I like everything about this :dependent option on the post model

Ooooh, Security now - finally something more real-world oriented.  Fairly straight forward.  I like that the language and naming conventions Rails uses are all self-explanatory and just seem to make sense.  Authentication works but I'm curious how you handle logouts.  I guess we save that for another time since we are off to build a tagging mechanism.

When adding the view for tags, I come across the line @post.tags.map { |t| t.name }.join(", ") and my eye starts twitching from having to parse through giant chained commands like that in Java.  Luckily, the walkthrough creator probably had a similar thing happen and so they jump right in to creating View Helpers.  It doesn't remove the idea of chained commands but it at least gets them out of the view and into their own section.  I call that a win.

And after a couple Gotcha's and further references, we have completed walkthrough #2 for Rails.  Hooray!  Also, I have just built a functional blog with tagging and commenting in about 1 hour or so.  I can really start to see why everyone is raving about Rails and Ruby, it really does make things much easier! 

...and we're back!  Day 1 was a light day of making sure I am up to date with all my installations so I am starting from a good point and eliminating as many hurdles upfront as I could.  Today it is time to actual start learning

Todo: First Rails App Walkthrough

right away, step 1 seems to be incorrect on the site as it says "rails myapp" but i'm being told by my installation that the usage is actually "rails new myapp".  Semantics, but still kinda annoying.  

Moochacha:~ $ rails new ~/src/rails/myapp       create         create  README       create  Rakefile       create  config.ru       create  .gitignore       create  Gemfile       create  app       create  app/controllers/application_controller.rb       create  app/helpers/application_helper.rb       create  app/mailers       create  app/models       create  app/views/layouts/application.html.erb       create  config       create  config/routes.rb       create  config/application.rb       create  config/environment.rb       create  config/environments       create  config/environments/development.rb       create  config/environments/production.rb       create  config/environments/test.rb       create  config/initializers       create  config/initializers/backtrace_silencers.rb       create  config/initializers/inflections.rb       create  config/initializers/mime_types.rb       create  config/initializers/secret_token.rb       create  config/initializers/session_store.rb       create  config/locales       create  config/locales/en.yml       create  config/boot.rb       create  config/database.yml       create  db       create  db/seeds.rb       create  doc       create  doc/README_FOR_APP       create  lib       create  lib/tasks       create  lib/tasks/.gitkeep       create  log       create  log/server.log       create  log/production.log       create  log/development.log       create  log/test.log       create  public       create  public/404.html       create  public/422.html       create  public/500.html       create  public/favicon.ico       create  public/index.html       create  public/robots.txt       create  public/images       create  public/images/rails.png       create  public/stylesheets       create  public/stylesheets/.gitkeep       create  public/javascripts       create  public/javascripts/application.js       create  public/javascripts/controls.js       create  public/javascripts/dragdrop.js       create  public/javascripts/effects.js       create  public/javascripts/prototype.js       create  public/javascripts/rails.js       create  script       create  script/rails       create  test       create  test/fixtures       create  test/functional       create  test/integration       create  test/performance/browsing_test.rb       create  test/test_helper.rb       create  test/unit       create  tmp       create  tmp/sessions       create  tmp/sockets       create  tmp/cache       create  tmp/pids       create  vendor/plugins       create  vendor/plugins/.gitkeep

I've officially hit my first "niiice!" moment of this process.  Creating a new rails app is pretty easy and just the fact that it goes so far as to break out individual config files, custom error pages, and includes various javascript files like prototype.js is pretty impressive.  At quick glance I would say the only thing missing is jQuery but since I always use Google's jQuery library, it dosen't even matter.

Now its time to start up the rails server.  Having dealt with Apache, Tomcat, and other web servers in the past, this looks to be much simpler with no need to configure directories, include libraries, etc.

Moochacha:myapp $ rails server => Booting WEBrick => Rails 3.0.3 application starting in development on http://0.0.0.0:3000 => Call with -d to detach => Ctrl-C to shutdown server

[2011-01-22 15:46:53] INFO WEBrick 1.3.1 [2011-01-22 15:46:53] INFO ruby 1.8.7 (2009-06-12) [universal-darwin10.0] [2011-01-22 15:46:54] INFO WEBrick::HTTPServer#start: pid=14704 port=3000

What do you know, nothing to do but a simple call.  Let's mark this as "niiice!" moment #2.  Now to find a rails IDE.  A quick google tells me that RadRails is a popular eclipse-based IDE so let's roll with that one for now.  If anyone has some suggestions for what I could or should use on OSX, let me know in the comments or on Twitter.

Time to create some databases.  I like the use of the yml file and the "scaffold" idea reminds me of a PHP data access layer I was working on a while back.  Its a pretty easy process to setup a new table too.  Here is me creating a new table called "user" that has 3 columns:

Moochacha:myapp $ rails generate scaffold user first_name:string last_name:string active:boolean       invoke  active_record       create    db/migrate/20110123002621_create_users.rb       create    app/models/user.rb       invoke    test_unit       create      test/unit/user_test.rb       create      test/fixtures/users.yml        route  resources :users       invoke  scaffold_controller       create    app/controllers/users_controller.rb       invoke    erb       create      app/views/users       create      app/views/users/index.html.erb       create      app/views/users/edit.html.erb       create      app/views/users/show.html.erb       create      app/views/users/new.html.erb       create      app/views/users/_form.html.erb       invoke    test_unit       create      test/functional/users_controller_test.rb       invoke    helper       create      app/helpers/users_helper.rb       invoke      test_unit       create        test/unit/helpers/users_helper_test.rb       invoke  stylesheets       create    public/stylesheets/scaffold.css

Let's mark this as "niiice!" moment #3 of the day as I see this auto-generates unit tests on the fly.  That is pretty slick and should prove to be very useful.  Running the db:migrate command, I now have a fully functioning user manager web interface to my database.  Sweet!

The walkthrough now wants to add a new column to the user table and utilizes the db:rollback command to this. Back when the scaffolding was generated for the user table, it also generated a migration file that the db:migrate command runs.  I appreciate the self.up and self.down aspects of this migration file, very slick.  Also, adding new columns is pretty simple assuming you know the proper syntax.

After re-creating the user table in the database, I now get to dive into actual ruby code to add the bio field to the page.  Or maybe this is all considered ruby code?  It is unclear to me at this point but I assume any ".rb" file is ruby.  The new "bio" section needs to be added to both the create/edit form and the view.  One of my favorite aspects of PHP is that it is a scripting language and can be pretty much just dropped into files wherever you need it.  Ruby looks to be very similar in this respect which makes me happy.    

The walkthrough says to let out a barbaric woot now, so "w00t!".

This render command looks to be similar to an include or require in PHP.  Good to know.

Time for some validation now, I'm curious to see how this works and how well integrated it is.  If it is anything like the rest of rails, it should be pretty seamless. 

class User < ActiveRecord::Base   validates_presence_of :first_name, :last_name end

Wow, that is it.  Niiice!  functionality is all taken care of and everything.  What's even better is that there are a bunch of validation classes bundled in rails and ready to go.  I'm particularly interested in the validates_uniqueness_of method but I am curious about its efficiency.  I'll push that investigation off for now and just say, me likey!

Next up is playing around with the layout.  I like the concept of layouts in ruby and they seem to be very useful and well implemented.  I'm sure it may get both tricky and annoying trying to hunt down bugs but I think making an effort to stay organized and consistent will eliminate that. And if not, well, that seems like a small price to pay.  For a big concept, there is not much to do on the walkthrough with layouts as their instructions seem out of date since the users.html.erb file is already named application.html.erb.  So, off to play with the console!

console is pretty slick but seems a bit off topic for this walkthrough.  Regardless, I wonder how the migrate script syntax handles default values for database columns.  Something to look into.  I like all the functionality available within the console and the idea that I potentially will never have to write SQL again.  Seriously, how many calls/lines of code would this take in another language:

>> User.all.each {|user| puts user.first_name.upcase}   User Load (0.6ms)  SELECT "users".* FROM "users" CONAN PENNY BAD GREGG

That is some cool functionality right there.  Just look at some other calls you can do too.  Well done ruby!  As a sidenote, what is apidock.com?   The rubyonrails.org site keeps referencing it for API functionality, is it associated to ruby in any way or just a third party site with some documentation?

I'll call this a productive day as I have a fully-functioning rails app, a basic understanding of the architecture, and an understanding of the model and how to manipulate and use it effectively.  Not bad for less than 1 hour of work.  The next step for me will be running through a bit more intensive walkthrough that focuses more on the architecture before starting in on some specific tasks and maybe building a site of my own from scratch.  Its very early, but color me impressed so far!

So, on with the show...

Todo: Installation Guide

I'm going to be doing most of my developing and learning on my MacBook Pro (old version, not new) so I best update the ruby and ruby on rails builds on my machine before anything else.  Currently I'm at ruby 1.8.7 and Rails 2.3.5.  Looks like the current MacPorts version of ruby is 1.8.7 so I'm guess I'm good there.  The intro I'm following along with says to test out the installation so...

Moochacha:~ $ ruby -v ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0] Moochacha:~ $ ruby -ropenssl -rzlib -rreadline -e "puts :Hello" Hello

Not sure exactly what the second command does, looks like some sort inclusion of libraries and an echo.  I'm sure it will all make sense soon.  

Time to update ruby gems and rails next.  Looks like gems is simple enough to update with a couple calls.  The latest Rails release is 3.0.3 and I am at 2.3.5, so best be updating that one.  Whew, that took a little while but we have success!

Moochacha:~ $ rails -v Rails 3.0.3

Its Friday and I'm hungry so I'm halting here and heading out for food and a drink or two.   Next set to come soon is doing the First Rails App Walkthrough and then on to some tutorials

That's it.  

I'm doing this.  

5 years ago I was a software developer working in downtown Chicago and a huge fan of everything 37signals was about.  Today, I am a software developer working in downtown Seattle and a huge fan of everything 37signals is all about. 

Which brings me to Ruby, and more specifically, Ruby on Rails.  I have been fascinated by its apparent simplicity and am constantly hearing people rave about it in the media, blogs, and from fellow developers.   Wanting to dive into it myself, I have stuck my toe in the water and built demo applications here and there but never had the time or motivation to really dive in and become a Ruby on Rails developer.  Until now.

I still don't really have the time learn at any uber-fast pace, but I am hoping this blog and my slowly dying hope in programming languages will be motivation enough to bring me through.

I am set to follow a few tutorials and "Getting Started" links found on the rubyonrails.org wiki this weekend and am looking into purchasing a few reference books as well.  I am an amateur writer at best, but nonetheless will document my learning process best I can the whole way through on this here blog.  If you have any advice for me or just an interesting story about your Ruby on Rails learning process, I would love to hear it!