Ruby on Rails - Bad Request - University of Calgary

<strong>Ruby</strong> on Rails
Mitchell Craig; Tam Nguyen; Becker Luu; Eliezer Mar Manarang; and Colin Williams
University of Calgary SENG 403 Dr. Kremer
Abstract—The proceeding document describes the <strong>Ruby</strong> on
Rails web application framework. A history is provided, along
with the founding Philosophies and Priciples, Technical Information,
Notable Applications and a comparison to competitors.
A short tutorial is provided as an example.
I. INTRODUCTION
<strong>Ruby</strong> on Rails [1] (often referred to as Rails or RoR)
is an open source web application development framework
that is written in the <strong>Ruby</strong> [2] programming language. The
<strong>Ruby</strong> on Rails framework is designed to make programming
web applications easier by making assumptions on what the
developer requires to get started on their applications. <strong>Ruby</strong>
on Rails is a development tool which assists developers in
building websites and applications because it abstracts and
simplifies the commonly used and repetitive tasks. What this
means is that the programmers only have to write new code
in areas where their application differs from the standard
conventions. Using <strong>Ruby</strong> on Rails, the programmers are able
to write less code while producing more output than with
other development frameworks. Highlighted in this report
is an overview of the philosophies and principles behind
<strong>Ruby</strong> on Rails, an in-depth look at the technical aspects
of the framework as well as comparisons to other similar
technologies. Finally, the report includes a tutorial on getting
setup with the <strong>Ruby</strong> on Rails framework and getting started
with developing a simple web application.
II. HISTORY OF RUBY ON RAILS
<strong>Ruby</strong> on Rails was created in 2003 by David Heinemeier
Hansson. Hansson developed the original framework for
Rails while he was working on <strong>Ruby</strong>-based projects for
37signals[3], a web application company. Rails was extracted
from some of Hanssons work on Basecamp, a project
management tool developed by 37signals.
Rails was first released publicly released in July 2004 as
an open source project. The project had reached a milestone
in 2006 when Apple announced that <strong>Ruby</strong> on Rails would
be bundled together with Mac OS X v10.5 Leopard which
later released in 2007.
The Rails framework is based on established principles
that had been proven successful elsewhere and is focused on
practicality which is the reason behind why it has become
so successful. With the release of <strong>Ruby</strong> on Rails, <strong>Ruby</strong> has
risen to become a prominent alternative for other classic
languages such as PHP and Java for developing websites and
web applications. Thousands of web applications around the
world have been developed using <strong>Ruby</strong> on Rails with some
notable examples such as Twitter, Yellow Pages, Github and
Hulu. Today, the Rails framework is supported by the Rails
core team consisting of a dozen members who have been
given the keys to the source repository as well as more
than 2,100 contributors to the project. The framework is
supported by a vibrant ecosystem which includes various
choices in hosting, tools, editors, conferences, workshops
and consultants.
III. PHILOSOPHIES AND PRINCIPLES
There are three primary philosophies or principles[4] behind
<strong>Ruby</strong> on Rails: Convention over Configuration (CoC),
Dont Repeat Yourself (DRY) and Representational State
Transfer (REST).
The first key principle is Convention over Configuration.
The Rails framework is designed with conventions that tell
you how you should structure your code, how to name your
classes and files and how to organize your databases and
tables. The framework makes large assumptions about what
you want to do and how you want to do it so that you dont
need to explicitly specify it. The benefit of having these
conventions is that it simplifies and reduces the amount
of code that you actually need to write when developing
your web application. What this means when developing is
that only the unconventional aspects of the program need
to be written. This allows for better productivity and high
efficiency since the repetitive or common tasks are already
automatically completed for you. Of course, there is the
option to ignore these conventions and structure the code to
your own preferences but this means that more unnecessary
work is being done. This principle makes <strong>Ruby</strong> on Rails a
bit of an opinionated framework[5] and is largely a reason
why the framework is named <strong>Ruby</strong> on Rails. If you decide to
follow the conventions that have been set out, you will enjoy
the benefits of using Rails for developing your applications.
If you dont conform to the style that the framework was
built on, it may not work well for you.
The second key principle is DRY which stands for Dont
Repeat Yourself. This principle suggests that writing the
same code over and over again is a bad thing. The main
idea behind the DRY principle is that it promotes the reuse
of code as often as possible rather than duplicating and
rewriting similar code in multiple places. <strong>Ruby</strong> on Rails
follows the DRY principle to help in maintaining clean code

and reducing the chance of errors in the code. Having DRY
code in your program means that changes only need to be
made at one location rather having to revise changes in all
different locations. If an error were to occur, it would be
a lot more traceable and easier to detect the root cause of
the error. Rails is designed with and provides libraries that
assist in writing DRY code.
The last principle of <strong>Ruby</strong> on Rails is REST or Representational
State Transfer[6]. This is not one of the primary
philosophies of <strong>Ruby</strong> on Rails but in recent years, the
Rails community has moved towards following the RESTful
architecture. Unlike the other philosophies of Rails, it is not
a requirement for the application to follow a REST design.
It is encouraged that developers follow the REST design and
the framework provides tools that make it easier to do so.
REST is a pattern for making web applications which
organizes the application around resources and standard
HTTP verbs. With REST, there are three key ideas. The
first is proper identification of resources, the second is the
manipulation of the resources and the last is to have selfdescriptive
messages that are easy to interpret. Resources
are often the core model objects in the program. The main
idea behind the RESTful design is to identify and manipulate
resources using a standard convention that is self-descriptive.
As an example, the following HTTP request, DELETE
/photos/17 can be easily understood as referencing a photo
resource with an ID number of 17. The standard HTTP
verb being used in this case is the delete functionality. The
purpose behind using REST in <strong>Ruby</strong> on Rails is to provide
a simplified design pattern that is clear and straightforward.
This can be especially helpful if the application being
developed is an open source project. Following a common
pattern like REST for all applications using Rails means that
all developers will have a good understanding of the coding
style and practices.
The philosophies and principles of <strong>Ruby</strong> on Rails are very
closely related within the framework. They all aim towards
simplifying and making the process of developing web applications
as simple as possible. Convention over Configuration
focuses on making the development process straightforward
and increasing productivity by abstracting the common and
repetitive tasks so that the developer only needs to be focus
on the new aspects to be implemented rather than having to
worry about the unnecessary conventional aspects. The DRY
philosophy focuses on having to write code only once and
reusing it as much possible when that particular functionality
is needed. Once again, this increases productivity since it
reduces the amount of code that needs to be written. It
also helps because it allows for better traceability of the
code which makes it easier to make revisions. Following
the RESTful design, the design of code follows a certain
standard which all developers can interpret and understand.
When <strong>Ruby</strong> on Rails is used with these principles and
philosophies in mind, the result is having cleaner and more
reliable code. Less work and code is required from the
developers which results in higher productivity.
IV. TECHNICAL INFORMATION
This section describes <strong>Ruby</strong> on Rails[7] basic technical
information: the structure on how it works, classes that are
needed for development, and the framework that it supplies
aiding the web application development. Also, some tools
for deployment of the application is tackled briefly. The information
stated here are mainly learned/cited from sources
[8], [9], and [10] for the system architecture/information and
development tools, and [11] contains the recommended tools
for deployment.
A. Introduction
<strong>Ruby</strong> on Rails is a development framework for developing
a web application. Rails offers libraries for development
ranging from the user interface up to managing the data and
processing it. This is why Rails is called a full-stack web
application development framework - usable to create all
functionality of a working web application.The availability
of the different libraries and given the founding philosophies
of Rails, which is the basis of a Rails project default configuration,
are giving Rails the ability to automatically link
different aspects and classes of a created project resulting
for the developers ease of use of the system. Though the
drawback of following a default configuration for the Rails
framework is that it offers little flexibility on configuration
management and design for the developer. The basic features
that <strong>Ruby</strong> on Rails provides for the application development
are: [10]
• HTML [12] templating (which involves the view component
of the application).
• Database storage/retrieval (involves the model classes
in the application).
• User Web browser requests and response (involves the
controller classes in the application).
• HTML form handling.
B. Directory Structure
When creating a project on Rails, Rails creates a predefined
directory structure to contain the files needed for the
project to work. Below are the directory names that could
be seen in a Rails project, and a brief description of each:
[10]
app
The folder that contains all developed code for the
project that are related to the MVC [13] architecture.
It means that it contains the model classes,
the controller classes, and the view templates for
the application.
config
Contains the configuration files for the application.

db
doc
lib
log
It contains the database schema and migration
files for model classes and database entities. Even
though that Rails is a full-stack framework for web
application development, the application still needs
to have a separate database to store the data needed
by the application.
This contains the documentation made for the
application that is being developed.
Code developed for the application that are not part
of the MVC classes and code files.
Log files for the application. These are automatically
created by Rails.
public
Contains the static files needed by the application.
(i.e images)
script
Contains Rails scripts for different utilities needed
by the application.
test
Folder to contain test code for the application.
tmp
Files needed by the application that are related to
web service.
vendor
Plugins installed in Rails that are being used by
the application.
C. MVC[13]
One of <strong>Ruby</strong> on Rails main technical highlight is that
the projects created follows the principle of Model-View-
Controller design architecture in arranging the applications
functionality. Model classes represents the object linked
from an existing database and its business logic features in
manipulating the data. View are the templates that are being
rendered to be shown to the user depending what the user
needs to see. Controller is the interface for the application
users web browser, it handles requests between the browser,
communicates with models to process the data needed, and
renders the view templates and sends it back to the browser.
The diagram below shows the simple interaction of a users
web browser to a MVC system.
There are main components and libraries built-in on Rails
to support and design the MVC architecture for the web
application development: ActiveRecord library is to support
Model classes in linking to database entities, ActionController
module on ActionPack library is the base class for all
controller objects for the project, and ActionView module
on ActionPack library assists in developing the templates
needed for different view.
Figure 1. A simple diagram showing how MVC architecture works, in
context of Rails.
1) Model - ActiveRecord Library: To represent a Model
layer in the project being created, Rails has a library called
ActiveRecord to implement model classes and linking it
to the web application database. ActiveRecord library and
its concept is based on [14], a design concept created
by Martin Fowler. The concept of ActiveRecord is that it
first maps relational databases into object classes, which
is called Object Relational Mapping [15]. The mapping is
done due to the fact that relational tables are structured
differently compared to object oriented classes. Typically
a relational database table could be traced as an object
class with the column description as attributes and each
row is an object of the class. But with addition of foreign
keys, disjoint, overlap, and other relational database table
characteristics, the differences between relational database
entities and object oriented is evident, thus it needs to be
mapped or converted for object-oriented use of the system.
Each relational database row and its attributes are encapsulated
within object classes. And then the class definition
contains data access methods for the specific data in the
database table. Also. it also contains other business logic
processing methods to manipulate the attributes of the object
and the linked data in the database if needed. This class
that represents the data from the database is called a Model,
and the relationship between Models are called Associations.
Associations can define model hierarchy and association
cardinality between models. ActiveRecord::Base is the base
class for creating models and also for creating associations
between models.
2) Controller - ActionController Module: Controller
classes are the classes that handles the communication
between the content of the application (View rendering and

Model data manipulation) and the request/response handling
of Users web browser. Thus, only the Controller layer on the
MVC architecture should know the methods that relates in
browser requests and response. ActionController class under
the Action Pack library in Rails represents the controller
class that the application needs. Usually, each model (or each
web page/view) should have its own controller class, and
each active entity in the view that a user could interact that
produces a request should have its own method inside the
controller class. These methods are called action methods,
which handles the process flow, or routing, within the
system. The handling of action method routing could be
either predefined or could be configured by the developer.
The ancestor class for all ActionController class within the
project is called ActionController::Base.
3) View-ActionView Module: The view layer handles the
display structure that the user sees in using application in
a given time. Based on our experiences using the web, we
could all say that many website servers uses different layouts
for different webpages of different purposes. It is the view
layer that handles these different layout views depending on
which aspect of the application is being viewed by the user.
In Rails, it is the ActionView module inside the Action Pack
library that handles the different views that the application
could have. Views in Rails are usually templates composed
of HTML [12] files and .erb (embedded ruby) [16] files.
Given that this layer handles the template for views, this
layer must not have any business logic methods inside it.
D. Other Components or Libraries
Aside from the main ones discussed above that handles
the core architecture of the project, there are also other
components and libraries that Rails have for additional
implementation of the designed application:
ActionDispatch
Part of the Action Pack library (that includes ActionController
and ActionView), ActionDispatch
are a set of classes that handles web request routing
and dispatch to applications.
ActionMailer
A component for email services development for
the application being developed. It enables the application
to send, process, and receive emails. The
base class ActionMailer::Base are the parent class
for mailer models in the system that are being used
for the email functionality being implemented.
ActiveModel
It is an interface between the Action Pack library
components and Object-Relational Mapping
components (i.e. ActiveRecord). This enables the
developer to have configuration control over the
usage of other ORM frameworks if it is not desired
to use ActiveRecord as the applications default
ORM.
ActiveResource
It is a framework to link objects and RESTful [6]
web services. It is similar to ActiveRecord, it does
Object-Relational Mapping to model REST web
services into objects.
ActiveSupport
Collection of utility classes for Rails usage. Could
also be used for the development of the application.
Railities
The core or the center of Rails code, which defines
on how Rails functions as a framework for
developing projects for web applications.
E. Tools to Aid Rails Development
As stated above, <strong>Ruby</strong> on Rails provides the classes and
the framework needed by the developer to develop their
desired web application. Aside from the framework, Rails
also provide tools to aid development of the application,
ranging from console tools up to automatic code generation
tools that satisfies the philosophy of Rails development.
1) Rails Console: Rails console is an extension of Interactive
<strong>Ruby</strong> console (irb) [16] - the command-line console in
<strong>Ruby</strong> to aid <strong>Ruby</strong>-based development. Similar to irb, Rails
console is extended to aid developers of Rails application for
setting up the system, for development, and for debugging.
Command-line consoles aids in viewing the system state in a
given system instance, and helps the developer to control the
system in a more powerful manner compared to managing
only the applications view interface in a web browser for
further debugging.
2) WEBrick: WEBrick [17] is a package provided in
Rails to provide aid in application development in terms
of local hosting the project before the actual deployment.
The application, before release, still needs to be hosted
somewhere for its development and testing. WEBrick is
local web server so that the application could be hosted
for its further development by the developer. One feature of
WEBrick is that changes applied to the project being hosted
automatically updates the server, thus removing the time
overhead spent for restarting the server for the developer to
see the change in accessing the application in a web browser.
3) Code GenerationScripts and Migration Files: These
are the components of Rails that helps the developer create
the application project easier and faster. The generation
scripts helps in generating the skeleton model and controller
classes needed by the system. It also helps in creating unit
tests for the classes being generated, and it also creates
migration files that handles the recognition of the application
to the database schema being used. Both code generation
scripts and migration files helps by automatically generating
code for the application when the user follows the default
configuration of the system.

F. Deployment
After the development of the application, it needs to be
deployed as a web service as a form of release for clients usage.
<strong>Ruby</strong> on Rails website [11] recommends some external
tools to help the developer deploy their project to the internet
community. One of the suggested tools in [11] is Phusion
Passenger a.k.a. mod rails [18]. The deployment process of
the web application developed relies on the specific tool
being used. Adding additional information about each tools
process for deployment is outside of the scope of this report.
Please see [11] for available tools for Rails application
deployment.
V. TUTORIAL
A. Setting up <strong>Ruby</strong> and <strong>Ruby</strong> on Rails
Setting up Rails is a little more work for those that are
used to using PHP and having little to no set up required.
However, this initial set up time is worth it. Time will
quickly be made up for due to the speed at which a web
application can be developed with Rails. The first step on
the path to fast web development is installing <strong>Ruby</strong>.
For demonstration purposes, the version of <strong>Ruby</strong> we
suggest is 1.8.7 p358, which can be downloaded free from
http://rubyforge.org/frs/shownotes.php?release id=46588
for Windows. When prompted to integrate into PATH,
yes should be checked for convenience. After the installer
finishes <strong>Ruby</strong>Gems, a package manager, can be installed
by typing gem update –system’.
Next, the Devkit should be installed from
http://rubyinstaller.org/downloads. After extracting and
navigating to the downloaded Devkit in command prompt,
the ruby dk.rb init’ and ruby dk.rb install commands will
finish the installation. What the Devkit does is install
necessary gems for the next step: installing Rails.
With <strong>Ruby</strong> and the Devkit installed, running gem install
rails at a command prompt will finally install <strong>Ruby</strong> on Rails!
Now the environment is ready to create a new project (application).
All that needs to be run is rails new project name;
adding -d mysql will use a MySQL database which you will
need to install separately. In addition to installing MySQL,
you need to install a gem for it by running gem install mysql.
MySQL installation is probably the hardest part of the
process. After installing MySQL Server and Connectors
from
http://dev.mysql.com/downloads/mirror.php?id=405845#mirrors,
you must manually copy the LIBMYSQL.dll file, as rails
and ruby will not do it for you. This file can be found at,
for example,
C:\Program Files\MySQL\Connector C 6.0.2\
lib\opt
and must be placed in the
<strong>Ruby</strong>\bin
folder. Now youre ready to use Rails with MySQL.
One of the few helpful commands to know while using
Rails is rake. This is <strong>Ruby</strong>s version of make (<strong>Ruby</strong> Make). It
uses a type of makefile to run tasks and builds. One example
is rake db:create which creates all of your databases for the
application. Another helpful tool is bundle, a dependency
manager. For example bundle install should install all the
dependencies/gems that your application requires.
Now, you are ready to test your Rails installation. After
creating a project, navigate to its root directory and run rails
server. This will start up WEBrick, a simple ruby server,
through which you can view your web application. Just
navigate to localhost:3000 in your favourite web browser.
The default welcome to rails page should show; just follow
the instructions to get started making your first project!
B. Learn to Math
First we want to create a project, open command prompt
and type the command:
rails new MathProject -d mysql
Go into the new MathProject directory. As you can see
this set up a lot of folders and files. Since this is a short
tutorial, the folders you need to know about are apps, config
and db. The apps folder contains your models, view and
controller folders. The db folder has a migrate folder that
contains the entities in your database. Finally the config
folder has the file routes.rb which contains your routes -
the links you use to redirect on your website.
We are going to use Nifty to auto-generate files for user
authentication. First modify the Gemfile, uncomment the
line:
gem ’bcrypt-ruby’, ’˜> 3.0.0’
(this is used for encryption), also add the line
gem "nifty-generators", :group => :development
Now run the command
bundle install
which will install nifty generators. Nifty generators is auto
generation software which we will use to make our User.
Create the table using:
rails generate nifty:authentication
rails generate nifty:layout
rake db:migrate
This will create a User entity in the database with an id,
username, email, password, password hash, password salt,
created at, and updated at columns. Users are authenticated
using the BCrypt encryption gem.
It also creates a bunch of web pages and ruby files
containing classes and functions to log in, check passwords,
etc.

Check the file user.rb, if
require ’bcrypt’
isnt at the top of the file and
include BCrypt
isnt at the beginning of the User class, add them.
When someone goes to our site we want them to go to
the auto-generated file views/sessions/new.html.erb.
To do this well have to change the route inside config/routes.db.
Uncomment and modify the root route:
root :to => ’sessions#new’
Since this is going to be a math website, we want users
to have a score for how many questions they got right. Find
and modify the accessible attributes:
attr_accessible :username, :email,
:password, :password_confirmation, :score
Also add the score to create users.db
t.string :password_hash
t.string :password_salt
=> t.integer :score
Drop the database and (inside command prompt) recreate
it with
rake db:create
rake db:migrate
Now the the database has been recreated with a score
column.
Now we want to be able to add, update, and get our score.
Add this to the User class inside user.rb.
def increase_Score()
update_attributes(:score => score+1)
end
def decrease_Score()
update_attributes(:score => score-1)
end
def get_Score
return score
end
In increase Score() and decrease Score() the update
attributes() function updates an attribute of User (in this
case score) inside the database. Depending on whether the
user gets the question right or wrong, their score increases or
decreases by 1 respectively. The get Score() simply returns
the score of the User.
Now we need to create a page for answering math
questions. Create a folder called maths inside the view
folder. Inside that folder create a file index.html.erb.
Put this following code inside the file:
Hello, Rails!
The variables rand1 and rand2 which are random numbers
between 0 and 1000, ops is an array containing the operators
for adding, subtracting, multiplying and dividing and randop
is a random number between 0 and 3 to choose one of the
operators.
The next line simply shows the user what the math
question is. Then the form begins with the random numbers
and operators in the questions being put inside r1, r2, and
op to be passed using GET when the user submits.
What is
?
rand1, :r2 => rand2,
:op => randop do %>
This code allows the user to submit the form with their
answer inside q.
Now we check to see if the users answer was correct. If
they answered correctly then we find their id and increase
their score, we also print out their new score. Else their score
will decrease.
To get access to this page we need a controller and to add
a route inside routes.rb to access it.

To create the maths controller use the command
rails generate controller maths
This will create a maths contoller.rb file inside
app/controllers. Navigate to the file and modify it as
follows
Once navigating to the webpage, there should be a login
page displayed. This was all generated by nifty. Initially,
there will be no users in the database. By clicking the
register link, a new account can be created. Once you
created an account youll be automatically logged in. If you
look inside the MySQL Workbench youll see the new user
account added. After creation, that user is now logged in.
There is (obviously) no advanced error checking or loggedin
checking. Additionally, there is not a link to the math page
created earlier. However, by entering localhost:3000/math,
this page can be viewed. Again, there is no error checking
on this page, so navigating to it while not logged in will
cause an error.
First try entering in the right answer, the score should be
displayed with a value of 1 which can be checked with the
score inside the database. Now when you test entering in
the wrong answer you should see your score go down by
one when this displayed in the website. Youll also see the
same page in the database. You should be able to tell just
how fast <strong>Ruby</strong> on Rails is after this tutorial, since most of
the code was generated by Rails. The only major piece of
user written code is the index page for the Maths view.
Once navigating to the webpage, there should be a login
page displayed. This was all generated by nifty. Initially,
there will be no users in the database. By clicking the
register link, a new account can be created. Once you
created an account youll be automatically logged in. If you
look inside the MySQL Workbench youll see the new user
account added. After creation, that user is now logged in.
There is (obviously) no advanced error checking or loggedin
checking. Additionally, there is not a link to the math page
created earlier. However, by entering localhost:3000/math,
this page can be viewed. Again, there is no error checking
on this page, so navigating to it while not logged in will
cause an error.
First try entering in the right answer, the score should be
displayed with a value of 1 which can be checked with the
score inside the database. Now when you test entering in
the wrong answer you should see your score go down by
one when this displayed in the website. Youll also see the
same page in the database. You should be able to tell just
how fast <strong>Ruby</strong> on Rails is after this tutorial, since most of
the code was generated by Rails. The only major piece of
user written code is the index page for the Maths view.
VI. NOTABLE APPLICATIONS
One of the most notable applications of <strong>Ruby</strong> on Rails
is Twitter. However due to Twitters explosive growth and
<strong>Ruby</strong> on Rails problems of scalability, Twitter is switching
over to Java (Twitter has now moved its entire search stack
from <strong>Ruby</strong>-on-Rails to Java. [19]).
While this one example might dissuade new programmers
to use RoR because of its problems with scalability it is
still a hotly debated topic. Many senior Rails developers
say scalability isnt a problem with RoR (Dix, 2010). They
say that the main problem for scalability is the database. By
dividing up your system into services that access the data
you can distribute the load [20] while using <strong>Ruby</strong> on Rails
to hold all the services together.
There are some sites that managed to use Justin.tv while
maintaining high speed. One example is Justin.tv a media
streaming/ VOD website.
There are 5 ways that Justin.tv improved speed while
using Rails [21]:
1) SQL - Decreased database querying times by finding
out
• Which queries were slow, indexing queries
• Refactoring slow queries
• Retrieve only the needed information from the
database
2) C Libraries
• Speed of C
• Better memory management then <strong>Ruby</strong>
3) Upgraded MemCache to latest version - which increased
speeds by a factor of 3
4) Cache Expiration
• Changed expiry times of caches
5) Unicorn
6) GC Tuning
7) Regain Memory
• Less objects allocated
• Removed unused dependencies from Gemfiles
• Removed old controllers/ views
After these improvements garbage collection sped up by
10%, response time decreased to 80ms, and over 50 thousand
useless objects were saved.
This just shows that while <strong>Ruby</strong> on Rails might make
it hard to scale big applications reliably, its certainly not
impossible to improvise to improve the speed of your
application.
According to [22] some other major websites that use
<strong>Ruby</strong> on Rails- Groupon, GitHub, Justin.tv, and Hulu.
VII. RUBY ON RAILS COMPARED
In the world of web development today, there is a wide
variety of languages and frameworks available for use. This
can make deciding what to use for a project more difficult.
The following section will compare and contrast <strong>Ruby</strong> on
Rails with more mature languages, as well as more modern,
but less mature, frameworks that are arising in its wake.

A. PHP and Java
While on their own PHP and Java do not constitute a full
stack framework like RoR does, they are both heavily used
within web development due to their inherent flexibility.
PHP and Java both allow, even require, extensive configuration
by the developer. This lends to their flexibility, but
can also be a hinderance due to the amount of extra work
required. RoR, however, highly discourages from modifying
any of the pre-built configurations, promoting learning to
work within those confines.[23]
Due to RoR’s relative immaturity, it has been criticized
to be not as scalable as PHP and Java. On the other hand,
by having a full stack framework available for use, it goes
without question that a website can be developed far faster
using RoR, where a single Rails developer can do the work
of an entire team using Java.[24]
B. Django and Zend
Django and Zend, like RoR, are full-stack frameworks,
designed to be easy to use and implement. The largest
difference between the three is the language that they are
based upon. Zend is built off of PHP and Django is based
on Python, unlike Rails being built off of <strong>Ruby</strong>. Zend, being
based on PHP, has held the value of flexibility despite the
additional framework.[25] The Zend framework is utilized
by many high profile companies, including Best Buy and
Bank of America.
C. .NET MVC
.NET MVC is a very new development framework produced
by Microsoft, which was released in 2009. It is based
off of the C# language which is very modern, having roots
in both Java and C/C++. Like RoR, it follows the MVC
design pattern.
While core functionality is very similar between RoR and
.NET MVC, .NET MVC has been found to suffer from a
relative lack of community support for both development
support and plugins. This is mostly caused by its young
age.
VIII. CONCLUSION
There are many advantages and disadvantages to using
the <strong>Ruby</strong> on Rails framework. Deciding on whether or not
to use <strong>Ruby</strong> on Rails for an application depends on the type
of qualities the project requires. The initial set up does take
a little more time than some of the alternative frameworks.
By demonstrating the creation of a simple web application,
we have hopefully given some insight in to the amount of
work required to setup and create projects with Rails.
REFERENCES
[1] (2012, February) <strong>Ruby</strong> on rails. [Online]. Available:
http://rubyonrails.org/
[2] (2012, February) <strong>Ruby</strong>. [Online]. Available: http://www.rubylang.org/en/
[3] (2012, February) 37signals: Web-based collaboration apps
for small business. [Online]. Available: http://37signals.com/
[4] M. Slater. (2012, April) Understanding ruby on rails. [Online].
Available: http://www.buildingwebapps.com/articles/79188understanding-ruby-on-rails
[5] (2012, February) <strong>Ruby</strong> on rails guides: Getting
started with rails. [Online]. Available:
http://guides.rubyonrails.org/getting started.html
[6] R. Fielding. (2012, February) Architectural styles
and the design of network-based software architectures.
[Online]. Available: http://www.ics.uci.edu/ fielding/pubs/dissertation/top.htm
[7] R. on Rails Team. (2012, February) <strong>Ruby</strong> on rails. [Online].
Available: http://rubyonrails.org/
[8] ——. (2012, April) <strong>Ruby</strong> on rails documentation. [Online].
Available: http://api.rubyonrails.org/
[9] ——. (2012, 04) <strong>Ruby</strong> on rails guides:
Getting started with rails. [Online]. Available:
http://guides.rubyonrails.org/getting started.html
[10] T. Fisher, <strong>Ruby</strong> on Rails R○ Bible, 1st ed. Wiley Publishing
Inc., October 2008, no. 67-74, 107-109, 147-149, 173-179.
[11] R. on Rails Team. (2012, February) <strong>Ruby</strong> on rails: Deploy.
[Online]. Available: http://rubyonrails.org/deploy
[12] (2012, April) Rfc 1866 - hypertext markup language - 2.0.
[Online]. Available: http://tools.ietf.org/html/rfc1866
[13] T. Reenskaug. (2012, February) Trygve/mvc. [Online].
Available: http://heim.ifi.uio.no/ trygver/themes/mvc/mvcindex.html
[14] M. Fowler. (2012, April) P of
eaa: Active record. [Online]. Available:
http://www.martinfowler.com/eaaCatalog/activeRecord.html
[15] Hibernate. (2012, April) What is object/relational
mapping? - jboss community. [Online]. Available:
http://www.hibernate.org/about/orm
[16] R. P. L. Team. (2012, February) <strong>Ruby</strong> programming
language. [Online]. Available: http://www.ruby-lang.org/en/
[17] Y. Santoso. (2012, April) Gnome’s
guide to webrick. [Online]. Available:
http://microjet.ath.cx/webrickguide/html/html webrick.html
[18] Phusion. (2012, April) Overview – phusion passenger( TM )
(a.k.a mod rails / mod rack). [Online]. Available:
http://www.modrails.com/
[19] A. Williams. (2012, April) Once again, twitter
drops ruby for java. [Online]. Available:http://www.readwriteweb.com/cloud/2011/04/twitterdrops-ruby-for-java.php
[20] P. Dix, Service-Oriented Design with <strong>Ruby</strong> on Rails.
Addison-Wesley Professional, 2010.

[21] (2012, April). [Online]. Available:
http://www.slideshare.net/kwi/rails-performance-at-justintvguillaume-luccisano
[22] Stuart. (2012, April) Top 50 ruby on rails websites.
[Online]. Available: http://storecrowd.com/blog/top-50-rubyon-rails-websites/
[23] B. A. Tate and C. Hibbs, <strong>Ruby</strong> on Rails Up and Running.
O’Reilly Media, Inc., August 2006, no. 2.
[24] D. Geer, “Will software developers ride ruby on rails to
success,” Computer, vol. 39, no. 2, p. 19, February 2006.
[25] R. Allen, N. Lo, and S. Brown, Zend Framework in Action.
Manning Publications, January 2009, no. 15.