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.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.

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.

See also the RubyForge project page.

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.

While using Ruby for your projects, you may need some references.

These are some references that might help you in using Ruby:

• Language

General Syntax Rules

• Comments start with a pound/sharp (#) character and go to EOL.
• Ruby programs are sequence of expressions.
• Each expression is delimited by semicolons(;) or newlines unless obviously incomplete (e.g. trailing ‘+’).
• Backslashes at the end of line does not terminate expression.

Reserved words

alias   and     BEGIN   begin   break   case    class   def     defined
do      else    elsif   END     end     ensure  false   for     if
in      module  next    nil     not     or      redo    rescue  retry
return  self    super   then    true    undef   unless  until   when
while   yield

Type

Basic types are numbers, strings, ranges, regexen, symbols, arrays, and hashes. Also included are files because they are used so often.

Variables

$global_variable
@@class_variable
@instance_variable
[OtherClass::]CONSTANT
local_variable

• Standard Library

Ruby comes with an extensive library of classes and modules. Some are built-in, and some are part of the standard library. You can distinguish the two by the fact that the built-in classes are in fact, built-in. There are no dot-rb files for them.

Built-in Library

Class Hierarchy:

Object

• Hash
• Symbol
• IO
  • File
• Continuation
• File::Stat
• Data
• NilClass
• Exception (see tree above)
• Array
• Proc
• String

Standard Library

The essentials:

• • benchmark.rb a simple benchmarking utility
  • cgi-lib.rb decode CGI data – simpler than cgi.rb
  • cgi.rb CGI interaction
  • date.rb date object (compatible)
  • debug.rb ruby debugger
  • delegate.rb delegate messages to other object
  • English.rb access global variables by english names
  • fileutils.rb file utility methods for copying, moving, removing, etc.

• Tools: ruby(Command Line Options, Environment Variables), irb, xmp, ruby-mode, Debugger, rdoc

• Mindshare, Idiom and Patterns (Object Design, Other Third-party Libraries)

For further details visit Ruby Quick Reference page at ZenSpider.

No related posts.

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

Advanced Rails offers you an in-depth look at techniques for dealing with databases, security, performance, web services and much more.

O’Reilly Media, Inc. published an intermediate-to-expert Rails book, authored by Brad Ediger:

Chapters in this book help you understand not only the tricks and techniques used within the Rails framework itself, but also how to make use of ideas borrowed from other programming paradigms. Advanced Rails pays particular attention to building applications that scale — whether “scale” means handling more users, or working with a bigger and more complex database.

You’ll find plenty of examples and code samples that explain:

• Aspects of Ruby that are often confusing or misunderstood
• Metaprogramming
• How to develop Rails plug-ins Different database management systems
• Advanced database features, including triggers, rules, and stored procedures
• How to connect to multiple databases
• When to use the Active Support library for generic, reusable functions Security principles for web application design, and security issues endemic to the Web When and when not to optimize performance
• Why version control and issue tracking systems are essential to any large or long-lived Rails project
• Advanced Rails also gives you a look at REST for developing web services, ways to incorporate and extend Rails, how to use internationalization, and many other topics.

Advanced Rails is an essential resource for improving your skills on Rails through advanced techniques.

No related posts.

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

Design Patterns in Ruby documents smart ways to resolve many problems that Ruby developers commonly encounter. Addison-Wesley Professional press has this exciting book, authored by Russ Olsen.

Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. Most design pattern books are based on C++ and Java. But Ruby is different—and the language’s unique qualities make design patterns easier to implement and use.

In this book, Russ Olsen demonstrates how to combine Ruby’s power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and “mixins” for easier code reuse.

Design Patterns in Ruby also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based “Convention over Configuration” pattern, designed to help integrate entire applications and frameworks.

More resources:

• “Design Patterns in Ruby” at Amazon.com
• Review at barnesandnoble homepage

No related posts.

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

Practical Reporting with Ruby and Rails is a great book for Ruby and Rails developers seeking to create compelling business intelligence and reporting solutions using a wide variety of applications and services. Published by Apress, and the author is David Berube.

Business intelligence and real-time reporting mechanisms play a major role in any of today’s forward-looking business plans. With many of these solutions being moved to the Web, the popular Rails framework and its underlying Ruby language are playing a major role alongside web services in building the reporting solutions of tomorrow.

Practical Reporting with Ruby and Rails is the first book to comprehensively introduce this popular framework, guiding readers through a wide-ranging array of features. Note this isn’t a staid guide to generating traditional reports, but rather it shows you how the Ruby language and Rails framework can create truly compelling reporting services by plugging into popular third-party applications and services such as Google AdWords, UPS.com, iTunes, and SalesForce.com.

There’s a lot to learn from this book, including:

• Create reporting solutions for both the Web and the desktop.
• Integrate with powerful third-party retail solutions such as eBay, and Amazon.com in order to monitor your sales campaigns in real-time.
• Build an invoice reporting system using Rails and PayPal.
• Monitor your sales performance by taking advantage of SugarCRM’s web service offerings.

More resources:

• Editorial review at Amazon.com

No related posts.

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

The goal of Portable Ruby is to reduce those updates to a single place, your USB drive. About.com describes how to make this possible:

Installing Ruby

The easiest way to setup a Portable Ruby application is to start with an existing Ruby installation. I recommend the One-Click Installer. If you haven’t done so already, go ahead and install it.

The entire Ruby distribution is created in a single “ruby” directory structure. Additional changes include the creation of shortcuts for the start menu, which we will simulate in the PortableApp menu. The One-Click Installer also updates the Windows PATH environment variable to include the ruby\bin directory.

Layout the PortableApp Structure

Another helpful tip is to install PortableApps to the root of your hard drive so you can easily test the integration of your Portable Ruby development. Using the earlier articles as a reference, install PortableApps to “C:\PortableRoot”.

The next step is to create a standard PortableApp directory structure. To make this easy, you can download the Ruby Portable Template starter zip. In addition to the directory structure, the starter zip also contains files for creating the Ruby and SciTE Portable launchers.

Unzip the Ruby Portable Template inside of the directory “C:\PortableRoot\PortableApps\”. Your directory structure should look similar to the following.

• C:\PortableRoot
  • PortableApps
    • OtherApps
    • RubyPortable
      • App
        • AppInfo
        • ruby
      • Data
        • settings
      • Other
        • RubyPortableSource
        • RubySource

At this point, you can copy the contents of the “ruby” directory the One-Click Installer created into the RubyPortable -> App -> ruby directory.

Check your free space first. The directory is about 80MB, but I would plan on having additional free space for your projects. Once you have copied the Ruby directories over, you can uninstall the One-Click Installer. While this isn’t technically necessary, it is helpful to remove the changes to the Windows environment so they do not conflict with testing your setup of the Portable Ruby application.

More information and instructions are available on About.com: Ruby page.

No related posts.

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

The latest entry in Addison-Wesley’s Professional Ruby Series is The Rails Way, by Obie Fernandez, is a long awaited book billing itself as the “expert guide to building Ruby on Rails applications.”

More precisely, the book dives into nearly every area of the Rails libraries and APIs and acts as a reference work for them. Coming in at about 850 pages, the book is physically very similar to The Ruby Way by Hal Fulton. There’s no denying that these two books look good next to each other on the bookshelf, and a lot of comparison can be made between the two.

Using detailed code examples, Obie systematically covers Rails’ key capabilities and subsystems. He presents advanced programming techniques, introduces open source libraries that facilitate easy Rails adoption, and offers important insights into testing and production deployment. Dive deep into the Rails codebase together, discovering why Rails behaves as it does– and how to make it behave the way you want it to.

This book will help you:

• Increase your productivity as a web developer
• Realize the overall joy of programming with Ruby on Rails
• Learn what’s new in Rails 2.0
• Drive design and protect long-term maintainability with TestUnit and RSpec
• Understand and manage complex program flow in Rails controllers
• Leverage Rails’ support for designing REST-compliant APIs
• Master sophisticated Rails routing concepts and techniques
• Examine and troubleshoot Rails routing
• Make the most of ActiveRecord object-relational mapping
• Utilize Ajax within your Rails applications
• Incorporate logins and authentication into your application
• Extend Rails with the best third-party plug-ins and write your own
• Integrate email services into your applications with ActionMailer
• Choose the right Rails production configurations
• Streamline deployment with Capistrano

More resources:

• Editorial review at Amazon.com
• Review for this book at hasmanythrough blog

No related posts.

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

It’s not just Rails 2.0 but another added bump in the minor version

There are thousands (literally, considering the Subversion revision numbers of improvements, including:

• Action Pack: Resources
• Action Pack: Multiview
• Action Pack: Record identification
• Action Pack: HTTP Loving
• Action Pack: Security
• Action Pack: Exception handling
• Action Pack: Cookie store sessions
• Action Pack: New request profiler
• Action Pack: Miscellaneous
• Active Record: Performance
• Active Record: Sexy migrations
• Active Record: Foxy fixtures
• Active Record: XML in, JSON out
• Active Record: Shedding some weight
• Active Record: with_scope with a dash of syntactic vinegar
• ActionWebService out, ActiveResource in
• ActiveSupport
• Action Mailer
• Rails: The debugger is back
• Rails: Clean up your environment
• Rails: Easier plugin order
• And hundreds upon hundreds of other improvements

It’s not my call so I’ll let David Heinemeier Hansson’s announcement at 37signals’ Riding Rails blog speak for real

To update your Rails (and everything!):

sudo gem update

PS: Rubygems 0.9.5 is also here, too! So, to update this:

sudo gem update --system

No related posts.

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