Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:05:15Z

Mndsouza: /* External Links */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like '''<timestamp>_create_categories.rb'''. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>

===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549

<references/>

=External Links=
*[http://ruby.railstutorial.org/ Ruby on Rails Tutorial by Michael Hartl]
*[http://www.rubyonrailstutorials.com/ Ruby on Rails Tutorials]
*[http://www.buildingwebapps.com/learningrails Audio lessons on Rails]
*[http://rubyonrails.org/screencasts Video Lectures on Rails]
*[http://www.ruby-lang.org/en/downloads/ Installing Ruby]
*[http://rubyforge.org/projects/instantrails/ Installing Rails]

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:04:32Z

Mndsouza: /* References */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:04:15Z

Mndsouza: /* External Links */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like '''<timestamp>_create_categories.rb'''. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>

===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549

[8] Installing Ruby : http://www.ruby-lang.org/en/downloads/

[7] Installing Rails : http://rubyforge.org/projects/instantrails/

<references/>

=External Links=
*[http://ruby.railstutorial.org/ Ruby on Rails Tutorial by Michael Hartl]
*[http://www.rubyonrailstutorials.com/ Ruby on Rails Tutorials]
*[http://www.buildingwebapps.com/learningrails Audio lessons on Rails]
*[http://rubyonrails.org/screencasts Video Lectures on Rails]

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:02:04Z

Mndsouza: /* References */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like '''<timestamp>_create_categories.rb'''. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>

===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549

[8] Installing Ruby : http://www.ruby-lang.org/en/downloads/

[7] Installing Rails : http://rubyforge.org/projects/instantrails/

<references/>

=External Links=
[1] Ruby on Rails Tutorial by Michael Hartl : http://ruby.railstutorial.org/
[2] Ruby on Rails Tutorials : http://www.rubyonrailstutorials.com/
[3] Audio lessons on Rails : http://www.buildingwebapps.com/learningrails
[4] Video Lectures on Rails : http://rubyonrails.org/screencasts

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:01:41Z

Mndsouza: /* External Links */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like '''<timestamp>_create_categories.rb'''. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>

===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

[8] Installing Ruby : http://www.ruby-lang.org/en/downloads/

[7] Installing Rails : http://rubyforge.org/projects/instantrails/

=External Links=
[1] Ruby on Rails Tutorial by Michael Hartl : http://ruby.railstutorial.org/
[2] Ruby on Rails Tutorials : http://www.rubyonrailstutorials.com/
[3] Audio lessons on Rails : http://www.buildingwebapps.com/learningrails
[4] Video Lectures on Rails : http://rubyonrails.org/screencasts

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T18:01:29Z

Mndsouza: /* References */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like '''<timestamp>_create_categories.rb'''. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>

===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

[8] Installing Ruby : http://www.ruby-lang.org/en/downloads/

[7] Installing Rails : http://rubyforge.org/projects/instantrails/

=External Links=
[1] Ruby on Rails Tutorial by Michael Hartl : http://ruby.railstutorial.org/
[2] Ruby on Rails Tutorials : http://www.rubyonrailstutorials.com/
[3] Audio lessons on Rails : http://www.buildingwebapps.com/learningrails
[4] Video Lectures on Rails : http://rubyonrails.org/screencasts
[5]

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:53:53Z

Mndsouza: /* DB Migration */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:53:10Z

Mndsouza: /* Routing in Rails */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos || index || display a list of all photos
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos ||create|| create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] ||/photos/new || new || return an HTML form for creating a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods POST] || /photos || create || create a new photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id || show || display a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods GET] || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods PUT] || /photos/:id || update || update a specific photo
|-
| [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods DELETE] || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:49:04Z

Mndsouza: /* CRUD */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. '''Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model'''. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:48:32Z

Mndsouza: /* Object relational Mapping */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to '''Rails classes'''
# Database records (rows) correspond to '''Rails objects'''.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:47:44Z

Mndsouza: /* Relationships */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the '''<timestamp>_create_recipes.rb''' migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:47:02Z

Mndsouza: /* Routes.rb */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The '''routes.rb''' file is located in the '''config folder'''. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:46:19Z

Mndsouza: /* Relationships */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the '''has_many''' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a '''db:migrate'''.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:45:37Z

Mndsouza: /* Creating Recipes */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a '''db:migrate''', so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a db:migrate.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:45:19Z

Mndsouza: /* Creating Categories */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is '''localhost:3000/categories/new'''. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.

===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a db:migrate.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:44:04Z

Mndsouza: /* Don't repeat yourself */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that ''information should not be repeated''. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a db:migrate.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:43:31Z

Mndsouza: /* Model/View/Controller Framework */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to '''real world entities'''. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a '''human interface(GUI)''' for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the '''user actions''' and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a db:migrate.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-27T17:42:49Z

Mndsouza: /* Convention over Configuration */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the ''conventional part of the program will be specified by the framework itself''. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. We first want to say that each recipe belongs to a category. This can be done in the recipe controller as shown below :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>

Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :

<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

We also have to add a reference in the migration, to indicate that the recipes table references the categories table. This can be done in the <timestamp>_create_recipes.rb migration, and now it would look like :

<pre>
class CreateRecipes < ActiveRecord::Migration
def change
create_table :recipes do |t|
t.string :title
t.string :description
t.text :instructions
t.references :category
t.timestamps
end
end
end
</pre>

As before, since we have made a change to the migration, we now need to do a db:migrate.
<pre>
rake db:migrate
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==
Now that the major portion of the application has been done, let us talk about Views and Layouts.
First, let us add the following code to application.html.erb in the app\views\layouts folder.

<pre>
<%= link_to "Show all recipes", recipes_url %> <%= link_to "Show all categories", categories_url %>
</pre>

Now, when we start the rails server, we see the following page :

[[File:6.jpg]]

Since we want the user to choose a category for each recipe, we include the following code in our view (in the recipes\_form.html.erb in the views section of our app) :

<pre>
<%= f.label :category %>
<%= select("recipe", "category_id", Category.find(:all).collect{ |c| [ c.name, c.id] }) %>
</pre>

The view now would have a drop box to choose which category and the user can write the recipe for that category. The new recipe page would now look like :

[[File:7.jpg]]

The CookBookApp now can have many categories, and recipes for each category. Note that we just used a few commands : scaffold, db:migrate, etc. to create this application. Since rails uses the Convention over Configuration principle, it makes it easier to write applications.

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-20T03:26:59Z

Mndsouza: /* References */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text category:references
</pre>
The category:references creates a line 'belongs_to :category' in the Recipe model. The Recipe model now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. When we created recipes by scaffolding, the 'category:references' made sure that the Recipes model has the 'belongs_to' relationship with Category. Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :
<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails, ISBN:1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-20T03:26:42Z

Mndsouza: /* References */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text category:references
</pre>
The category:references creates a line 'belongs_to :category' in the Recipe model. The Recipe model now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. When we created recipes by scaffolding, the 'category:references' made sure that the Recipes model has the 'belongs_to' relationship with Category. Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :
<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

[6] Sam Ruby, Agile Web Development with Rails ISBN: 1934356549
<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-20T03:17:41Z

Mndsouza: /* References */

''' The CookBook Application (Lecture 9)'''
=Introduction=
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.Rails includes a simple light weight application server [http://en.wikipedia.org/wiki/WEBrick Webrick] and a build system [http://en.wikipedia.org/wiki/Rake_(software) Rake] which makes development on rails easy.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration] states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code. Also in ActiveRecord there is no need to specify attribute names since it is picked up from the database tables itself.

==Model/View/Controller Framework==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecords allow a Rails program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

=Developing the Cookbook App=
We now will look into how to develop the cookbook application, and talk about how to get started with the same.
To get started, we first create a new rails project called say 'CookBookApp', which is done by simply running the command :
<pre>
rails new CookBookApp
</pre>
Once this is run, a series of folders are created, like app, config, db, etc. In developing the cookbook app, we will mainly look into the app, config and db folders mainly.
==Scaffolding==
[http://en.wikipedia.org/wiki/Scaffold_%28programming%29 Scaffolding] is a very powerful command that creates code to create, read, update and delete (CRUD) data from the database. In the Cookbook application, the first scaffold is to create categories. Each Category will then have multiple recipes, and the main functionality of our cookbook app would be done.
The scaffold command to create categories is done by simply giving the command :
<pre>
rails generate scaffold category name:string
</pre>
As seen, this generates the model called category, a bunch of views, and a category controller.
It also generates a migration, to create a new table called categories (notice that rails called the table as categories, which is the plural of category automatically).
===DB Migration===
The scaffold command generates a lot of files, and also a migration in db\migrate with a name like <timestamp>_create_categories.rb. This migration contains the details of the table that has to be created called 'categories', so the next step is to run the migrations. Before we do this, however, if we start the rails server, we get an error mentioning that the table 'categories' doesn't exist.
Let us now run the migration using the command :
<pre>
rake db:migrate
</pre>
After the migration is run, we know that the categories table has been created, and now run the server.
<pre>
rails server
</pre>
===Creating Categories===
Now, if we goto the default localhost:3000 page, we see one option : Create a new category, as shown below.

[[File:2.jpg]]

We can click on it, and make a new category, lets say 'Main Course'

[[File:3.jpg]]

When clicking on a new category notice that the URL is localhost:3000/categories/new. So we are executing the new method of the categories controller. On clicking 'Create Category', a new category with the name 'Main Course' is created, and a flash notice saying 'Successfully Create' is shown. We can now see the category in our list of categories.

[[File:5.jpg]]

So, as we saw, with just a simple scaffold command and db:migrate, we have an application with the basic CRUD functionality.
===Creating Recipes===
Now, similar to creating categories, we create recipes using the scaffold command.
<pre>
rails generate scaffold recipe title:string description:string instructions:text category:references
</pre>
The category:references creates a line 'belongs_to :category' in the Recipe model. The Recipe model now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
end
</pre>
Once this is done, we again have to run a db:migrate, so that the recipes table is in the database.
<pre>
rake db:migrate
</pre>
Now, the recipes have been created, and as seen in the recipe model, each recipe belongs to a category.

==Relationships==
Relationships are always defined in the model. When we created recipes by scaffolding, the 'category:references' made sure that the Recipes model has the 'belongs_to' relationship with Category. Similarly, we want to add a detail mentioning that each Category can have many Recipes : a one to many relationship. To do this, we need to edit the Category model, and include the 'has_many' relationship with Recipe. The Category model now looks like :
<pre>
class Category < ActiveRecord::Base
has_many :recipes
end
</pre>

==Valdations==
Validations, just like Relationships, are also defined in the model. Suppose we want to make sure that each recipe entered has a valid title and instructions, and the condition being that they cannot be empty. We can add this to the Recipe model, which now looks like :
<pre>
class Recipe < ActiveRecord::Base
belongs_to :category
validates :title, :presence => true
validates :instructions, :presence => true
validates :category, :presence => true
end
</pre>
Thus, the title, instructions and category are all validated, and it makes sure that title and instructions are not empty, and that the category it belongs also exists.

==Routes.rb==
The routes.rb file is located in the config folder. routes.rb, as the name suggests is used to route to the corresponding controller's method. Suppose we have defined a new method in the Category controller. Now, if we want to route a link to the Category controller's new method from some recipe view, we have to include this in the routes.rb file. If we don't, we get an error saying 'No route matches ...'. Whenever we decide to add a new method to a controller, we have to add something similar to :
<pre>
match 'Controller_name/new_method_name' => 'Controller_name#new_method_name'
</pre>
Our application starts are localhost:3000\categories. Suppose we want to have the root localhost:3000 to the index method in the category controller, we can do:
<pre>
root :to => 'categories#index'
</pre>
This has to be done after deleting the index.html file from the public directory.

==Views & Layouts==

=References=
[1] Ruby on Rails Guides: Getting Started With Rails :http://guides.rubyonrails.org/getting_started.html

[2] CookBookApp : http://courses.ncsu.edu/csc517/common/exercises/cookbook3/

[3] CSC 517 Fall 2011 : Engineering Online Video : http://mediasite.online.ncsu.edu/online/Viewer/?peid=5a5b4de717dc4108a1b04133575b22181d

[4] Course Schedule, and Lecture #9 Materials : http://www.csc.ncsu.edu/faculty/efg/517/f11/lectures

[5] Ruby on Rails official site : http://rubyonrails.org/

<references/>

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:09:22Z

Mndsouza: /* References */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:08:58Z

Mndsouza: /* Object relational Mapping */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:06:27Z

Mndsouza: /* Don't repeat yourself */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:04:20Z

Mndsouza: /* Convention over Configuration */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:03:58Z

Mndsouza:

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T04:03:03Z

Mndsouza: /* Introduction */

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:56:37Z

Mndsouza:

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:56:11Z

Mndsouza:

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:53:35Z

Mndsouza: /* Routing in Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

===Ruby on Rails===
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
====Convention over Configuration====
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

====Don't repeat yourself====
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

===Model/View/Controller Framework===
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

===CRUD===
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

===Routing in Rails===
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

===Object relational Mapping===
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query Interface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:52:14Z

Mndsouza: /* Routing in Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==Model/View/Controller Framework ==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo
|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:51:31Z

Mndsouza: /* Routing in Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==Model/View/Controller Framework ==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET || /photos || index || display a list of all photos
|-
| GET || /photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos ||create|| create a new photo
|-
| GET ||/photos/new || new || return an HTML form for creating a new photo
|-
| POST || /photos || create || create a new photo
|-
| GET || /photos/:id || show || display a specific photo
|-
| GET || /photos/:id/edit || edit || return an HTML form for editing a photo
|-
| PUT || /photos/:id || update || update a specific photo
|-
| DELETE || /photos/:id || destroy || delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:49:07Z

Mndsouza: /* [Model/View/Controller Framework http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller ] */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==Model/View/Controller Framework ==
All Rails applications are implemented using the [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller] (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
|-
| GET | /photos/new | new | return an HTML form for creating a new photo
|-
| POST | /photos |create| create a new photo
|-
| GET |/photos/new| new| return an HTML form for creating a new photo|
|-
| POST |/photos |create |create a new photo|
|-
| GET |/photos/:id |show |display a specific photo|
|-
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
|-
| PUT |/photos/:id| update |update a specific photo
|-
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:46:46Z

Mndsouza: /* Model/View/Controller Framework */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[Model/View/Controller Framework http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller ]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
|-
| GET | /photos/new | new | return an HTML form for creating a new photo
|-
| POST | /photos |create| create a new photo
|-
| GET |/photos/new| new| return an HTML form for creating a new photo|
|-
| POST |/photos |create |create a new photo|
|-
| GET |/photos/:id |show |display a specific photo|
|-
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
|-
| PUT |/photos/:id| update |update a specific photo
|-
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:46:30Z

Mndsouza: /* CRUD */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller Framework]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==CRUD==
[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD] stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
|-
| GET | /photos/new | new | return an HTML form for creating a new photo
|-
| POST | /photos |create| create a new photo
|-
| GET |/photos/new| new| return an HTML form for creating a new photo|
|-
| POST |/photos |create |create a new photo|
|-
| GET |/photos/:id |show |display a specific photo|
|-
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
|-
| PUT |/photos/:id| update |update a specific photo
|-
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:31:15Z

Mndsouza: /* Routing in Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller Framework]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
|-
| GET | /photos/new | new | return an HTML form for creating a new photo
|-
| POST | /photos |create| create a new photo
|-
| GET |/photos/new| new| return an HTML form for creating a new photo|
|-
| POST |/photos |create |create a new photo|
|-
| GET |/photos/:id |show |display a specific photo|
|-
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
|-
| PUT |/photos/:id| update |update a specific photo
|-
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:29:34Z

Mndsouza: /* Ruby on Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===Convention over Configuration===
[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===Don't repeat yourself===
[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller Framework]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
| POST | /photos |create| create a new photo
| GET |/photos/new| new| return an HTML form for creating a new photo|
| POST |/photos |create |create a new photo|
| GET |/photos/:id |show |display a specific photo|
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
| PUT |/photos/:id| update |update a specific photo
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:24:51Z

Mndsouza: /* Ruby on Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]===
Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself]===
Don't repeat yourself states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller Frame work]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[ http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
| POST | /photos |create| create a new photo
| GET |/photos/new| new| return an HTML form for creating a new photo|
| POST |/photos |create |create a new photo|
| GET |/photos/:id |show |display a specific photo|
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
| PUT |/photos/:id| update |update a specific photo
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:22:54Z

Mndsouza: /* Ruby on Rails */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby programming language]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===[http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]===
Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===[http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself]===
Don't repeat yourself states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[Model/View/Controller Frame work http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller ]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[CRUD http://en.wikipedia.org/wiki/Create,_read,_update_and_delete ]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
| POST | /photos |create| create a new photo
| GET |/photos/new| new| return an HTML form for creating a new photo|
| POST |/photos |create |create a new photo|
| GET |/photos/:id |show |display a specific photo|
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
| PUT |/photos/:id| update |update a specific photo
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:21:26Z

Mndsouza: /* [Convention over Configuration http://en.wikipedia.org/wiki/Convention_over_configuration ] */

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [Ruby programming language http://en.wikipedia.org/wiki/Ruby_(programming_language)]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===[Convention over Configuration http://en.wikipedia.org/wiki/Convention_over_configuration]===
Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.

===[Don't repeat yourself http://en.wikipedia.org/wiki/Don't_repeat_yourself ]===
Don't repeat yourself states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[Model/View/Controller Frame work http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller ]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[CRUD http://en.wikipedia.org/wiki/Create,_read,_update_and_delete ]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
| POST | /photos |create| create a new photo
| GET |/photos/new| new| return an HTML form for creating a new photo|
| POST |/photos |create |create a new photo|
| GET |/photos/:id |show |display a specific photo|
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
| PUT |/photos/:id| update |update a specific photo
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:21:00Z

Mndsouza:

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [http://en.wikipedia.org/wiki/Web_application_framework open source web application framework] for the [Ruby programming language http://en.wikipedia.org/wiki/Ruby_(programming_language)]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===[Convention over Configuration http://en.wikipedia.org/wiki/Convention_over_configuration ]===
Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.
===[Don't repeat yourself http://en.wikipedia.org/wiki/Don't_repeat_yourself ]===
Don't repeat yourself states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[Model/View/Controller Frame work http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller ]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[CRUD http://en.wikipedia.org/wiki/Create,_read,_update_and_delete ]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
| POST | /photos |create| create a new photo
| GET |/photos/new| new| return an HTML form for creating a new photo|
| POST |/photos |create |create a new photo|
| GET |/photos/:id |show |display a specific photo|
| GET |/photos/:id/edit |edit |return an HTML form for editing a photo
| PUT |/photos/:id| update |update a specific photo
| DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011/ch4 4d mt

2011-10-15T03:17:46Z

Mndsouza: Created page with "''' The CookBook Application (Lecture 9)''' ==Introduction== Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the p..."

''' The CookBook Application (Lecture 9)'''
==Introduction==
Lecture 9 talks about creation of the Cookbook application. This is a basic web application which demonstrates the power and ease of use of Ruby on Rails for web development. This article first introduces Rails and its key features and then takes us through the steps for creation of the Cookbook application.

==Ruby on Rails==
Ruby on Rails, is an [open source web application framework http://en.wikipedia.org/wiki/Web_application_framework] for the[ Ruby programming language http://en.wikipedia.org/wiki/Ruby_(programming_language)]. It was first released to the public in July 2004 and is now become the standard Web-development framework for Ruby. The Rails framework is built on the following 2 key principles:
===[ http://en.wikipedia.org/wiki/Convention_over_configuration Convention over Configuration]===
Convention over Configuration states that the conventional part of the program will be specified by the framework itself. So the programmer needs to concentrate only on the core logic of the program and the unconventional aspects of the program .Rails implements this by providing features like Rails scaffold and Rails generate which help us generate the basic framework of our application with minimal coding.
===[ http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself]===
Don't repeat yourself states that information should not be repeated. This applies to both data as well as code. Rails allows us to specify relational databases and queries in the form of object models using migrations and ActiveRecord. This helps us port applications across databases without any changes in code

==[ http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model/View/Controller Frame work]==
All Rails applications are implemented using the Model/View/Controller (MVC) architecture. MVC architecture is a software engineering concept that allows us to isolate the application logic from the user interface. This allows us implement these separate the development ,testing and maintainence of the application logic and the UI.
Key components of MVC architecture include:
# Models : These are objects that map to real world entities. They contain the application logic and provide persistence storage by interfacing with the database. Models in Rails are implemented using ActivedRecord objects.
#Views: Views provide a human interface(GUI) for the model. Views in Rails are implemented using embedded ruby (.html.erb) files
#Controllers: Controllers process the user actions and help redirect to the appropriate model ,build a user response and update the View.
The typical user interaction on a Rails application happens as follows:
#The user responds to the UI (ex : clicks a button)
#The router routes the action to the appropriate controller and action in it
#The controller calls the model. The model may changes state depending on the call(Ex: The model may update its values based on user entered data
#A view queries the model and uses its data to build a response .
#The view updates the UI with the view and waits for further user interaction.

==[ http://en.wikipedia.org/wiki/Create,_read,_update_and_delete CRUD]==
CRUD stands for create, read, update and delete (CRUD) the four basic functions of persistent storage. CRUD also relates to the UI for most applications. Almost every model obect must have following features and a UI to acess them:
#Create or add new entries
#Read, retrieve, search, or view existing entries
#Update or edit existing entries
#Delete existing entries
Due to the fundamental nature of these features, Rails provides readymade implementation for them in the form of Scaffolding. Scaffolding creates migrations,model,controller and View by only specifying the attributes of the model. Once the CRUD functionality has been generated by Rails, it can be modified to suit requirements.

CRUD is also relevant at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:
Without at least these four operations, the software cannot be considered complete. Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as "contact management" or "contact maintenance" (or "document management" in general, depending on the basic storage unit for the particular application).

==Routing in Rails==
Rails provides recourseful routing. This allows us to quickly specify the common routes for a resourceful controller( ie one that implements the CRUD functionality). Since CRUD featuresare common across entities, a single line in routes.db ex:
resources :photos
can allow us to specify 7 routes for the application.
{| class="wikitable"
|-
! HTTP Verb
! Path
! action
! used for
|-
| GET | /photos | index | display a list of all photos
| GET | /photos/new | new | return an HTML form for creating a new photo
|POST| /photos |create| create a new photo
|GET |/photos/new| new| return an HTML form for creating a new photo|
|POST |/photos |create |create a new photo|
|GET |/photos/:id |show |display a specific photo|
|GET |/photos/:id/edit |edit |return an HTML form for editing a photo
|PUT |/photos/:id| update |update a specific photo
|DELETE |/photos/:id |destroy |delete a specific photo|}

Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. Instead of declaring separate routes for your index, show, new, edit, create, update anddestroy actions, a resourceful route declares them in a single line of code.

resources :photos
creates seven different routes in your application, all mapping to the Photos controller:

==Object relational Mapping==
Rails handles Object Relational mapping using Active Records. ActiveRecors allow a Railds program to deal with objects and itself handles the mapping of these objects to relational databases. In Active Record,
# Database tables correspond to Rails classes
# Database records (rows) correspond to Rails objects.
ActiveRecord also allow us to query the database in the object domain by using the Active Record Query INterface

CSC/ECE 517 Fall 2011

2011-10-15T03:17:11Z

Mndsouza:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:37:26Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach<ref>[http://www.robdavispe.com/free2/software-qa-testing-test-tester-2229.html Davis, Rob. "What Is the Difference Between Top Down and Bottom up Design?" N.p., 2001. Web.]</ref> of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, the print_file returns an integer which represents success. By using return a called block can return a value to the scope of the calling block.

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

int print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/
if(!ifp)
return -1;
while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/
return 0;
}

void main()
{
char *name;
int success;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

success = print_file(name); /*Function call made to print_file() to print the file*/
if(success == -1)
printf("\n Error opening file");
}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features<ref>[http://www.jvoegele.com/software/langcomp.html Voegele, Jason. "Programming Language Comparison." Web.]</ref>
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C++, C#, VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

E.g. C++ program demonstrating the use of a class .
The class CRectangle represents a rectangle and has data members x,y which represent the length and breadth (ie: properties) of the rectangle. The functions set_values() and area() allow us to access these data members in a controlled manner. The class object has been instantiated in function main
<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data.<ref>[http://c2.com/cgi/wiki?GlobalVariablesAreBad Global Variables Are Bad]</ref> The access to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.<ref>[http://www.cs.bgsu.edu/maner/domains/RAD.htm Maner, Walter. RAPID APPLICATION DEVELOPMENT. N.p., 15 Mar. 1997. Web.]</ref> <ref>[http://www.chillarege.com/authwork/TestingBestPractice.pdf Chillarege, Ram. "Software Testing Best Practices." N.p., 26 Apr. 1999. Web.]</ref>
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:30:52Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features<ref>[http://www.jvoegele.com/software/langcomp.html Voegele, Jason. "Programming Language Comparison." Web.]</ref>
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C++, C#, VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

E.g. C++ program demonstrating the use of a class .
The class CRectangle represents a rectangle and has data members x,y which represent the length and breadth (ie: properties) of the rectangle. The functions set_values() and area() allow us to access these data members in a controlled manner. The class object has been instantiated in function main
<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data.<ref>[http://c2.com/cgi/wiki?GlobalVariablesAreBad Global Variables Are Bad]</ref> The access to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.<ref>[http://www.cs.bgsu.edu/maner/domains/RAD.htm Maner, Walter. RAPID APPLICATION DEVELOPMENT. N.p., 15 Mar. 1997. Web.]</ref> <ref>[http://www.chillarege.com/authwork/TestingBestPractice.pdf Chillarege, Ram. "Software Testing Best Practices." N.p., 26 Apr. 1999. Web.]</ref>
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:30:08Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features<ref>[http://www.jvoegele.com/software/langcomp.html Voegele, Jason. "Programming Language Comparison." Web.]</ref>
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C++, C#, VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

E.g. C++ program demonstrating the use of a class .
The class CRectangle represents a rectangle and has data members x,y which represent the length and breadth (ie: properties) of the rectangle. The functions set_values() and area() allow us to access these data members in a controlled manner. The class object has been instatiated in function main
<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.<ref>[http://www.cs.bgsu.edu/maner/domains/RAD.htm Maner, Walter. RAPID APPLICATION DEVELOPMENT. N.p., 15 Mar. 1997. Web.]</ref> <ref>[http://www.chillarege.com/authwork/TestingBestPractice.pdf Chillarege, Ram. "Software Testing Best Practices." N.p., 26 Apr. 1999. Web.]</ref>
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:29:34Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features<ref>[http://www.jvoegele.com/software/langcomp.html Voegele, Jason. "Programming Language Comparison." Web.]</ref>
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C++, C#, VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

*E.g. C++ program demonstrating the use of a class .
The class CRectangle represents a rectangle and has data members x,y which represent the length and breadth (ie: properties) of the rectangle. The functions set_values() and area() allow us to access these data members in a controlled manner. The class object has been instatiated in function main
<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.<ref>[http://www.cs.bgsu.edu/maner/domains/RAD.htm Maner, Walter. RAPID APPLICATION DEVELOPMENT. N.p., 15 Mar. 1997. Web.]</ref> <ref>[http://www.chillarege.com/authwork/TestingBestPractice.pdf Chillarege, Ram. "Software Testing Best Practices." N.p., 26 Apr. 1999. Web.]</ref>
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:28:33Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features<ref>[http://www.jvoegele.com/software/langcomp.html Voegele, Jason. "Programming Language Comparison." Web.]</ref>
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C++, C#, VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

E.g. C++ program demonstrating the use of a class .The class CRectangle represents a rectangle and has data members x,y which represent the length and breadth (ie: properties) of the rectangle. The functions set_values() and area() allow us to access these data members in a controlled manner. The class object has been instatiated in function main
<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.<ref>[http://www.cs.bgsu.edu/maner/domains/RAD.htm Maner, Walter. RAPID APPLICATION DEVELOPMENT. N.p., 15 Mar. 1997. Web.]</ref> <ref>[http://www.chillarege.com/authwork/TestingBestPractice.pdf Chillarege, Ram. "Software Testing Best Practices." N.p., 26 Apr. 1999. Web.]</ref>
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:22:09Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C# , VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]

CSC/ECE 517 Fall 2011/ch1 1e lm

2011-09-25T22:21:24Z

Mndsouza: /* Examples */

==Introduction==
This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

==Block structured languages==

===Definition===
A [http://en.wikipedia.org/wiki/Block_(programming) block] is a piece of code consisting of one or more [http://en.wikipedia.org/wiki/Declaration_(computer_science) declarations] and [http://en.wikipedia.org/wiki/Statement_(programming) statements]. A block structured programming language is the one that would allow usage of such blocks & including [http://en.wikipedia.org/wiki/Nesting_(computing) nesting] of such blocks.
The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

===Basic features===
*Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
*The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
*It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
*Functions are implemented as black-boxes with an input and output specification.

===Examples===
Some of the examples of these languages include Algol, C & Pascal.
*E.g. Pascal program multiply two numbers.
Here we can see that the block is delimited by "Begin" & "End" keywords

<nowiki>
Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real;

Begin
Writeln('Program to multiply 2 numbers:');
Writeln;
Writeln;
Write('Enter the Multilicand: ');
Readln(Multiplicand);
Writeln;
Write('Enter the Multiplier: ');
Readln(Multiplier);

Product := Multiplicand * Multiplier;
Writeln;
Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
+'to ',Product);

End.

</nowiki>

*E.g. C program to read a file line by line.
Here we can see that the blocks are delimited by the flower braces. We can also see the usage of global variable by the function print_file().
Also, we can see that in our case we explictly tell the main() not to expect any return value from the function print_file() with the help of keyword "void".

<nowiki>
#include<stdio.h>

FILE *ifp; /*File pointer which points to the file*/

void print_file(char *filename)
{
char line[80]; /*Assuming each line is 80 character in length*/
ifp = fopen(*filename, "r"); /*opens the file for "reading" mode only*/

while(fgets(line,1,sizeof(line),fp) /*Loop till no more lines to read*/
{
printf("%s", line); /*Prints this line on to the standard output*/
}
fclose(fp); /*Closes the file*/

}
void main()
{
char *name;

printf("Enter the name of the file to be opened: ");
scanf("%s", name);

print_file(name); /*Function call made to print_file() to print the file*/

}
</nowiki>

==Object Oriented Languages:==

===Definition===
Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an '''''Object'''''. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

===Fundamental features of Object Oriented languages===
*[http://en.wikipedia.org/wiki/Object_%28computer_science%29 Object]/[http://en.wikipedia.org/wiki/Class_%28computer_programming%29 Class]: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

*[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction]/[http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29 Encapsulation]: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

*[http://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29 Inheritance]: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird ''Peacock'' is a part of the class ''Flying bird'' which again is part of the class ''Bird''. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

*[http://en.wikipedia.org/wiki/Interface_%28Java%29 Interface]: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]/[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

===Examples===
The below languages implement different degrees of OO features
*Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
*Java, C# , VB.NET, Python are OO languages but have some degree of procedural elements
*Visual Basic, PHP, Perl are basically procedural languages with some OO features.

<nowiki>

#include <iostream>
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () ;
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

void CRectangle::area() {
return x*y;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
</nowiki>

==Need for Object Oriented Languages==
Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:
#Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of [http://en.wiktionary.org/wiki/tramp_data tramp data] being passed around.<ref> [http://en.wikipedia.org/wiki/Structured_programming#Object-oriented_comparison Object Oriented Comparison. Web. 8 June 2011.] </ref>
#As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
#In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
#Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
#Structured program suffered from memory leaks.<ref>[http://www.cprogramming.com/debugging/valgrind.html Using Valgrind to Find Memory Leaks and Invalid Memory Use]</ref> This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.
The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

==Advantages of Object-oriented languages over Block structured languages==
#Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>
#The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.<ref>[http://www.developer.com/design/article.php/3387591/Hiding-Data-within-Object-Oriented-Programming.htm Weisfeld, Matt. "Hiding Data within Object-Oriented Programming." N.p., 29 July 2004. Web.]</ref>
#Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.<ref>[http://www.artima.com/interfacedesign/SigObjects.html "Interface Design by Bill Venners." Web.]</ref>
#Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
#Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.
#Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
#Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection<ref>[http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html Paul, Javin. "Garbage Collection in Java." How Garbage Collection Works In Java. N.p., 11 Apr. 2011. Web. ]</ref>, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

==Drawbacks of Object-Oriented Languages==
Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.
#Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">[http://lucacardelli.name/Papers/BadPropertiesOfOO.html Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli]</ref>
#Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing.
#Also many OO languages include automatic garbage collection (e.g. Java) & hence it might slow down the performance.<ref>[http://www.jelovic.com/articles/why_java_is_slow.htm Why Java is slow Jelovic, Dejan. "Why Java Is Slow." Why Java Will Always Be Slower Than C++. N.p., 18 Dec. 2009. Web.]</ref>. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>[http://csjournals.com/IJCSC/PDF1-2/9..pdf Object Oriented Vs Procedural Programming in Embedded System ]</ref>

==Usage of block-structures in Object Oriented languages==
OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure are as follows:
*In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
*Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.
E.g. Java program demonstrating the usage of a while loop .The while loop encloses a group of statements within curly braces signifying a block that may be iterated upon till while condition holds true
<nowiki>
package hashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class ExampleHashMap
{
public static void main(String args[])
{
LinkedHashMap h = new LinkedHashMap(); //Creates a LinkedHashMap. Linked HashMaps defines the
h.put("A",100); //iteration ordering, which is normally the
h.put("B",200); //order in which keys were inserted into the map.
h.put("C",300);
h.put("D",400);
h.put("E",500);

Set s = h.entrySet(); //Returns a set containing key value pairs
Iterator i = s.iterator();

while(i.hasNext())
{
Map.Entry me = (Map.Entry)i.next(); //Each element in the set has to be casted to Map.Entry
System.out.println(me.getKey()+" : "+me.getValue()); //to access the key/value
}
}
}

</nowiki>
*OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks
E.g.: Try...catch blocks in Java
Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime. Also, we can see usage of conditional statements if...else in this case.
<nowiki>
try{
System.out.println("Inside try block of testMethod!");
int p=1000, q=0, i=0;
if(p>q){ //We can clearly see here that a Divide by Zero exception will occur.
i=p/q;
}
else if(q>p){
i=q/p;
}
else{ //In this case p equals q
i=p/q;
}
}
catch(Exception e){
System.out.println("Inside catch block of testMethod!");
System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
System.out.println("Inside finally block of testMethod!");
System.out.println(“This block executes everytime an exception is caught...”);
}
</nowiki>
*Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.
E.g.
Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example
<nowiki>
import java.awt.Button;

class Submit()
{
public Submit()
{
Button button1 = new Button("Submit");

button1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent event){
System.out.println("actionPerfomed is implemented as anonymous class here & is added as a listener to button1");
}
});
}
}

</nowiki>
*In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.]</ref>
E.g.
Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.
<nowiki>
def block_demo
yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
Hello Smith
</nowiki>

==Conclusion==
Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

==References==
<references/>

==External Links==
#[http://golang.org/ The Go Programming Language by Google for multicore and networked machines]
#[http://download.oracle.com/javase/tutorial/java/concepts/ Object Oriented Concepts (Java Tutorials)]
#[http://www.daimi.au.dk/publications/PB/230/PB-230.pdf Block Structure and Object Oriented Languages by Ole Lehrmann Madsen]
#[http://portal.acm.org/citation.cfm?id=356671 A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977) ]
#[http://ruby-lang.org Official Ruby Webpage]
#[http://www.pascal-programming.info/index.php Pascal programming tutorials]
#[http://steve-yegge.blogspot.com/2008/05/dynamic-languages-strike-back.html Dynamic Languages Strike Back]
#[http://amath.colorado.edu/computing/mmm/funcproc.html Functional vs Procedural languages]