In our previous set of Videos, we have covered basics of a Web Application, MVC architecture and also basic introduction to Ruby and Rails.
In this post, we have videos which explain certain tools which can be used to speed up our development process. They are:
Command Line
Text Editor
Rails & Ruby Overview
Command Line
Summary:
We use Terminal in Mac, Command prompt in Windows and X-terminal in Unix/Linux. In windows, we can access this by going to ‘Start’ button, then ‘Run’ and then type ‘cmd’. The author explains how to use Command Line to navigate between files and Rails files in particular and also to check the version of Rails installed and some commands to operate Rails from command line. It would be dealt with detail in the coming videos.
Text Editor
Summary:
The author explains the working of Text-Mate, a text editor used extensively by Programmers on Mac OS. Since I don’t use Text-Mate, I have no summary to offer 🙂 . Windows text-editors are explained in Installation of Rails on Windows videos.
Ruby language is a scripting language developed by a Japanese in 1990’s. Installation of Ruby on Windows is a simple Double-click which will be dealt in detail in coming videos.
Rails framework installation is also discussed in coming videos. After its installation, Rails framework is saved in a particular file format which will also be discussed later.
Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.
In this post, the following Concepts are explained
Web Applications and Rails
What Rails can Do
Where Rails Came From
Rails Philosophies
More Rails Philosophies
MVC
Model
View Part 1
View Part 2
Controller
Web Applications and Rails
Summary:
Basic introduction to Web applications in general. The architecture of Web browser(Cleint) and Server(which also includes a Database) is explained. Model-View-Controller architecture of Rails is also explained very well. A must see for newbies.
What Rails can Do
Summary:
Examples of usages of Ruby on Rails in some of the Deployed and running web applications. The author also explains a web app he had developed with Rails (Please dont be upset with the layout of this app, the functionality matters ). The app developed by him shows the power of Rails prototyping at a much faster rate compared to other frameworks. He also goes on to explain different Rails website showcased on Rubyonrails official website.
Where Rails Came From
Summary:
This explains the background for the development for Ruby on Rails. A company based out of Chicago by name 37Signals hired a smart developer from Denmark by name David Heinemeier Hansson to work on a Collaborating Web-app Basecamp . Because of the Geographical distance between them, an interesting Design pattern and philosophy was developed which has crept its way into Ruby on Rails. Rails has been extracted into a framework from a product (BaseCamp), which is not quite the usual case. The author also recommends to watch the Video presentation by David on Rails and its background.
One piece of information should be present only at a single place. Most of the code should be placed only once in specific places based on MVC paradigm. This makes the code highly efficient and easy to maintain.
Rails follows certain Conventions, that is it has defaults for most aspects of putting together a web application. If you follow these conventions, you can develop Web apps rapidly not bothering about a lot of Configurations which you would otherwise do in Java or normal PHP. This also makes your code base very minimal
More Rails Philosophies
Summary:
Another philosophy behind Rails is Agile Development. It emphasizes more on important things rather than conventional standards. In the following list, the items in bold text have emphasis over the normal text.
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan
MVC
Summary:
A brief history and introduction to MVC architecture. The pattern was first described in 1979 by Trygve Reenskaug, then working on Smalltalk at Xerox PARC
The components of MVC are Model-View and Controller.
Model maintains the state of your application.
View is responsible for generating User Interface through which a website user interacts with it
Controller can be perceived as the part which controls and co-ordinates the View and Model.
In Rails, M-V-C files are under separate folders and Model and Controller files have .rb extension whereas View files have a .rhtml(html with Ruby Code embedded) or .rjs (JavaScript embedded with Ruby Code).In Rails, the MVC works as follows.
A URL from Web-browser interacts with a Controller (not a View directly). Controller then interacts with Model which makes queries into the Database. The Database replies with the output to Model which will return to Controller in the form of Object Oriented array, which can be manipulated and then sent to the View which renders the html and Javascript on the Web-browser.
Model
Summary:
Model interacts with database and maintains state of the database in a Rails Application. In Rails, we extensively use Active Record which is a ORM (Object-Relational Mapping ) mechanism. Every model-class in Rails app corresponds to a Table in our Database. Every attribute in a model-class is mapped to a column in the corresponding database table. All these are done automatically once you instantiate a Model (Thanks to Rails, which takes care of this headache ). Author also shows and explains some Code of a model class. The ActiveRecord is intelligent enough to update itself with any Database changes you make. So it truly uses DRY i.e you dont have to make any changes in the Model file after you make changes in the Database. He also explains the syntax of a Model file(tech.rb), which is
[sourcecode language=’ruby’]
class Tech < ActiveRecord::Base #Tech as a subclass of ActiveRecord Class
has_many: work_requests # one to many mapping, work_requests is another model-class
has_many: assigned_teches
has_many: work_requests_notes
def self.login(name,password)
find(:first, :condtions => [“name = ? and password = ?”, name, password])
end
def try_to_login
Tech.login(self.name, self.password)
end
end
[/sourcecode]
View Part 1
Summary:
View is the Part of the MVC architecture which renders or parses the generated html and javascript code to the Browser. Compared to Model and Controller files(.rb) which are Classes and have only Ruby code in them, View files(.rhtml or .rjs) have html and/or javascript code and have Ruby code embedded in them between <% …some ruby code…%>
The author shows and explains a simple Recipe list which has Recipes with add/edit/delete and search functionalities. He goes through the Controller code which will in-turn parse to View to render html to browser. Name of the Controller file and Controller class are related and is generated by Rails. In this example, the controller’s class name is RecipeController and the controller file name is recipe_controller.rb , which is as follows
[sourcecode language=’ruby’]
class RecipeController < ApplicationController # Subclass of ApplicationController
def list #function or method. An important convention is that it parses a view file by the same name. i.e list.rhtml and is not explicitly mentioned
@all_recipes = Recipe.find(:all) #It finds all the recipes and stores in instance variable 'all_recipes'
end
def view
@a_recipe = Recipe.find(params[:id]) #it finds a recipe with a given id
@all_recipes = Recipe.find(:all) #It finds all the recipes
end
def show_add_recipe
end
def search
title = "%" + @params[:title] + "%"
@all_recipes = Recipe.find(:all, :condtions=>[“title like ?”, title])
end
From the previous Video, we look at list.rhtml. It is called by ‘list’ method/function in RecipeController class. The beauty of Rails is that you dont have to specify the name of the View file, its convention is to have the Controller class name itself. In this case it is list.rhtml whose content is as follows
[sourcecode language=’html’]
Recipe List
<%= flash[:notice] %>
<%= render(:partial => ‘the_list”)%>
[/sourcecode]
In the above snippet of code, the major part is normal html. The Ruby code is put between <% …some code … %> if its not printing anything on the browser . If you are outputting or printing something, we use <%= ..some code.. %>.
The line <%= render(:partial => “the_list”) %> renders another view, in this case its a partial view. The partial views can only be called from main views and hence can be used repeatedly at many places. The partial view file is named _the_list.rhtml . There is an underscore before the file name to distinguish it as a partial view. The contents of ‘_the_list.rhtml’ file is as follows
@all_recipes which is parsed from RecipeController is taken on a Loop.
On every iteration, variable ‘a_recipe’ is rendered in a new table-row.
To print the title of a recipe, we use a_recipe.title and similarly for description, we use a_recipe.description.
In <%= link_to ‘View Recipe”, action=> ‘view’, :id=> a_recipe %> , link_to is a Ruby function which builds an anchor or link with text “View Recipe” and clicking on it will trigger ‘view’ function in RecipeController and parses ‘id’ as an argument.
<%= render(:partial => “search_form”) %> will render “_the_search_form.rhtml” file
Controller
Summary:
Controller can be thought of a co-ordinator between a model and a view. A controller is usually called by a URL from the web-browser. Say there is a URL request of http://0.0.0.0:3000/recipe/list , it directly goes to controller recipe, whose filename is recipe_controller.rb and whose class name is RecipeController. All these would seem a bit confusing at first, but once you are familiar with the conventions, it would be a cake walk in future. The next part of the url after the controller name is ‘list’, which is the function name inside ‘recipe’ controller.
Lets explore ‘recipe_controller.rb’ file
[sourcecode language=’ruby’]
class RecipeController < ApplicationController # Subclass of ApplicationController, Class is i
def list #function or method. An important convention is that it parses a view file by the same name. i.e list.rhtml and is not explicitly mentioned
@all_recipes = Recipe.find(:all) #It finds all the recipes and stores in instance variable 'all_recipes'
end
def view
@a_recipe = Recipe.find(params[:id]) #it finds a recipe with a given id
@all_recipes = Recipe.find(:all) #It finds all the recipes
end
def show_add_recipe
end
def search
title = "%" + @params[:title] + "%"
@all_recipes = Recipe.find(:all, :condtions=>[“title like ?”, title])
end
In the following snippet of code, RecipeController class is made a sub-class of ApplicationController, meaning it derives all the properties of ApplicationController (Inheritance property of OOP). The class should always be terminated by ‘end’
[sourcecode language=’ruby’]
class RecipeController < ApplicationController
.....
.....
end
[/sourcecode]
In the following snippet of code, 'list' is a function/method. It is defined by keyword 'def' followed by its name. It is terminated by 'end'. Whatever is in between them is executed upon calling the function. In this case, there is a ActiveRecord Model named 'Recipe'. Recipe.find(:all) will interact with recipe corresponding table in database and get all the rows. The relational data from database is converted into Object by ActiveRecord and it is assigned to instance variable @all_recipes in the form of an array. Once this is done, the function will then call the view file with the same name as its, and parse the instance variables. In this case, it would be 'list.rhtml' as we had covered in the previous video summary.
[sourcecode language='ruby']
def list
@all_recipes = Recipe.find(:all)
end
[/sourcecode]
Since a Controller is the co-ordinator for Views and Models, if we have less code in View and more in Controller, it would become easy to maintain and update the code.
Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.
Rails Framework: Rails framework is a series of Ruby Code written to develop a Web application, making Rapid Web application development very straight forward. “Ruby on Rails was extracted by David Heinemeier Hansson from his work on Basecamp, a project management tool by the web design (now web application) company 37signals“
What this Tutorial will Cover ?
Summary:
This is again intended for Novice learners. In this video, a outline or the Things to be covered in Tutorial Set has been given, which is as follows.
What is Ruby on Rails? – A brief intro
Where did it come from ? – A brief history
How and what it does ?
How to install Rails on Windows/ Mac ?
What are different tools used for Development and Deployment ?
What are the programming constructs ?
How to build Database backed Applications ? – Usage of CRUD
What are the resources available ?
Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.
Finally I intend to begin my journey on Rails (Ruby on Rails). After searching for some quick resources to learn Rails fast, I came across a good number of them which would be shared in this post.
I am hoping I can learn Ruby on Rails faster for the following 2 reasons
Lets begin it this way. The first Google result for “Rails Video Tutorial” was Screencasts page from RubyOnRails official website. The 15 minutes Blog video is truly impressive, but it doesn’t really help a beginner much other than just making his/her jaw drop down. I would recommend if you go through this video after gaining some insight into RoR.
One of the other Google Search result was Virtual Training Company. They specialize in online courses for all Software/Web technologies. The set of Video tutorials for Ruby on Rails has been developed by Mr. Al Anderson . They have some Free online Videos and for the rest of the package you need to register by paying certain amount. If you have bucks, do get yourselves registered and checkout the high-quality videos.
As an alternative to these paid videos, these have been uploaded on Youtube. The main problem with these videos are that since Youtube reduces the quality of the Videos uploaded, you probably cannot clearly makeout the code being typed/shown. Another possible problem to view on Youtube is that these videos (90+ in number) are all Titled “Ruby on Rails”, so its quite painful to go in a particular order.
I shall try to embed these Youtube Videos in individual posts with a short summary of the Video with a Table of Content(List of all the individual videos) in this post.
Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.
Finally I intend to begin my journey on