AdaRuby

The Book of Ruby (3rd Edition) Review

2011-08-04T04:42:00Z

Looking to learn Ruby programming language? You’re lucky: The Book of Ruby, fresh from the oven 3rd Edition has been published by No Starch Press. Written by Huw Collingbourne, the developer of Ruby in Steel IDE, so it’s quite a special treat.

The book contains 425 pages in 20 chapters, while quite short it explains well a lot of the Ruby programming language constructs that you will use everyday.

Ruby development learning materials covered are as follows:

Chapters 1 to 3 cover strings, numbers, etc as well as the basic Ruby class hierarchy.
Chapter 4 tackles arrays and hashes.
Chapters 5 and 6 cover loops and conditionals.
Chapters 7 to 10 teach methods, arguments, exceptions and blocks.
Chapter 11 covers symbols, a small but important piece of the puzzle.
Chapter 12 describes Ruby modules and mixins.
Chapter 13 is about files and I/O.
Chapters 14 to 20 are a mishmash of various smaller topics such as YAML, a short chapter on Rails, etc.

Some chapters are structured like tutorials and are truly a joy to read. Instructions on the book are easy follow even for beginners. The author usually goes straight to the point, explaining the principles, usage description, with several practical examples.

Only a single chapter in this book, chapter 19, is devoted to Ruby on Rails web applications development. Though it is very short, it serves well as quick way to get you started with Web 2.0 applications programming. This also proves Ruby on Rails’ powerfulness: you don’t need to do much to get the common functionality working rightaway! Ruby on Rails lets you focus on the tasks that matter, saving you from the boring boilerplate work.

Even if you already start developing with Ruby on Rails, this book will help you unleash the potential of your Ruby on Rails apps with Ruby language features you may not know before. You can get The Book of Ruby here.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Assembla – Agile Bug Tracking and Issue Management

2010-07-02T09:06:16Z

Assembla.com is an online software development version control and management tool. The site includes an SVN/Subversion/Git/Mercurial/CVS repository hosting, a complete ticketing system, a collaboration tool and a management tool.

Certain features of the site can be used for free, but to use the entire suite of tools requires a paid subscription to the site. The site uses 128-bit encryption for free and paid users, and all data is stored on secure Amazon servers. The ticketing system incorporates task tracking, issue tracking and bug tracking. The collaboration tool includes a wiki, a message board and shared files. The software repositories offered by the site require no setup and offer seamless integration with the ticketing, collaboration and management tools.

Assembla.com can be used for all phases of a software project, and is being used by many software development firms. User control is simplified, so it is easy to give or revoke access to contractors when outsourcing is being used.

See more: Assembla: Agile bug tracking and issue management

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Rails 3 Beta Ready with Merb Goodness

2010-02-06T18:10:05Z

What do you get when the power of Ruby on Rails is combined with flexibility of Merb web framework? Rails 3 of course!

We have a very happy news: Rails 3 Beta is ready for testing. The improvements are numerous: ActiveRecord, ActionController, ActionView, and ActionMailer, ActiveSupport have all been redesigned. ActiveRecord got pimped with ActiveRelation scoped queries.

Some components have been refactored into their own: ActionDispatch, ActiveModel. Even better, all components can be used alone and you don’t have to require the entire Rails framework.

Rails is now not only Rack compatible, but subcomponents of Rails, like routing, are Rack middlewares.

Not to mention better dependency management system called Bundler, and improved performance especially on ActionView.

Read more detailed explanation on Yehuda Katz’s post:

http://www.engineyard.com/blog/2010/rails-3-beta-is-out-a-retrospective/

Will you upgrade to Rails 3?

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Why You Should Be Grateful for Coding in Ruby

2010-02-03T18:05:27Z

How do you feel during your daily Ruby programming workflow? Do you feel fun or productive? Either way, you’ve got to feel grateful!

After several years not doing any serious PHP programming, today I get curious.

Right now, PHP has evolved. PHP programmers are not “script kiddies” anymore, they’re professional programmers with quality MVC web frameworks.

Now it won’t be fair if I compared Ruby on Rails with PHP, as that’d be like comparing apples and oranges. So I have to pick some killer app written in PHP that competes directly with Rails, as long as it’s not WordPress or Drupal.

So I checked out Symfony, the most popular PHP web framework out there. I’ve never programmed Symfony, but I’ve heard a lot of good things about it.

After initial reading on the documentation, it seems the good things I’ve heard about it are true. The development model is very similar to Ruby on Rails. Scaffolds and plenty of helpers.

However, the syntax is unbearable. (at least for me!) Check out this tutorial example code:

// apps/frontend/modules/job/templates/showSuccess.php
<?php slot('title') ?>
 <?php echo sprintf('%s is looking for a %s', $job->getCompany(), $job->getPosition()) ?>
<?php end_slot(); ?>

slot() and end_slot() aren’t even a proper block construct. They’re just two separate functions made to look like they’re blocks.

Compare with how to do the same in Ruby on Rails:

# app/views/jobs/show_success.html.erb
<% content_for :title do %>
  <%= @job.company %> is looking for a <%= @job.position %>
<!-- or: <%= "#{@job.company} is looking for a #{@job.position}" %> -->
<% end %>

It might be a simple example, but that begs your gratefulness even more: Imagine coding a much more complex web application!

I certainly won’t blame it on Symfony. Its developers have done a great job releasing an excellent web framework using PHP language as its foundation.

However, the PHP programming language (at least in its current incarnation v5.x) while makes great things possible unfortunately make them greatly ugly at the same time. To be fair, it’s not hard to abuse Ruby if you want to get cryptic. But at least, Ruby programming language when used properly will yield beautiful and highly readable code like the above example.

What’s your take? Time to get opinionated, guys!

Image credits

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Quest for The Fluid Web Framework

2010-01-10T05:25:02Z

During my experience developing web applications, it’s challenging to find the “best” web development approach of them all.I like these principles:

POJO approach. No inheritance, interfaces, minimal annotations. Configuration is all that’s necessary.
Convention over Configuration. Even with POJO, some configuration is needed. Minimize configuration by using conventions. And document the conventions! Because conventions can sometimes be confusing.
REST approach. This is not anti-SOAP or anti-WS-*. It means designed for the web, and embrace resource-oriented and stateless principles.
Use JSON. For browser-server communication JSON is preferable. Atom+XML is more suited for documents and server-server communication.
Decentralized. Rather than one big app, decompose as much as possible. Decentralization means a more robust infrastructure is needed, and yes it means looking for trouble.
Resource-oriented. Contrasts with page-oriented or procedural. Somewhat similar to object-oriented but with resource semantics. Kind of Objects than implement IResource.
Interoperable. Services are exposed via JSON-REST API, AtomPub, or other mechanism. Can also consume other services easily
Robust security infrastructure. Provides sufficient authentication and authorization mechanisms, and easily programmable.
“ Native”. Blends with the host environment, even if just a simulation. jQTouch, Qt, Swing, are all good examples here.
Lightweight. Prefers lightweight specialized frameworks, like Merb, Sinatra, than Ruby on Rails. Spring than Java EE. Heavy full-stack framworks (some call it “bloated”, though I don’t believe that term anymore) does have its plus sides though, less headache is one of them.
Scalable. Runs on a scalable clustered system like Google Apps Engine or Heroku. Also means dictated by scalability restrictions of the respective environments (more headaches).
Reasonably Reusable. I wanted cross-platform, but now it has expanded to cross-environment (with mobile devices and other stuff). So now I think some sort of reusability is desirable. For example, JavaScript logic that can be used by server-side desktop web application, server-side mobile web application, and client-side applications with embedded browser component.

The Fluid Web framework (I made up that term) provides most of the benefits with a reasonable level of complexity and learning curve.

Fluid Web will also use the best programming model for the task at hand. Divided broadly, there are three programming models in question:

POJO Model. to Spring Programming Model. Also used in JavaScript and all Object-oriented programming languages. It’s RPC and object-oriented.
REST Model. The “Web programming model” as Google calls it. This is less of an API and more of a protocol(s). It’s resource-oriented or document-oriented.
Comet model. Asynchronous programming model. Data is passed through several message channels. Everybody are clients, they can publish and subscribe to the channels. XMPP belongs here too.
SQL model. Great for accessing data stores declaratively. Also in this category: SPARQL for RDF triplets, YQL for web resources, GQL for Google Big Table, Microsoft’s LINQ. Resulting data is document-oriented.

I have been somewhat obsessed by this quest since a few years ago, and haven’t yet found the true answer. Betting on it on a commercial project is also too risky. So I decided that I will do more experiments on it on a research basis, and share my experiences here.

Feel free to share your ideas.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Three Ways You Can Speed Up Your Fresh Rails Development

2009-12-21T08:58:30Z

A Ruby on Rails web application I’ve been developing uses Dojo-based full AJAX frontend. I learned some new tricks during development, relearned old pitfalls, and found some mistakes that I’d like to share with you.

Our team decided to implement the webapp in a non-conventional approach, using Dojo Toolkit-based full AJAX frontend, without using any ActionView functionality. It turned that it went quite well, but there are some things that we weren’t aware of and now we know how to deal with it, and you will too.
Communication between backend and frontend is done using JSON REST API. Since there is pratically no view code in the server-side app, theoretically it would be more appropriate to use Sinatra instead of Rails. But we opted for Rails because of familiarity with all its eccentricasies and exoticism. It’s not so much about learning the Sinatra framework, but more on what if we need to hack things out? (which we have personally proven to be time consuming)

1. Make Good Use of Integration Tests

Since the app uses SOFEA-style (Service Oriented Front End Architecture), I thought backend tests aren’t so critical as it’s replaceable by the front end (which is separate) itself.

I was mostly wrong. Unit tests are still needed to test the backend implementation (with regard to database).

But to my surprise, integration tests are more important than ever, even more than functional tests.

Functional (controller) tests have limited use, I tend to skip it and it can even be misleading. Example: rendering string as JSON only outputs the string, but controller test won’t know that, while integration test detects that the returned JSON is incorrect. Let me illustrate with a more concrete example.

Wrong output:

@message = "Hello World"
render :json => @message

Correct output:

@message = "Hello World"
render :json => @message.to_sym

The first example returns just: Hello World, without quotes, which is an incorrect JSON. Since JSON is parsed, a simple string must be surrounded by quotes (and encoded), hence the to_sym ‘hack’.

2. Scaffolds Are Your Friend (or Leave Your Admin UI Alone for Now)

We thought we’d say good bye to ActionView. Well, we did, but not to scaffolds.

At first we focused on building the Admin UI, not so long before we realize we’re trying to do something Rails is good enough to do it for a few (milli)seconds: scaffolding.

Building the UI with Dojo, Dijit, and DojoX was fun. When you get to know JavaScript more, it’s not as scary as its reputation. And the resulting UI is awesome.

But we spent too much time building the Admin UI with Dojo. It’s not that the UI is hard or that we won’t need it, but we don’t need it now.

Schemas may evolve (migrate), as development progresses, and we couldn’t care less about how the Admin UI looks at this point.

Another plus for Rails scaffolds (whichever your preferred flavor) is it can directly reflect the database. Not true with Dojo-based one. You can rake db:migrate or change the model and voila, your Admin UI instantly has your changes.

3. Start Small

Two previous tips were more concrete, but this one is less of an action and more of… Less.

We tried to do more with more. We actually did less.

Especially during new development, you need as much instant gratification as possible.

Do less with more.

Do something that 80% works with only 20% effort. Or better, something that 60% works just by using 1% of your time.

I wrote specs too, the JSON specs, resource model, REST conventions. It looked pretty good… until I found out it’s not trivial to implement them in the server (and sometimes in the frontend).

Not that it’s not possible, but doing that will mean lots of additional logic in the controllers. Especially since Rails isn’t primarily geared to being a REST resource framework, but a server-side MVC web framework with REST support. Even worse, these logic are duplicated in all controllers, and while trying to refactor them out, it feels like I’m building a new framework of its own.

My workaround was simple: Code what the app is supposed to do.

Leave the snazzies, extras, and toppings for later.

And write tests.

Summing It Up

I’ve to say that I have been enjoying developing a SOFEA-style web application in Rails. Probably there is a better way, yet Rails is quite general-purpose: Rails doesn’t restrict us from doing what we wanted.

Writing backend tests is more important in SOFEA-style than traditional MVC webapps, because the frontend may not be fully developed and you need the tests to make sure the backend works.

Liberal use of Rails Scaffolds saves time. And start with the shortest code that works.

I want to know about your experiences too, please share it in the comments.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

How to Use ActionView Helpers in Your Rails Controller

2009-12-16T06:01:09Z

Sometimes when developing a Ruby on Rails web application, you want to use an ActionView helper method inside your controller. The following tip is from Gabriel Gironda ¹.

This is incredibly straightforward and more of an occasional convenience, but I thought I’d throw it out there anyway.

One use case is to use pluralize() in a flash message and not have to do it by hand using the inflector. You could include ActionView::Helpers::TextHelper in the controller, but that fills your namespace with crap.

Put this in the class ApplicationController instead:

  def help
    Helper.instance
  end

  class Helper
    include Singleton
    include ActionView::Helpers::TextHelper
  end

Then you can just use it like so:

  def check_for_max_donkeys
    if Donkey.find_fit_donkeys.size ==
APP_SETTINGS['max_fit_donkeys']
      flash_error &quot;The maximum of
#{help.pluralize(APP_SETTINGS['max_fit_donkeys'], 'donkey')} has
been reached.&quot;
      redirect_to_index
    end
  end

Don’t use the method name “helper” because Rails already uses that. Just “help” works fine.

1 http://gabriel.gironda.org/articles/2006/02/08/using-helpers-inside-a-controller

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

NetBeans IDE 6.8 Released — with Enhanced Ruby on Rails Support!

2009-12-14T20:35:03Z

NetBeans IDE version 6.8 has been released, Sun Microsystems’ newest flagship programming environment. Primarily targeted at Java programmers, NetBeans also sports a very polished IDE for Ruby on Rails developers.

New NetBeans 6.8 features and improvements for Ruby on Rails include:

Upgraded bundled JRuby to 1.4
Ruby 1.9 debugging support
Run/Debug File with arguments
Support for running/debugging files that are not part of a project
Improved handling of inherited methods in rename refactoring
Possibility to specify arguments for Rails servers
Navigation support for ActiveRecord associations
RSpec 1.2.9 support
Faster and more accurate type inference
Improved navigation for accessor methods created by attr, attr_accessor and attr_reader
Support for creating Rails 2.3.4 apps with dispatchers

Ability to uninstall a specific gem version.

Type assertions for method return types, use :return:=> (type) in the method’s rdoc, e.g.: #:return:=>String

Other improvements include:

Database/SQL Improvements

Database integration: Code completion in SQL Editor now also for DELETE, DROP, UPDATE statements, and for reserved keywords

Embedded Browser

There is a brand new embedded browser based on Mozilla XULRunner available on Update Center for MS Windows.
The Browser is disabled by default. To enable it use Tools > Options and select ‘Embedded Mozilla Browser’ as Web Browser.
The Embedded Browser is used to display all links (that would be normally opened in the external browser) inside the IDE as Editor tabs.

The Embedded Browser in IDE is very new thing and we would like to gather a lot of feedback about it. Should you find some issue then please file a bug report.

Embedded Browser requires 32-bit JDK.

Web Preview for HTML and CSS

Embedded Browser (EB) component is used for HTML file preview that is opened in Output area and user can preview changes while editing (simply by saving the file) without jumping between external editor and NetBeans IDE.
EB is also used for CSS editor where it replaces previous HTML rendering component, so user can see CSS changes in real-world internet browser.

Note: Both preview can be used only on Windows after downloading Web Preview and Embedded Browser modules from UC

Kenai.com: Connected Developer

Full JIRA support (plugin from update center)
Project dashboard with more member and project details, improved search and navigation, easier project sharing
Improved instant messenger integration: Online presence, private and group chat with Kenai members, easy to add links to code / files /issues / stack traces to messages
Improved issue tracker integration

Download NetBeans IDE

Start developing Ruby on Rails web applications faster with this full-featured IDE, download and install NetBeans here.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Aquarium 0.4.2: Aspect-Oriented Programming for Ruby

2009-12-03T04:31:56Z

Aquarium is a framework that implements Aspect-Oriented Programming (AOP) for Ruby. The premise of AOP is that some concerns in an application will cut across the natural object boundaries of the problem domain. Rather than scatter duplicated code in each object to handle the cross-cutting concern, AOP modularizes the specification of which execution points are affected (called join points) and the actions that should be invoked at those points.

New in V0.4.0: Preliminary support for advising Java classes in JRuby! See the discussion here.

Usage

Aquarium provides a Domain Specific Language (DSL) with which you can express “aspectual” system behaviour in a modular way, i.e., using a succinct language and without repeating yourself all over your code base!

Imagine you want to trace all invocations of the public, instance methods in all classes whose names end with “Service”. Here’s how you can implement that behavior in Aquarium:

class ServiceTracer
    include Aquarium::Aspects::DSL::AspectDSL
    before :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Entering: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
    end
    after :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Leaving: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
    end
end
A more succinct implementation of this behavior uses #around advice:

class ServiceTracer
    include Aquarium::Aspects::DSL::AspectsDSL
    around :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Entering: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
      result = join_point.proceed
      log "Leaving: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
      result  # block needs to return the result of the "proceed"!
    end
end
See the Examples and the API section for more details.

Start Here

$ gem install -y aquarium

See the download page for different options or go directly to Rubyforge download page.

more resources: Aquarium.rubyforge home page.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

A Server Hard Drive Crash :(

2008-05-12T10:31:32Z

Just got a server hard drive crash

We should be back operational soon. In the mean time please bear with us. Thank you.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.