CSC/ECE 517 Fall 2007/wiki2 1 rl: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
Line 56: Line 56:
Rails offers the following advantages for the final application:
Rails offers the following advantages for the final application:
<ul>
<ul>
<li>reword: less config, less repetition in code, generated core code on fly makes for smaller app, etc</li>
<li>Rails natively supports filters, which allow you to wrap actions with before-code and after-code, for concerns such as authentication, logging, etc.  Struts, on the other hand, requires SAIF (Struts Action Invocation Framework) in order to support filters.</li>   
<li>Rails natively supports filters, which allow you to wrap actions with before-code and after-code, for concerns such as authentication, logging, etc.  Struts, on the other hand, requires SAIF (Struts Action Invocation Framework) in order to support filters.</li>   
<li>Rails natively supports layouts for a common look and feel.  Struts on the other hand requires the use of Tiles (a separate Apache project) to do the same, and this in turn necessitates even more XML configuration.</li>
<li>Rails natively supports layouts for a common look and feel.  Struts on the other hand requires the use of Tiles (a separate Apache project) to do the same, and this in turn necessitates even more XML configuration.</li>
Line 63: Line 64:
Struts offers the following advantages for the final application:
Struts offers the following advantages for the final application:
<ul>
<ul>
<li>J2EE has been around longer than Rails, and is a proven technology.</li>
<li>Struts is an older and more established framework, and is a proven technology.</li>
<li>With Struts, you are not locked into a specific model implementation.  You can select a model implementation that best suits your application's needs.</li>
<li>With Struts, you are not locked into a specific model implementation.  You can select a model implementation that best suits your application's needs.</li>
</ul>
</ul>
new so not playing catchup on standards (page 2 of book),
http://en.wikipedia.org/wiki/Convention_over_Configuration (hibernate)
http://www.javalobby.org/java/forums/t65305.html
It's the philosophical approach to development of Web applications that sets the two frameworks apart. Rails prefers explicit code instead of configuration files, and the dynamic nature of the Ruby language generates much of the plumbing code at runtime. Most of the Rails framework has been created as a single project and application development benefits from a set of homogeneous components. In contrast, the typical J2EE stack tends to be built from best-of-breed components that are usually developed independently of one another, and XML is often used for configuration and gluing the components together.
So, should you consider Rails for your next Web application? Well, why shouldn't you? It's a well-written stack of components that work well with each other and are based upon industry accepted enterprise patterns. The Ruby language allows for fast development and adds to the framework by generating much of the application plumbing. Those who are familiar with MVC and ORM frameworks available in the Java world will have no difficulty wrapping their minds around Rails.
rails claims developers can be 10 times more productive (http://www.ibm.com/developerworks/linux/library/wa-rubyonrails/)
http://www.ibm.com/developerworks/linux/library/wa-rubyonrails/ :
Although I can't guarantee that the framework will deliver on its promise of joy, the statement does a good job of summing up Rails' qualities. The full stack consists of a Web server, a framework for processing HTTP requests and responses, and a framework for easily persisting data to a relational database. Rails strives for development ease by eliminating complicated XML configuration files and using the very dynamic nature of the Ruby language to help minimize much of the repeating code often found in static typed languages.


==References==
==References==

Revision as of 04:27, 23 October 2007

Assignment

Compare Ruby on Rails with Apache Struts. The Apache Struts framework in the Java world occupies a position similar to Ruby on Rails, except that it is not as universally used. Compare the two. Which are the advantages of each for the developer? For the finished application?

Introduction

Ruby on Rails and Apache Struts are both web application frameworks based on the Model-View-Controller (MVC) architecture.

MVC Architecture

MVC separates an application into three components: the model, the view, and the controller. The model maintains the application state; it consists of both the data used by the application as well as the rules surrounding the use of that data. The view generates the user interface, which allows the user to view and interact with the data in the model. The controller takes input from the outside world, interprets the input, and manipulates the model accordingly. Separating these three components, or concerns, makes the application code easier to understand, reuse, and maintain.

Ruby on Rails

Ruby on Rails, also known as "Rails" or "RoR", is the standard Web application framework for the Ruby programming language. It is an open source project that was released in 2004, and was created to make web application development quick and easy.

All Rails applications use the MVC architecture. Rails projects are created with a placeholder for each concern, and these concerns always interact in the same standard way. Models and controllers are Ruby classes, and views are written in eRuby (HTML with embedded Ruby). The Ruby router directs requests to a particular controller and action based on the URL.

For more basic information on Ruby on Rails, visit the Ruby on Rails homepage.

Apache Struts

Apache Struts is a Web application framework for the Java programming language, used to create Java 2 Platform, Enterprise Edition (J2EE) applications. It is an open source project that was donated to Apache in 2000. Struts was introduced to encourage the use of the MVC architecture. Struts provides a controller in the way of request and response handlers, and provides a tag library that developers can use to develop views. The model is left up to the developer.

For more basic information on Apache Struts, visit the Apache Struts homepage.

Comparison of Ruby on Rails and Apache Struts

Rails and Struts are similar in many ways. They are both web application frameworks for their respective languages, and they both implement the Model View Controller architecture. The figure below, taken from Ruby on Rails and J2EE: Is there room for both?, provides a comparison of a typical Rails stack and a typical J2EE stack containing Struts.


As you can see, the two stacks are fundamentally quite similar. Note, however, that the Persistence (Model) layer of the Rails stack, Active Record, is actually part of the Rails framework, whereas Hibernate (an object-relational mapper for Java) is not part of Struts. This is one key difference between Rails and Struts: Rails provides a complete MVC implementation and Struts does not. In addition to not providing a Model implementation, Struts also does not fully provide a View. As you can see in the stack, JSPs are used for the View, and these JSPs take advantage of a tag library provided by Struts.


In Rails, the DispatchServlet dispatches web requests to the controller and action specified in the URL. For example, a request for a URL ending in /questions/show/3 will be routed to the QuestionsController class and the show method. By convention, Rails knows that this will be found in questions_controller.rb. Assuming scaffolding is in use and no customization has been done to change the behavior, this url will cause the question with ID of 3 to be displayed to the end user. The ActionServlet in Struts, on the other hand, uses an XML configuration file to map requests to specific controllers and actions. This typifies another key difference between Rails and Struts: Where Rails relies on convention, reflection and discovery to determine what to do, Struts relies on configuration files. Note also that actions in Rails are simply methods inside their respective controllers, but they require full classes in Struts.

Advantages

Both Rails and Struts offer all the advantages that come with using the MVC architecture. The separation of concerns makes the code more maintainable, reusable, and understandable. It allows developers to specialize, and facilitates parallel development. Finally, it makes enhancements to the application easier to design and implement. The two frameworks each also offer distinct advantages over the other, both for the developer and for the finished application.

Advantages for the Developer

Rails offers the following advantages for the developer:

  • Rails provides database scaffolding out of the box. Essentially, Rails will generate all of the code necessary to do basic database interactions, such as create, read, update, and delete entries. This allows developers to quickly and easily begin working with their data model, and replace the generated code with customized versions piece by piece.
  • Rails favors Convention over Configuration. Rails uses sensible defaults, so as long as you follow convention, your application can be written with significantly less code and without the great number of configuration files seen in other web applications today. For example, if you create a model class called Product, Rails will also generate for you a controller class named ProductsController, and will assume that your model is using a database table called products. You only need to configure the table name if you are using a different value. Writing less code and doing less configuration saves developers time during design, development, test, and maintentance.
  • Rails has Don't Repeat Yourself as its mantra. Information about the system should be expressed in only one place. For example, the names of the columns of a database table need only be contained in the table itself. Rails gathers this information through reflection and discovery. Avoiding code repetition is always good for the developer.

Struts offers the following advantages for the developer:


Advantages for the Final Application

Rails offers the following advantages for the final application:

  • reword: less config, less repetition in code, generated core code on fly makes for smaller app, etc
  • Rails natively supports filters, which allow you to wrap actions with before-code and after-code, for concerns such as authentication, logging, etc. Struts, on the other hand, requires SAIF (Struts Action Invocation Framework) in order to support filters.
  • Rails natively supports layouts for a common look and feel. Struts on the other hand requires the use of Tiles (a separate Apache project) to do the same, and this in turn necessitates even more XML configuration.
  • URLs in a Rails application are short and clear. They are of the form http://<host:port>/controller/action/id. Default Struts, on the other hand, exposes the use of Struts to the user by showing *.do at the end of the URL.

Struts offers the following advantages for the final application:

  • Struts is an older and more established framework, and is a proven technology.
  • With Struts, you are not locked into a specific model implementation. You can select a model implementation that best suits your application's needs.

References

  1. Ruby on Rails and J2EE: Is there room for both?
  2. Rolling with Ruby on Rails Revisited
  3. Ruby on Rails
  4. Model-view-controller
  5. CSC517 Lecture 12: Ruby on Rails
  6. Agile Web Development with Rails
  7. Ruby on Rails Wikipedia entry
  8. Apache Struts Wikipedia entry
  9. Rails vs Java Struts

See Also

  1. Hibernate
  2. SAIF
  3. Apache Tiles
Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2007/wiki2_1_rl&oldid=6825"