My hunt for knowledge usually leads me to interesting places (in Rails as well as generally). Today I found a priceless little book by 37 Signals titled “Getting Real”. The book is available for purchase here

I’ve skimmed through the free online book and it looks extremely insightful for new designers, developers etc etc coming to the Rails framework.

You might just want to check it out…

This is a follow up post from the one I read over at Rails Envy. Indeed its true that Rails need Active Members for their growing community, but the fact is that they don’t and this is one of the reasons Greg Pollack posted on his blog.

Read what Greg had to say:

Here in the Rails community I feel we’ve been lucky enough to have several great coders who are also great leaders. I’m not just talking about the people on the Rails core, I’m talking about people who create educational media such as rails blogs, tutorials, books, classes, screencasts, podcasts. I’m also talking about anyone who has taken the time to release a Rails Plugin or Gem, support new Rails developers (like on mailing lists, forums, or IRC), or run events promoting Rails or Ruby.

Doing this sort of community development (as you may already know), can often be a thankless job. It may feel like the people at the top (or in our case, the core developers) get all the credit. Just like I’ve heard people say “Why bother coding a Rails patch, it won’t get accepted” in regards to code, I’ve also heard “Why bother producing this Rails content, if it won’t be appreciated or recognized” in regards to community development. Thus, I’ve personally done my best to recognize and publicize these people, either by promoting them in the Rails Envy Podcast or through the Ruby Hero Awards, but sometimes I wish I could do more.

You know that this man is sincere about Rails and knows exactly where it is headed in the future. Ok, so you are not a great coder (don’t worry you will be if you take the time to). You can help out however by contributing to anyone of these destinations or by signing up:

Rails User Voice
Rails Envy => Start by commenting on their blog.
Rails Google Activist Group

Two other points that i liked (from the Rails Envy blog)

Empower People to do good work:

If you want to help with the documentation, you have an idea for a new resource, or you want to completely redo the wiki, let us know. Come to us with your ideas on how you can support the community on the internet or even in your local neighborhood. Lets figure out how we can help you spread the word.

Listen to the community

I care a great deal about growing Rails in 2009, and pushing it deeper into the enterprise. Each of the Activists has their own initiatives and projects to help do this, but we’re going to need community involvement to attack some of the bigger issues. Two examples of this might include fixing the Wiki, and the creation of some sort of Rails Book.

Valid points by Greg no doubt, so let the Rails Core team do what they do best => and that is program. I for one will help out wherever i can, even if it means spending extra hours on the computer aside all my other work..

This is an unforgettable mistake i made today while running some migrations in Rails.

Here is the first migration file. It was generated by using this simple command:

ruby script/generate model Articles

Simple enough right? The output of the generation was:

def self.up
  create_table :articles do |t|
    t.column :user_id, :integer
    t.column :title, :string
    t.column :synopsis, :text, :limit => 1000
    t.column :body, :text, :limit => 20000
    t.column :published, :boolean, :default => false
    t.column :created_at, :datetime
    t.column :updated_at, :datetime
    t.column :published_at, :datetime
    t.column :category_id, :integer
  end

def self.down
  drop_table :categories
 end
end

When i went ahead and tried the rake command to migrate to my database: rake db:migrate I kept getting an error “Uninitialized constant Create Articles” Rake Aborted!!

Having forgot that everything in Rails is Object Orientated (extends from one base class or another) i overlooked two things.

1. I did not declare the class and what base it extended
2. I did not add the schema file name into my migration file

Usually Rails generates the schema and adds the base class (Active Record) but this time it didn’t. Anyhow the fix was easy enough…

#20090106022023_create_articles.rb
class CreateArticles < ActiveRecord::Migration
  def self.up
    create_table :articles do |t|
      t.belongs_to :user, :category
      t.string :title
      t.text :synopsis, :limit => 1000
      t.text :body, :limit => 20000
      t.boolean :published, :default => false
      t.datetime :published_at
      t.timestamps
    end
  end

  def self.down
    drop_table :articles
  end
end

So this is a classic mistake of us all having our moments..Thanks again to the users over at Stack Overflow for helping out. Their are some excellent trouble shooters out there.

RPM Lite is a FREE, supported Rails production monitoring product that helps you keep your app humming. You get deep, real-time visibility into your app, so you always know what’s up. Use it on as many applications and hosts as you like. For as long as you like.

Troubleshoot in development. Troubleshoot in production. Build high speed into your app from the very beginning.

Sign up for New Relic (its free!!)

I spent two minutes checking it out with the *small flex/rails app that i made the other day. What i liked straight off the bat was two things:

1. Installing the plugin: Easy as pie! I’m not exactly sure if you can install it without signing up, nevertheless it was a cinch!
2. Point and Go!: All you got to do is point your browser to:
   http://localhost:3000/newrelic and you are done!!

So its pretty much a straight outta the box type of deal here. Will definitely be using this little baby from now on!

Today we had our first training session on Ruby and Ruby on Rails. The boys over at office where extremely excited and so was I. We went over:

1. What is Ruby?
2. What is Rails?
3. History of Ruby and Ruby on Rails.
4. Brief Approach to MVC and Design Patterns.
5. Skinny Vs. Fat Controllers.
6. Intro and History of MERB.
7. Intro to Git/Putty/SSH.
8. Pre-Requisites (Ruby, Cap, Mongrel, Rails, Gems, SQL).
9. Difference between Instant Rails and Manual Install.
10. Common commands.
11. Installing Rails.
12. Skeleton Application.
13. Intro to routes, database.yml, common folders in a Rails App.
14. Review and Questions

Its amazing to see how quickly developers get the hang of Rails framework. Some of the team members are versed in Oracle, Java and we have a dedicated database architect also. Sure it took them a little bit of Spoonfed goodness but thats aight! We hope to continue our training till we reach a point where we can do the Agile Web Development Thang (aint too far away InshAllah). Thats not to say thay we will “ditch” our “bread and butter” work for Rails. Its just really exciting to see Pakistanis gel with sincerity.

Rails has given me not only the opportunity to share with others, but bridge the divide amongst my own people. That is itself says alot for one Framework. With the merge of Merb and Rails (OMG), i guarantee you lots of adoption in the near future.

DHH will you get on making Rails easier to deploy in the near future. In my limited knowledge deployment is one aspect that will doom Rails for early adopters out there.

Sheesh i need to post some pics up of the office and the guys!! Well done team, I am proud of you all today (MashAllah).

We be chopping game soon baby CHOP CHOP CHOP!!!

Working with rails is a lot of fun, I’ll admit, but when you throw Flex into the Picture its like “The Real Side of The Force”. This is a small tutorial demonstrating how to get up and running with Flex and Rails!!

^This tutorial is for Windows users (yuck, can’t wait to get onto Linux), and is inspired by Peter Armstrongs Flexible Rails Book. Pre requisites for this tutorial are: Flex Builder/Rails 2.2.2/mysql (not needed but pre configured) and thats about it. If you are running an older version of Flex or Rails try and follow along, it should work out as its a basic demo without database interaction.

Configuring the Application:

1. CREATE YOUR APPLICATION: This is very easy just create the app by using this command

rails -d mysql flexonrails # tell Rails to use mysql instead of the default sqlite3 adapter

*You should modify your command line prompt to start up with the directory your Rails Apps reside. My directory is D:/Rails Apps. All you have to do is click on the Command Line Shortcut and define the path in the “Start In” field.



Other commands that might come in handy:
D:\Rails Apps> mkdir flexonrails //create a directory named "flexonrails"
D:\RailsApps> cd flexonrails //cd into the dir. you just created

You can also use an IDE of your choice to create the application. I just switched over to netbeans.

2. CHECK IF THE APP IS WORKING: Point your web browser at http://localhost:3000/ and you should get your normal Rails screen showing.

   Make sure that you create your database (even though we aren’t using it in this small demo.) You should get used to doing that.

   

3. CREATE THE FLEX PROJECT: I will be using Flex Builder 3 here, but you can easily use the FLEX SDK. Before you go ahead and create the project make sure to create these folders within your application direcotry.
   D:\Rails Apps\flexonrails> mkdir app/flex //creates the flex dir within the app dir.
   ….
   D:\Rails Apps/flexonrails> mkdir public/bin //creates the bin dir withing the public dir.

   …
   

   …
   

   ….
   

4. CREATE THE CONTROLLER IN RAILS: Create the controller in rails by using the normal:
   ruby script/generate controller {your controller name}

   (OR copy and paste the following to Controllers/hello_controller.rb)

   class HelloController < ApplicationController
     def hello
       render :text => "hello world!"
     end
   end
   

5. CREATE THE MXML: You will have to create the mxml which is pretty straightforward here. First rename your flexonrails.mxml to Flexonrails.mxml to avoid any naming conventions. Then copy this code over:

6. BUILD THE PROJECT AND POINT: All you have to do now is build the project (In Flex Project>Build Project and make sure Build Automatically is unchecked).

   Next point your browser to:
   http://localhost:3000/bin/FlexonRails.html

That should do it for you. In case it doesn’t work make sure that you:
(1) Saved your files.
(2) Configured Rails properly.
(3) Configured your Flex Builder Project Properly.
(4) Created the public/bin AND app/flex sub directories.

This should give some good insight on how to setup a Rails and Flex Project. Sure it might take some time to start creating bigger apps, and apps that connect to a database, but this is sure a good start.

Judging from this screenshot take a guess why I am moving over to the NetBeans IDE, and really soon! Scite is great to get started but is really painful when you start working with lots of files. It just comes bundled with the Ruby Installer so it’s **convenient to use.

Check out the some of what other people are using over at The Web Builder Zone.

Does anyone have anymore suggestions?

I’ve developed a couple of small apps with Rails now. Its been a ROR’ING ride allright + alot of fun to get your hands dirty. I have heard people diss on Capistrano (misguided bloggers) alot on different blogs, talking about:

PHP did not kill Rails–Rails killed Rails. Who in their right mind is going to want to deploy 5 – 10 30 meg preforked processes per application from whatever location on this thing called “mongrel” and have the whole mishmash marshalled by this other thing called “Cappucino”… er “Capistrano”, which is lipstick on a pig, because rails is a pig no doubt about it. I need one server with several preforked processes for ALL applications to be served.

Rails is a pig? Errm don’t blame Rails but Scoble. Note Twitter’s unique position as a web application. It is neither solely a messaging app or a social networking app, but a combination of both. In the past companies had been able to build applications based on one of those foundations, but not both.

Ok onward with Capistrano. I am definitely going to give deploying my apps a try with Capistrano, it is the standard way of deployment for Rails apps these days (at least so i have seen on the web).

I’ve developed http://pantherfotos.com in Rails in about 3 months (3 hours a day working on the train from and to work). It contains about 60 database tables which power: forums, blogs, photo uploads, google map integration, dzone/digg type listing directory, security, monthly memberships, e-commerce (selling of photos and photo albums), taxonomy (polymorphic), an articles section, member clubs (with the ability for members to create public/private clubs and clubs to create public/private forums), RSS feeds (with geotagging where available) on pretty much everything, commenting system (with akismet integration) on everything (polymorphic)…..

I probably forgot a few things there. Point is all this comes in at 6353 lines of code. It takes me under 30 seconds to update my website via Capistrano and Subversion.

PHP sucks balls. I know because I used it for three years. No PHP framework will ever turn me back to the shit side of the force!

I won’t say much till i start deploying my app, but i have a gut feeling that it will be just fine, even if it takes a little while to get the hang of it. I am not taking anyones side here, however i feel Rails is definitely a complete framework that cannot be ignored or tainted by ignorant people.

What is Capistrano? Jamis Buck is the author of the Capistrano remote-administration utility, and is currently employed by 37signals.

Any web developer will know how important a database and its relationship can be to their web application. With that being said i would like to introduce you to Active Record.  Active Record is a Ruby library that allows your Ruby programs to transmit data and command to and from various data stores, which are usually relational databases.  You can also say that Active Record allows Ruby to work with databases.

Brief History behind Active Record

Active Record is a design pattern originally published by Martin Fowler in his book Patterns of Enterprise Application Architecture.  David Heinemeier Hansson (the creator of the Rails framework) took the concepts laid out by Mr. Fowler and implemented them as a Ruby library called Active Record.

Active record has been released with the Rails framework to the public and is also available as a part of the core bundle with its own Ruby Gem.

Active Record and the ORM Pattern

At the core of Active Record is object relational mapping or “ORM.”  These relational databases can be represented well by object based code; if we look at an example of a dummy accounts table in a typical database it would look like this:

Accounts table
     ID field (integer; auto-incremented; primary key)
     Username field (text type field)
     Password field (text type field)

If we look at the Active Record Account class (or model) it would look something like this:

Class Account ActiveRecord::Base
#some code here
end

If we look through our Rails code, we could possible create instances of different account objects like below:

# creates a new account object in memory and a new account record in our database
newacc = Account.new
newacc.Username = "Ahad"
newacc.Password = "pass*$#"
newacc.save
# creates an Account object in memory from data in Account table with ID of 1
# (equivalent to the ANSI SQL statement of "select * from accounts where ID = 1")
findacc = Account.find(1)
# deletes records from database that have username of "Ahad"
Account.delete("username = 'Ahad'")

Active Record Differs from other ORM Libraries

Active record out of the box makes a number of configuration assumptions, without requiring any outside configuration files or mapping details.  The previous example takes advantage of Active Record Assumptions, so we are not required to to configure or set up any specific instructions.  This is unlike many ORM libraries such as Java’s Hibernate.

MVC Concepts and Active Record

Active Record is most famous as being an important part of the Ruby on Rails framework, and is being copied by many other frameworks such as Code Igniter.    What MVC does it that it breaks code into logical groupings and programs into logical functional groupings.  With Rails, the model section is generally your Active Record classes and other data-descriptive or datacommunication code. The view section remains primarily for the user interface, which tends to be a heavy dose of HTML in most Rails applications.

CRUD Database Transactions and Active Record

Ususally there are four tasks one can perform when working with databases, and as a group are referred ot as CRUD. 

1. (C): Creating 
2. (R): Retrieving
3. (U): Updating
4. (D): Deleting

newacc = Account.new(:username = "Ahad")
newacc.save # creates the new record in the account table
temp = Account.find(1)
# => selects the record associated with id of 1 from the account table
temp.username = 'Ahad' # => assigns a value to the username attribute of the object
temp.save # does the actual update statement applying the changes we just stated.
Account.destroy_all(1) # deletes the record in the account table with id of 1

There are many more options to that we can consider here, but the above is the most generic or the most common.

How the Active Record Library applies to Ruby code

What you have to remember is when working with Active Record is that its all Ruby code.  Anything you do with Ruby objects (inheritance, overriding methods, etc etc) can also be done with Active Record objects. The whole idea is to represent database records and objects, but they really are two separate things; Ruby onjects and database records.

Active Record:  The smart choice

There are many reasons why Active Record is the smart choice.  One is its easy to install, simple to write and read, and also a full feature object based code.  If you look below at the benefits of Acitve Record, there is no doubt that this library is worth learning about.

• Simplified configuration and default assumptions (Convention over Configuration).
• Associations among objects.
• Automated mapping b/w tables and classes and b/w columns and attributes.
• Data Validations.
• Callbacks
• Inheritance hierarchies.
• Direct manipulation of data as well as schema objects.
• Database abstraction through adapters.
• Logging support.
• Migration support.
• Active Record integrated in other emerging frameworks like Merb.

Man oh man am i excited about Rails.  I just wanted to give a special shout out to the Rails community and list some resources where you might learn from.

A Special Shout out to:

Amy Hoy:  Amy is an interface designer and developer from Maryland.  She has an attractive style of writing and gives alot of information about Rails + interface design on her blog at Slash7.  Check her out, you won’t regret it => she has some great content and cheat sheets.

RubyAdvent:  An Advent calender type for the Rails community.  I especially liked this post:  Generating (Real) Fake Content. but don’t take my word for it head over and check it out yourself and give up some of that comment love.  The RubyAdvent is written by Lakshan Perera.  You can visit his blog here: http://www.web2media.net/laktek/ 

Andy Jeffries:  A professional Zend Certified Engineer and was the first person that recommended Rails to me. At that time (not too long ago) I was hunting around for info on PHP frameworks namely Symfony and CakePHP. Read some of his posts here:

• Why I think Ruby on Rails is an ideal web development environment.
• Design Patterns vs Agile Development.
• Rebuilding a site from Symfony to Rails.
• 4 Reasons Why Ruby Syntax Is Better Than PHP’s.

Rails Screencasts:

1. https://peepcode.com/
2. http://railscasts.com
3. http://envycasts.com/products  
4. http://www.rubyonrails.org/screencasts