It searches for files and directories with partial matches of the first parameter:

1
2

$ f 26
./db/migrate/20121003094826_add_foo_to_bar.rb

If I supply a second parameter, it is taken as the directory to search in:

1
2
3

$ f 26 ..
../api/db/migrate/20121003094826_add_foo_to_bar.rb
../redmine/db/migrate/20091017212644_add_missing_indexes_to_messages.rb

If I do this:

1
2

puts foo
foo = 3

there is always the doubt whether I’m accessing a local variable, or calling methods foo and foo=.

TL;DR

When you want to call an instance’s own methods, use self:

1
2

self.foo             # Calls foo
self.foo = 'bar'     # Calls foo=

Example 1

1
2
3
4
5
6
7
8
9

def example1
 'example1 method'
end

example1 #=> "example1 method"

example1 = 'assigned value'

example1 #=> "assigned value"

Here, we define a method, and then make an assignment. As we assign to a bareword, Ruby creates a new local variable.

As soon as a value is assigned to the local variable, the method no longer gets called.

Example 2

But, what if we also have an assignment method?

1
2
3
4
5
6
7
8
9
10
11
12
13

def example2
 'example2 method'
end

def example2=(value)
 puts "example2= called" # (this never gets called)
end

example2 #=> "example2 method"

example2 = 'assigned value'

example2 #=> "assigned value"

Adding the method example2= does not change things. When we assign to a bareword, Ruby takes it as assignment to a local variable.

Example with a Class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class Foo

 attr_accessor :bar

 def initialize
   @bar = 42
 end

 def method1
   puts bar
 end

 def method2
   bar = 99
   puts bar
 end

 def method3
   bar = 99
   puts self.bar
 end

end

foo = Foo.new

foo.bar  #=> 42
foo.method1 #=> 42
foo.method2 #=> 99
foo.method3 #=> 42

method2 is the problem case. bar is assigned to, creating a local variable, so subsequent calls to bar return 99. method3 disambiguates by explicitly calling the bar method on self.

The Cause

There are two things going on here:

1. bareword assignment creates local variables,
2. local variables mask methods of the same name.

Refactoring Might Break Code

One solution is to use self.method only in cases where local variables mask methods. The problem with this approach is that code may be altered, introducing local variables, and so altering the behaviour of following code:

Original Code

1
2
3
4
5
6
7
8
9
10
11

class Foo
 attr_accessor :bar

 def baz
   puts bar
 end
end

foo = Foo.new
foo.bar = 42
foo.baz #=> 42

Modified Code

1
2
3
4
5
6
7
8
9
10
11
12

class Foo
  attr_accessor :bar

  def baz
    bar = 99 # <= variable assignment introduced
    puts bar
  end
end

foo = Foo.new
foo.bar = 42
foo.baz #=> 99

Solution

The best solution is to always call instance methods on self.

The HTML5 history API allows AJAX-based sites to avoid “breaking the back button”. Every time you update the page, you store the new content is the window.history object. When the user presses the back button, you retrieve the current item from window.history and update the page with it.

What follows is an “all-in-one page” Sinatra/jQuery program. You can find the code here.

Run it like this:

1

  $ ruby history_api.rb

The program allows you to browse back and forwards through numbered pages.

When the first page is shown, the initial content of the container is stored in the history object:

1

history.replaceState( $( '#container' ).html(), '', location.href );

As you select links, only the content of the ‘container’ DIV gets updated. An AJAX call is made to get the content, which is stored in the history object:

1
2
3
4
5
6

   var anchor = this;
    $.get( this.href, function( data ) {
      history.pushState( data, '', anchor.href );
      $( '#container' ).html( data );
      updateLinks( anchor.getAttribute( 'data-number' ) );
    } );

Each time the back button is pressed, the content is retrieved and placed in the container:

1
2
3

onpopstate = function( event ) {
  $( '#container' ).html( event.state );
};

Notice that pressing the forward and back buttons updates the page correctly without needing to call the server.

1
2

Person person( 123 );
std::cout << person << endl;

While working on my C++ ActiveRecord implementation, I had a few problems implementing the insertion operator for the main ActiveRecord::Base class.

The class ActiveRecord::Base class is a template class, and the problem was how to correctly declare the operator.

At the time I was unable to find examples on the Internet, so I thought I’d provide my own.

The Insertion Operator

By “insertion operator” I mean

1

ostream & operator<<( ostream &out_stream, const C& c );

This is a global function that can called like this:

1

std::cout << c;

This operator allows you to output a string representation of your classes, which is very handy for debugging:

1
2
3

C c;
c.do_stuff();
std::cout << c << endl;

The Example

A Class

Here’s an example class which (rather reduntantly) wraps an STL std::list:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <list>

using namespace std;

template < class T >
class MyList {
 public:
  MyList() {};
  void add( T item ) {
    data_.push_back( item );
  }
  int length() const {
    return data_.size();
  }
 private:
  list< T > data_;
};

Serialization

While debugging and testing, it would be handy to be able to output a string representation of an instance of this class.

1
2
3
4

MyList<int> ints;
ints.add( 42 );
ints.add( 13 );
std::cout << ints << endl;

Which should work like this:

$ ./my_list
2 items:
  42
  13

Implementation

Here’s an implementation that just outputs the number of items:

1
2
3
4
5

template< class T >
ostream & operator<<( ostream &out_stream, const MyList< T >& a_list ) {
  out_stream << a_list.length() << " items:" << endl;
  return out_stream;
}

Next, we want the operator to iterate over the list<T> member and output its values.

The main sticking point for me here was the declaration of the iterator. The following is not sufficient:

1
2
3

...
for( list<T>::const_iterator it = a_list.data_.begin(); it != a_list.data_.end(); ++it ) {
...

and produces this error message (with gcc):

to_ostream.cpp: In function 'std::ostream& operator<<(std::ostream&, const MyList<T>&)':
to_ostream.cpp:7: error: expected `;' before 'it'
to_ostream.cpp:7: error: 'it' was not declared in this scope

What’s missing is the typename keyword to tell the compiler that we’re instantiating an iterator:

1
2
3

...
for( typename list<T>::const_iterator it = a_list.data_.begin(); it != a_list.data_.end(); ++it ) {
...

Here’s the final implementation:

1
2
3
4
5
6
7
8

template< class T >
ostream & operator<<( ostream &out_stream, const MyList< T >& a_list ) {
  out_stream << a_list.length() << " items:" << endl;
  for( typename list<T>::const_iterator it = a_list.data_.begin(); it != a_list.data_.end(); ++it ) {
    out_stream << "\t" << *it << endl;
  }
  return out_stream;
}

The function also has to access the private data_ member, which entails declaring it as a friend:

1
2
3
4
5
6

template < class T >
class MyList {
 template< class T1 >
 friend ostream & operator<<( ostream &out_stream, const MyList< T1 >& a_list );
 ...
};

Here’s the whole class with the operator:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
#include <list>

using namespace std;

template < class T >
class MyList {
 template< class T1 >
 friend ostream & operator<<( ostream &out_stream, const MyList< T1 >& a_list );
 public:
  void add( T item ) {
    data_.push_back( item );
  }
  int length() const {
    return data_.size();
  }
 private:
  list< T > data_;
};

template< class T >
ostream & operator<<( ostream &out_stream, const MyList< T >& a_list ) {
  out_stream << a_list.length() << " items:" << endl;
  for( typename list<T>::const_iterator it = a_list.data_.begin(); it != a_list.data_.end(); ++it ) {
    out_stream << "\t" << *it << endl;
  }
  return out_stream;
}

And here’s an example of it’s use:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <string>

int main( int argc, char **argv ) {
  MyList< int > my_ints;
  my_ints.add( 1 );
  my_ints.add( 2 );

  cout << "myints" << endl;
  cout << my_ints << endl;

  MyList< string > my_strings;
  my_strings.add( "hello" );
  my_strings.add( "world" );

  cout << "mystrings" << endl;
  cout << my_strings << endl;

  return 0;
}

The output:

$ ./to_ostream 
myints
2 items:
        1
        2

mystrings
2 items:
        hello
        world

I’m trying out Gosu, which is a 2D game library written in C++ with Ruby bindings (Wikipedia article).

The Ruby documentation is sparse but sufficient.

The gem is easy to install:

$ gem install gosu

A ‘Hello World!’ app requires about 20 lines of code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

require 'rubygems'
require 'gosu'

class HelloWindow < Gosu::Window

  def initialize
    super( 250, 100, false )
    @background_image = Gosu::Image.new( self, 'hello_world.png' )
  end

  def draw
    @background_image.draw( 0, 0, 1 )
  end

  def button_down(id)
    close
  end

end

HelloWindow.new.show

Run it like this:

$ ruby hello_gosu.rb

The program creates the window shown at the start of this article.

The complete code is in a GitHub repository.

• I use ‘g’ instead of ‘git’,
• I’ve set up bash autocompletion for ‘g’, just like ‘git’.

Previously, I used the following in my ~/.bashrc:

...
alias gts='git status'
alias gtd='git diff'
...

Setup

Set Up ‘g’ as an alias for ‘git’

...
alias g='git'
...

2. Locate the Bash Completion File for Git

Locate your bash_completion.d directory:

• On Linux, /etc/bash_completion.d
• I’m using OS X with Mac Ports, so mine is at /opt/local/etc/bash_completion.d.

3. Add Completion for ‘g’

Add the following to the end of git-completion.bash: complete -o bashdefault -o default -o nospace -F _git g 2>/dev/null \ || complete -o default -o nospace -F _git g Now, if you type:

$ g |<TAB>

$ g |
add                 commit              init                request-pull 
am                  config              instaweb            reset 
annotate            describe            log                 revert
...

1

$ rake build

I’ve put together a rake-based system for building C and C++ projects.

I’ve called it Rake::Builder, it’s available on GitHub here.

autoconf

Build systems are complicated by external dependencies: finding third-party headers and libraries. Often there is a specific configuration for each operating system and distribution.

The standard system is GNU’s autoconf system, but it is a nightmare. At the most simple level, you distribute source code with a Makefile.
The problem is that Makefiles are just pure dependency managers - if they don’t find what they need, they just fail.
The solution to that problem is the use of configure. Configure runs a series of compatibility tests, sniffs the host system and spits out a Makefile.
So, with configure, the user then does the following: $ ./configure $ make $ sudo make install

But, configure itself is a long file, and it’s is a program: about 6000 lines of shell code.

A few lines:

ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

The solution to having to maintain configure? Generate it!

With autotools, there is a seemingly eternal regress of configuration files and scripts generated by other scripts.

This was my project’s root directory listing before I gave up on autoconf:

AUTHORS
COPYING
ChangeLog
EXAMPLE
INSTALL
Makefile
Makefile.am
Makefile.in
NEWS
README
aclocal.m4
autom4te.cache
config.h
config.h.in
config.log
config.status
configure
configure.ac
depcomp
include
install-sh
missing
objects
src
stamp-h1
test

Fifteen of those files are involved in the mechanics of autoconf.

Autoconf doesn’t really address the issue of building on various systems and adapting semi-automatically. You still have to add all the settings, but you have to learn where in a myriad of files these settings are to be placed.

Rake

Of the autoconf alternatives, rake seems to offer the cleanest solution. Rake itself was apparently created as a build system for C, but out of the box it’s too generic: it’s simply a dependency handling system.

There are already a number of specializations of rake. In Rails projects, and Gem building, Rakefiles handle maintenance, testing, documentation building and packaging.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

spec = Gem::Specification.new do |s|
  s.name             = 'rake-builder'
  s.summary          = 'Rake for C/C++ Projects'
  s.description      = 'Provides Rake:Builder, a specific rake TaskLib for building C, C++, Objective-C and Objective-C++ projects'
  s.version          = Rake::Builder::VERSION::STRING

  s.homepage         = 'http://github.com/joeyates/rake-builder'
  s.author           = 'My Name'
  s.email            = 'my.email@xmail.com'

  s.files            = ADMIN_FILES +
                       SOURCE_FILES +
                       EXAMPLE_SOURCE_FILES +
                       EXAMPLE_EXTRA_FILES
  s.require_paths    = [ 'lib' ]
  s.add_dependency( 'rake', '>= 0.8.7' )

  s.has_rdoc         = true
  s.rdoc_options     += RDOC_OPTS
  s.extra_rdoc_files = RDOC_FILES

  s.test_files       = SPEC_FILES
end

Rake::Builder is my attempt to specialise rake to the task of building C and C++ projects.
I’ve got to version 0.0.11 and it now builds the following types of projects:

• C++,
• QT C++,
• C
• Objective-C

This is an example with two build targets: a static library and a test executable, with the test project depending on the library:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

require 'rake/builder'

Rake::Builder.new do |builder|
  builder.target               = 'libactive_record_sqlite.a'
  builder.source_search_paths  = [ 'src' ]
  builder.header_search_paths  = [ 'include/**/*.h' ]
  builder.objects_path         = 'objects'
  builder.include_paths        = [ 'include' ]
  builder.library_dependencies = [ 'sqlite3' ]
end

Rake::Builder.new do |builder|
  builder.task_namespace       = :test
  builder.target               = 'active_record_test'
  builder.source_search_paths  = [ 'test' ]
  builder.header_search_paths  = [ 'test' ]
  builder.objects_path         = 'test/lib_objects'
  builder.include_paths        = [ 'include', 'test' ]
  builder.library_dependencies = [ 'sqlite3', 'gtest', 'gtest_main', 'active_record_sqlite' ]
  builder.library_paths        = [ 'objects' ]
  builder.target_prerequisites = [ :'rake:build' ]
  builder.default_task         = [ :run ]
end

I’m about to start using Rake::Builder on a sizable C++ project using QT, so I’ll have a chance to see if it handles real world stuff without turning into autoconf.

The Site

I have a young relative who draws a lot of comic strips, and thinking it would be nice if he could publish them, I looked around for an Open Source system.
I wanted something that was as near to XKCD as possible - latest comic, next/previous and random.
Not finding anything that was both pretty and ultra-simple, I decided to write my own.
The version for my relative is here - the system will be up on GitHub as soon as I finish making it configurable.

Technologies

Web Framework

If you’ve read the title of this post, you won’t be surprised to read that I chose Sinatra.

Database

I decided to use DataMapper as the ORM.
I’m also using SQLite for both development and production.

HTML and CSS

As will be clear from the example site, I didn’t work over hard on making a fresh graphic look - all I did was strip out a lot of HTML that was there to make rounded corners, and replaced it with Mozilla and WebKit specific rounding.
I then translated the HTML into HAML and the CSS into SASS (SCSS).

Development

Documentation for Sinatra, DataMapper, HAML and SASS is quite good, so things went quite smoothly. What follows is a list of the phases I went through while developing (on Ubuntu), and especially the bits I had trouble with.

DataMapper

Installation

  $ sudo gem install dm-core

  $ sudo gem install data_objects
  $ sudo gem install data_mapper
  $ sudo gem install do_sqlite3

Using DataMapper in Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  require 'dm-core'
  require 'data_mapper'

  DataMapper.setup({
    :adapter => 'sqlite3',
    :host => 'localhost',
    :username => '',
    :password => '',
    :database => 'db/sidcom_development'
  })

  class Comic
    include DataMapper::Resource

    property :title, :text
    property :permalink, :text
    property :created_at, :datetime
    property :updated_at, :datetime
  end
  Comic.auto_upgrade!

The ’Comic.auto_upgrade!’ bit handles migrations - at startup, table columns are adjusted to match the declaration in the equivalent class.

Rack

Authentication

This application has a ‘public’ and an ‘admin’ area, so I actually created two Sinatra Apps, wrapping one in Rack::Auth::Digest::MD5. A local settings file holds user names and hashed (kinda salted) passwords.

Sinatra

Sinatra apps have access to a number of globals, I used:

• request,
• params
  

Helpers

This app being a little more complex than my first, I decided to implement some Rails-like helpers.
The most important helper is url_for. Sinatra - by design - includes routing in the structure of an app, so it cannot provide pre-cooked methods of the sort.

HAML

I found HAML very easy to start using, what I didn’t immediately understand was:

• how to interpolate variables,
• how to call functions,
• and how to include partials.

These are actually all the same problem, but it took me a while to realize that!
In HAML, you can interpolate the Ruby way (with ’#{...}’) or the HAML way (with ’=’).

Variable Interpolation

Just use Ruby String interpolation:

  %h1 Hello #{ @name }!

Calling Functions

Use HAML evaluation syntax:

  %h1
    = @name
    !

HAML partials

Again, these can be evaluated as above:

  = haml(:_my_partial, :layout => false)

SASS

Generating CSS

I chose to keep my SCSS files in a subdirectory under my views directory, and generate CSS from them under the static path.

During development, you need to keep the static versions up to date, and to do so, you just need to keep a process running as follows:

  $ sass --watch views/stylesheets:static/stylesheets

Conclusion

Sinatra handles small sites very well. The code can be kept DRY, and if you decide to, Sinatra projects can be quite easily transformed into Rails projects.
Actually, I have doubts whether it was worth doing this project in Sinatra - a stripped-down Rails 3 project would have been just as lightweight and easy to develop. But, then again, it’s useful to run a sytem through its paces, to have an idea what areas it can usefully be applied to.

Preparation

Assuming you have a working GCC build environment, all you have to do is install the googletest packages:

  $ sudo apt-get install libgtest0 libgtest-dev

Makefile

The only think of note about the Makefile is that it includes ‘libgtest_main’ - which implements main() and calls RUN_ALL_TESTS()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

NAME = hello-world

LIBS = -lgtest_main

debug: all
run-debug:
  ./${NAME}

all: $(NAME).o
  c++ -lstdc++ $(LIBS) -o $(NAME) $(NAME).o

compile: $(NAME).o

clean:
  find . -name '*.o' -exec rm -f {} ';'
  find . -name $(NAME) -exec rm -f {} ';'

$(NAME).o: $(NAME).c++
  gcc -c -I. -o $(NAME).o $(NAME).c++

.c++.o:
  gcc -c -I. -o $@ $<

Source

I’ve put everything into a single source file to keep things minimal:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/////////////////////////////
// In the header file

#include <sstream>
using namespace std;

class Salutation
{
public:
  static string greet(const string& name);
};

///////////////////////////////////////
// In the class implementation file

string Salutation::greet(const string& name) {
  ostringstream s;
  s << "Hello " << name << "!";
  return s.str();
}

///////////////////////////////////////////
// In the test file
#include &lt;gtest/gtest.h&gt;

TEST(SalutationTest, Static) {
  EXPECT_EQ(string("Hello World!"), Salutation::greet("World"));
}

Compilation

Just run:

  $ make

Output

This test produces the following:

$ ./hello-world
Running main() from gtest_main.cc
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from SalutationTest
[ RUN      ] SalutationTest.Static
[       OK ] SalutationTest.Static
[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran.
[  PASSED  ] 1 test.

Conclusion

It couldn’t really be much simpler!

Each C++ object needs to hold its instance data. But, there is often not a perfect match between the sum of the byte sizes of the member variables and the size of an object: The space occupied will often be greater than the sum of the sizes of the member variables.

The reasons are:

• compiler-specific alignment issues: in order to speed up access, a few bytes can be wasted for each instance to ensure that all the members are aligned on a word boundary,
• the presence of a pointer to the virtual function table,
• empty classes.

An empty class

An empty class has no member variables, but does not occupy 0 bytes of memory. The ISO standard mandates that objects of any class must occupy at least one byte.

To show this, I’ll call the following code (see the end for the code used to dump objects):

1
2
3
4

class A {};

A a;
dump_instance("An empty class:", a);

The output shows the memory location of the instance, its size end content:
GCC:

An empty class:
  bfd3dfdf -> instance (1 byte):
    00

Visual C++:

An empty class:
  0012ff5f -> instance (1 byte):
    00

In both cases, the instance of the empty class occupies 1 byte. And, in both cases, the byte seems to have been initialized to 0.

Classes with member variables

Next, I’ll do the same for a non-empty class with a single int member variable. (I’ll initialize member variables to make the dumps easier to read.)

1
2
3
4
5
6
7
8
9

class B {
public:
  B(): i(0xbbbbbbbb) {};
private:
  int i;
};

B b;
dump_instance("A class with an int member:", b);

The memory occupied is exactly the size of the member (4 bytes):
GCC:

A class with an int member:
  bfa25e08 -> instance (4 bytes):
    bb bb bb bb 

Visual C++:

A class with an int member:
  0012ff64 -> instance (4 bytes):
    bb bb bb bb 

This case is the simplest of all. You get exactly what you expect: a four byte type occupying 4 bytes.

Word alignment

char, a single-byte-sized type, gets word-aligned both by GCC and Visual C++. Notice that three uninitilised bytes follow the byte containing 0xaa:

1
2
3
4
5
6
7
8
9
10

class C {
public:
  C(): ch(0xaa), i(0xbbbbbbbb) {};
private:
  char ch;
  int i;
};

C c;
dump_instance("A class with char and int members:", c);

GCC:

A class with char and int members:
  bfd3dfcc -> instance (8 bytes):
    aa 5e a2 bf bb bb bb bb 

Visual C++:

A class with char and int members:
  0012ff68 -> instance (8 bytes):
    aa 77 40 00 bb bb bb bb 

Both implementations allocate 8 bytes, wasting 3 bytes after the char, in order to word align the int.

The same is true if the char follows the int:

1
2
3
4
5
6
7
8
9
10

class D {
public:
  D(): i(0xbbbbbbbb), ch(0xaa) {};
private:
  int i;
  char ch;
};

D d;
dump_instance("A class with int and char members:", d);

GCC:

A class with int and char members:
  bfd3dfc4 -> instance (8 bytes):
    bb bb bb bb aa ad 04 08 

Visual C++:

A class with int and char members:
  0012ff70 -> instance (8 bytes):
    bb bb bb bb aa bf 40 00 

Member functions

Beyond data, the compiler needs to be able to call the object's functions. Member functions are shared between all instances of a class and so are only stored in one place. In the case of non-virtual member functions, nothing needs to be included in the class to allow name resolution.

1
2
3
4
5

class NonVirtual {
  void f() {}
};
NonVirtual nv;
dump_instance("A class with a single member function:", nv);

GCC:

A class with a single member function:
  bfbdeb5e -> instance (1 byte):
    53 

Visual C++:

A class with a single member function:
  0012ff5f -> instance (1 byte):
    00 

This example is similar to the empty class above: having no member variables, and no virtual member functions (below), the compiler is forced to waste one byte, to comply with the standard’s mandate of not having zero-sized classes. Visual C++ seems to initialize the byte.

Virtual member functions

Object derivation means that the list member functions callable on an object must be prepared by the compiler. If a base class implements a functions and it is not overridden by a derived class, the derived class must use the base class's implementation. But, if a derived class overrides, then it is that implementation that must be used.

The mechanism that compilers use to achieve this is not mandated by the C++ standard, but most implementations use the concept of the "virtual function table". For every class that has virtual members, a table is created which maps function names to their implementations. If a class has virtual functions, the compiler creates a unique vtbl for the class. This vtbl has pointers to the implementations of the member functions. Each instance holds a pointer (vptr) to its class’s vtbl. In the case of virtual inheritance, the derived class has a vtbl, which has a mix of pointers to member functions: those overridden in the derived class and those inherited.

1
2
3
4
5
6

class E {
  virtual void f() {}
};

E e;
dump_instance("A class with a virtual member function:", e, 1); // We supply the number of virtual methods

A class with a virtual member function:
  bfd3dfd4 -> instance (4 bytes):
    f8 aa 04 08 
    vtbl (0804aaf8 - 0804aafb) 1 entry:
      0804aaf8 -> fptr 0:
        08048cec 
        08048cec -> implementation (first 16 bytes):
          55 89 e5 5d c3 90 55 89 e5 8b 45 08 c7 00 e8 aa 

A class with a virtual member function:
  0012ff60 -> instance (4 bytes):
    e4 50 41 00 
    vtbl (004150e4 - 004150e7) 1 entry:
      004150e4 -> fptr 0:
        00405370 
        00405370 -> implementation (first 16 bytes):
          c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 

This class’s instances occupy 4 bytes, which hold the pointer to the class’s virtual function table.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class F {
public:
  F() : fdata(0xffffffff) {}; // Initialize with easy-to-spot data to make dumps clearer
  virtual int f(void) = 0;
private:
  int fdata;
};

class F1 : F {
public:
  F1() : f1data(0xf1f1f1f1) {}; // Initialize with easy-to-spot data to make dumps clearer
  virtual int f(void) { return 0x33333333; }
private:
  int f1data;
};

F1 f1;
dump_instance("A subclass of an abstract class:", f1, 1);

GCC:

A subclass of an abstract class:
  bfd3dfb8 -> instance (12 bytes):
    d8 aa 04 08 ff ff ff ff f1 f1 f1 f1 
    vtbl (0804aad8 - 0804aadb) 1 entry:
      0804aad8 -> fptr 0:
        08048d30 
        08048d30 -> implementation (first 16 bytes):
          55 89 e5 b8 33 33 33 33 5d c3 55 89 e5 8b 45 08 

Visual C++:

A subclass of an abstract class:
  0012ff78 -> instance (12 bytes):
    e0 50 41 00 ff ff ff ff f1 f1 f1 f1 
    vtbl (004150e0 - 004150e3) 1 entry:
      004150e0 -> fptr 0:
        00401140 
        00401140 -> implementation (first 16 bytes):
          b8 33 33 33 33 c3 90 90 90 90 90 90 90 90 90 90 

Both compilers place the vtbl at the start of the instance memory, so a pointer to the instance is a pointer to a pointer to the vtbl. The instance data follows, laid out in “class derivation order”.

Object dumping code

The examples in this article are available from Github.

The function dump_instance() prints the memory occupied by the object.

1
2
3
4
5
6
7
8
9
10

template<class T>
void dump_instance(const char * title, const T& t, int virtuals = 0) {
  cout << title << endl;
  stringstream sstr;
  sstr << "instance (" << object_size(t) << "):";
  dump_memory((unsigned char *) &t, sizeof(t), sstr.str().c_str(), 1);
  if (virtuals > 0)
    dump_vtable(t, virtuals);
  cout << endl;
}

The rest of the code is handles printing blocks of memory, and the virtual function table:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// output formatting helper
void indent(int depth) {
  for(int i = 0; i < depth; ++i)
    printf("  ");
}

template <class T>
void dump_memory(const T * p, size_t items, const char * title, int depth) {
  indent(depth);
  printf("%08x -> %s\n", (unsigned int) p, title);
  // Make a format string that prints hex with correct number of leading zeroes
  stringstream sstr;
  sstr << "%0" << sizeof(T) * 2 << "x ";
  string format = sstr.str();
  indent(depth + 1);
  const T * end = p + items;
  for(const T * chunk = p; chunk < end; ++chunk) {
    printf(format.c_str(), *chunk);
  }
  printf("\n");
}

// Pretend all pointers are to int to reduce number of casts
template<class T>
void dump_vtable(const T& t, int virtuals) {
  // In memory, the first bytes of the instance are occupied by the vtable
  int * vtbl = (int *) &t;
  int vtable_size = virtuals * sizeof(int);
  indent(2);
  printf("vtbl (%08x - %08x)", *vtbl, *vtbl + vtable_size - 1);
  printf(" %d entr%s:\n", virtuals, ((virtuals == 1) ? "y" : "ies"));
  for(int i = 0; i < virtuals; ++i) {
    int * fptr = ((int **) vtbl)[i];
    stringstream sstr;
    sstr << "fptr " << i << ":";
    dump_memory(fptr, 1, sstr.str().c_str(), 3);
    dump_memory((unsigned char *) *fptr, 16, "implementation (first 16 bytes):", 4);
  }
}

template<class T>
string object_size(const T& t) {
  stringstream sstr;
  sstr << sizeof(t) << " byte";
  if (sizeof(t) != 1)
    sstr << "s";
  return sstr.str();
}

Notes

The text assumes a 32-bit, little-endian machine.

References:

• http://www2.research.att.com/~bs/bs_faq2.html#layout-obj
• http://www2.research.att.com/~bs/bs_faq2.html#sizeof-empty
• http://www.cprogramming.com/tutorial/size_of_class_object.html

A month earlier, East Sussex county council had tried to warn them of the inevitable outcome if they were to proceed.

The warning was not heeded.

A spokesman said that traffic is now at record levels (for the tunnel, that is).

Using Sinatra reminds me of my first programming experiences - you write a tiny bit of code, with no boilerplate and get to see a result.

What follows owes a lot to the Sinatra README.

Installation

On Linux, you’ll need Ruby and Rubygems installed (if not you should find installation instructions easily enough via a Web search).

Apart from Ruby, you’ll need to use a text editor (e.g. GEdit) a Web browser and the Terminal (normally found in the Applications menu under Accessories).

Next install Sinatra:

$ gem install sinatra

1. Hello World!

1
2
3
4
5
6

require 'rubygems' if RUBY_VERSION < '1.9'
require 'sinatra';

get '/' do
  'Minimal Sinatra Hello World!'
end

Now, open a Terminal window and type:

ruby minimal.rb

Finally, go to this address: http://127.0.0.1:4567/

To stop the program, go to the Terminal window and press Ctrl+C

2. Adding Structure: Sinatra::Base

It’s useful to structure the program as a class.

1
2
3
4
5
6
7
8
9
10

require 'rubygems' if RUBY_VERSION < "1.9"
require 'sinatra/base'

class MyApp < Sinatra::Base
  get '/' do
    'Hello World!'
  end
end

MyApp.run!

Run it:

ruby sinatra_base.rb

3. Structure: A Separate App File

Create two files:

1
2
3
4
5
6
7
8

require 'rubygems' if RUBY_VERSION < "1.9"
require 'sinatra/base'

class MyApp < Sinatra::Base
  get '/' do
    'Hello World from MyApp in separate file!'
  end
end

1
2
3

require 'my_app'

MyApp.run!

Run it:

$ ruby run_my_app.rb

4. Rackup

Instead of writing a script to start the app, we can use Rackup to launch the same script:

Create a file ‘config.ru’:

require 'my_app'

run MyApp.new

Run it:

rackup config.ru

This time the application is visible at http://127.0.0.1:9292

If we want it to have the same address as before, we can run it like this:

rackup config.ru --port=4567

5. Static Files

A Web application will often have dynamic content (what we’ve created so far) and static content (e.g. images).

Create a directory ‘static’, and create a file called index.html in containing:

This is a static file.

1
2
3
4
5
6
7

require 'rubygems' if RUBY_VERSION < "1.9"
require 'sinatra/base'

class MyApp < Sinatra::Base
  set :static, true
  set :public, File.dirname(__FILE__) + '/static'
end

Now, if you run rackup, and go to http://127.0.0.1:4567/index.html you will see the content.

6. Routes

1
2
3
4
5
6
7
8

<ul>
  <li><a href="named_via_params/foo">Named parameters via params Hash</a></li>
  <li><a href="named_via_block_parameter/foo">Named parameters via block parameters</a></li>
  <li><a href="splat/foo/bar/baz">Multiple parameters via params[:splat]</a></li>
  <li><a href="splat_extension/myfile.txt">Filename via params[:splat]</a></li>
  <li><a href="regexp_params_captures/foobar">Using regular expression via params[:captures]</a></li>
  <li><a href="regexp_captures_via_block_parameter/foobar">Using regular expression via block parameters</a></li>
</ul>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

require 'rubygems' if RUBY_VERSION < "1.9"
require 'sinatra/base'

class MyApp < Sinatra::Base
  set :static, true
  set :public, File.dirname(__FILE__) + '/public'

  get '/named_via_params/:argument' do
    "
Using: '/named_via_params/:argument'<br/>
params[:argument] -> #{params[:argument]} (Try changing it)
"
  end

  get '/named_via_block_parameter/:argument' do |argument|
    "
Using: '/named_via_block_parameter/:argument'<br/>
argument -> #{argument}
"
  end

  get '/splat/*/bar/*' do
    "
Using: '/splat/*/bar/*'<br/>
params[:splat] -> #{params[:splat].join(', ')}
"
  end

  get '/splat_extension/*.*' do
    "
Using: '/splat_extension/*.*'<br/>
filename -> #{params[:splat][0]}<br/>
extension -> #{params[:splat][1]}
"
  end

  get %r{/regexp_params_captures/([\w]+)} do
    "params[:captures].first -> '#{params[:captures].first}'"
  end

  get %r{/regexp_captures_via_block_parameter/([\w]+)} do |c|
    "c -> '#{c}'"
  end

end

Go to http://127.0.0.1:4567/routes.html

You will see a list of links which exemplify different types of route matching.

7. Templates

Create a ‘views’ directory.

1

This is <%= @foo %>

1
2
3
4
5
6
7
8
9
10

require 'rubygems' if RUBY_VERSION < "1.9"
require 'sinatra/base'
require 'erb'

class MyApp < Sinatra::Base
  get '/template' do
    @foo = 'erb'
    erb :index
  end
end

You should get the following on http://localhost:4567/template:

The Application

I decided to use Django to write a small local history application: the story of Snape in East Sussex.

The front and of the application uses a SIMILE timeline to display dates.

Personal Impressions about Django

Apps

The main thing I was looking forward to while writing the app was modularity. In fact, in the and I made two apps: the specific Snape application and a generic timeline app.

Creating the Database

In Rails, you launch script/generate Model and you obtain a database and a series of migrations, which form a chronology of development of the database.

In Django, you describe the database fields in your model.py file and the run ’manage.py syncdb’.

The advantage of the Django system is that the model holds authoritative information about the fields in the database.

The great disadvantage is that there are no TABLE ALTERing migrations - you have to dump the table creation SQL and manually construct and run TABLE ALTER commands.

Settings

Django’s settings file (settings.py) more or less has to be site specific. So that means you have to decide what to check in to your version control system. Some people seem to use a ‘settings.py.default’ which they then copy to settings.py and alter tho the needs of a specific machine.

I chose to keep site specific stuff in a set of JSON files, named after the local machine (see http://gnuvince.wordpress.com/2007/03/15/local-settings-in-django/). It woks quite well, but in Rails as I commonly have a single development machine and a single production one, I am able to avoid the whole problem thanks to config/environments/[development|production].rb

Static Content

There is a difference between how one handles static files in development and production. Most people seem to use a hack in the urls.py file, indicating where to get static content if in DEBUG mode, whereas in production mode you are supposed to set up Apache aliases for the various directories.

The logic here is that Django should not get involved in serving static content (quite rightly), but it certainly makes setup more laborious. One can achieve a happy medium in Rails using X-SendFile - Rails gets the request and then punts serving to Apache.

Generating URLs

There is an equivalent to Rails’ url_for which is available inside Django templates, it’s the filter { % url %}. Unfortunately, the first time I wanted to create a URL was actually in Python code - I wanted to redirect. I was unable to find a way to use url from Python code. There is get_absolute_url, which can be implemented inside the model, but it’s only for instances.

Overall

I think Django is fairly straightforward for the Rails programmer. The fact that you get a ‘free’ admin backend (similar to ActiveScaffold), is certainly handy. There are a lot of sources of online information and tutorials, so it’s quite easy to get up and running. The main impression I got was of a small framework - while Rails covers a great range of functionality, I felt I came up against Django limitations rather quickly. That may be due to not looking in the right places, but my Google searches showed that a lot of other people were asking the same questions.

It works very well as it uses true parsing, not heuristics, to analyse code.

Installation

• Download http://js2-mode.googlecode.com/files/js2-20090723b.el
• Rename the file as js2-mode.el
• Move it to a directory in your ‘load-path’ (~/.emacs.d/ should work),
• Compile it:
  • Start Emacs,
  • Run the following command:

M-x byte-compile-file
js2-mode.el

Use

Add the following to your .emacs file:

  (require 'js2-mode)
  (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))

This associates all Javascript files with JS2 mode.

Some features of the mode are:

• Highlighting of syntax errors and doubtful structures, e.g. missing ‘;’, and undeclared variables,
• The auto-indentation system works.

I often make Javascript files dynamic in Rails projects, and the only feature I would wish for is for handling of Ruby ERB tags - currently they completely confuse the parser.

Many people have written about showing the current git branch in your shell prompt.

There is even the Bash function __git_ps1 provided in the main Git repo.

I prefer to show info like the current time and current git branch in a GNU screen status line.

Screen Status

As I use screen constantly, I decided to take a different route: put the current branch name in my screen status line.

Changing the Screen Current Directory

When you start screen, it remembers the current directory. Issuing ‘cd’ commands inside a shell does not change the value. The only way to change it is to issue a screen chdir command.

In order to know the current branch in a particular screen window, I needed to make screen’s current directory change to follow the shell it is presenting.

I added the following to my .bashrc:

1
2
3
4
5
6
7
8
9

function set_screen_path() {
  screen -X chdir "`pwd`"
}

case $TERM in
screen*)
  PROMPT_COMMAND=set_screen_path
  ;;
esac

This is Bash specific, but similar code should work in other shells.

git-current-branch

Next, I created the following shell script:

1
2
3

#!/bin/sh

git branch 2>/dev/null | grep '*' | sed 's/\* //'

.screenrc

And finally, I added a ‘backtick’ command to my .screenrc file:

startup_message off

backtick 1 0 1 git-current-branch

hardstatus alwayslastline "%-w%{.bw}%n %t%{-}%+w %-45= %1`"

screen -t bash 0
screen -t edit 1
select 0

The important line is:

backtick 1 0 1 git-current-branch

which creates a ’backtick command’ (number 1) which calls git-current-branch once a second via %1` in the hardstatus line.

The Result

Conclusion

This system is not perfect as the shell only notifies screen of its directory when a new prompt is created.

The result is that if you switch screens, the status line doesn’t get updated until after you issue a command.

The Project

The project is hosted on GitHub.

The gem is available from here.

Using ruby-sun-times

$ irb
>> require 'rubygems'
=> true
>> require 'sun_times'
=> true
>> SunTimes.set( Date.today, 44, 11 ).localtime
=> Tue Mar 09 18:14:08 +0100 2010

So, the sun will be setting round here at 6:14 PM local time.

Below is a minimal example: the aim is (as usual) to produce a greeting - this time in English and Italian.

Installation

$ gem install i18n

The t method

The most common use of i18n is via I18n.translate which has an abbreviated alias I18n.t.

Translations

1
2

en:
  hello world: Hello World!

1
2

it:
  hello world: Ciao Mondo!

These translations can be accessed as follows:

I18n.t( 'hello world' )

That will use the current locale setting. You can change it as follows:

I18n.locale = :it

The Program

After loading the i18n gem, set up I18n.load_path before attempting to retrieve any transaltions.

1
2
3
4
5
6
7
8
9
10
11
12

require 'rubygems' if RUBY_VERSION < '1.9'
require 'i18n'

I18n.load_path = ['en.yml', 'it.yml']

puts 'In English...'
I18n.locale = :en
puts I18n.t('hello world')

puts 'In Italian...'
I18n.locale = :it
puts I18n.t('hello world')

The result:

$ ruby salutation.rb
In English...
Hello World!
In Italian...
Ciao Mondo!

You can install PostGIS as a package or from sources. Sometimes the version available from Linux distributions is a bit out of step with the PostgreSQL version that gets installed (i.e. Ubuntu currently installs PostgreSQL 8.4, but only has PostGIS 8.3)

From Sources

Choose which version to download

$ wget http://postgis.refractions.net/download/postgis-1.4.1.tar.gz
$ tar -xkzf postgis-1.4.1.tar.gz
$ cd postgis-1.4.1
$ ./configure
$ make
$ sudo make install

On my system (Ubuntu), the net result is that you get various files copied into /usr/share/postgresql/8.4/contrib:

$ ls /usr/share/postgresql/8.4/contrib
postgis.sql                   postgis_upgrade_13_to_14.sql  postgis_upgrade.sql  uninstall_postgis.sql
postgis_upgrade_12_to_14.sql  postgis_upgrade_14_minor.sql  spatial_ref_sys.sql

Create a PostGIS Template Database

If you create a specific template with PostGIS, and use it instead of template1 (the default) template, you will be able to create PostGIS-enabled databases more quickly.

$ sudo -u postgres createdb template_postgis -E UTF-8

Set the Template Flag

UPDATE pg_database SET datistemplate = TRUE WHERE datname = 'template_postgis';

Make sure pl/pgsql is installed:

$ sudo -u postgres createlang -d template_postgis plpgsql

Insert PostGIS functions and tables:

$ sudo -u postgres psql template_postgis < /usr/share/postgresql/8.4/contrib/postgis.sql
$ sudo -u postgres psql template_postgis < /usr/share/postgresql/8.4/contrib/spatial_ref_sys.sql

Correct Permissions

The PostGIS tables need to be writeable by the owner of the database:

$ sudo -u postgres psql template_postgis
# GRANT ALL ON geometry_columns TO PUBLIC;
# GRANT ALL ON spatial_ref_sys TO PUBLIC;

Create a PostGIS-Enabled Database

$ sudo -u postgres createuser [USER NAME]
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
$ sudo -u postgres createdb [DATABASE NAME] -O [USER NAME] -T template_postgis

Check it Works

$ psql -U [USER NAME] [DATABASE NAME]

First let’s create a ‘locations’ table:

# CREATE TABLE locations (id serial, name character varying);
# SELECT AddGeometryColumn('', 'locations', 'geom', 32661, 'POINT', 2);

Insert a record:

# INSERT INTO "locations" ("name", "geom") VALUES(E'Tokyo International Airport', ST_GeomFromText('POINT(139.783333 35.55)', 32661)) RETURNING "id";
 id
----
  1
(1 row)

INSERT 0 1

Find all results in a given box:

# SELECT * FROM "locations" WHERE ("locations"."geom" && SetSRID(E'BOX3D(130.0 30.0, 140.0 40.0)'::box3d, 32661));
 id |            name             |                        geom
----+-----------------------------+----------------------------------------------------
  1 | Tokyo International Airport | 0101000020957F0000151C5E10117961406666666666C64140
(1 row)

JRuby is normally run on the “official” Sun (now Oracle) Java. Some people seem to be able to get it to run on GNU Java (GCJ), but I suggest sticking with Sun Java to get you started.

Which Type of Installation?

First of all you should decide where to install JRuby - do you want to install it for all system users or just for your own user?

Download

Download the latest JRuby from http://jruby.org/download.

$ wget http://jruby.kenai.com/downloads/1.4.0/jruby-bin-1.4.0.tar.gz
$ tar -xkzf jruby-bin-1.4.0.tar.gz

Personal Installation

$ cd ~/bin
$ cp -r ../jruby-1.4.0 .

Make a symlink to simplify things in the future when we upgrade to a new version:

$ ln -s jruby-1.4.0 jruby

Add the following line to your ~/.bashrc to add JRuby executables to your %PATH:

export PATH=~/bin/jruby/bin:$PATH

System-wide Installation

$ sudo cp jruby-1.4.0 /usr/local/lib
$ sudo ln -s /usr/local/lib/jruby-1.4.0 /usr/local/lib/jruby

Gems

List installed gems:

$ jruby -S gem list

Install a gem (in a personal installation):

$ jruby -S gem install rails

Install a gem (in a system-wide installation):

$ sudo /usr/local/lib/jruby/bin/jruby -S gem install rails

Modifying your Rails Project

You need to look at the list of dependencies of your project, principally the gems, and make sure they are available for JRuby.

Gems written in pure Ruby work ‘out of the box’ with JRuby. But you’ll need to find replacecements for gems which are written in whole or in part in C.

One example of this is RMagick (the Ruby interface to the ImageMagick/GraphicsMagick packages). Ruby on Rails which run on MRI Ruby and use RMagick will have to use RMagick4J under JRuby.

If your Ruby on Rails application has no gem dependency problems, you should be able to run it by changing the name of the database adapter:

1
2
3
4
5
6
7
8
9

<% if RUBY_PLATFORM =~ /java/ %>
development:
adapter: jdbcsqlite3
database: db/development.db
<% else %>
development:
adapter: sqlite3
dbfile: db/development.db
<% end %>

Here I have made use of the fact that Rails runs config/database.yml through ERB before loading it.

Once the database adapter setting has changed, you should be able to run

$ ./script/server

Packaging your application for a servlet container can be done with the warbler gem.

1. MRI Ruby 1.8.7
2. MRI Ruby 1.9.1
3. JRuby 1.4.0

I need a quick way to switch betwwen the three main Ruby executables, and the related other programs (gem, irb, etc).

I have set up Debian Alternatives to handle the job.

Alternatives with Ruby

The programs I want to switch are:

• ruby
• gem
• irb
• ri
• rake
• rails

Ruby MRI 1.8 and 1.9

If you compiled your own ruby 1.8 and 1.9, make sure you indicate the version:

$ ./configure --program-suffix=1.9

Install JRuby

See my other post.

Create Links from /etc/alternatives to /usr/bin

$ cd /usr/bin
$ sudo ln -s /etc/alternatives/ruby
$ sudo ln -s /etc/alternatives/irb
$ sudo ln -s /etc/alternatives/ri
$ sudo ln -s /etc/alternatives/rake
$ sudo ln -s /etc/alternatives/gem

Create Ruby Alternatives

$ sudo update-alternatives \
  --install  /usr/bin/ruby  ruby  /usr/local/bin/ruby1.9   30 \
  --slave    /usr/bin/irb   irb   /usr/local/bin/irb1.9       \
  --slave    /usr/bin/gem   gem   /usr/local/bin/gem1.9       \
  --slave    /usr/bin/ri    ri    /usr/local/bin/ri1.9        \
  --slave    /usr/bin/rails rails /usr/local/bin/rails1.9     \
  --slave    /usr/bin/rake  rake  /usr/local/bin/rake1.9

$ sudo update-alternatives \
  --install  /usr/bin/ruby  ruby  /usr/bin/ruby1.8   20 \
  --slave    /usr/bin/irb   irb   /usr/bin/irb1.8       \
  --slave    /usr/bin/ri    ri    /usr/bin/ri1.8        \
  --slave    /usr/bin/gem   gem   /usr/bin/gem1.8       \
  --slave    /usr/bin/rails rails /usr/bin/rails1.8     \
  --slave    /usr/bin/rake  rake  /usr/bin/rake1.8

$ sudo update-alternatives \
  --install  /usr/bin/ruby  ruby  /usr/local/lib/jruby/bin/jruby   10 \
  --slave    /usr/bin/irb   irb   /usr/local/lib/jruby/bin/jirb       \
  --slave    /usr/bin/ri    ri    /usr/local/lib/jruby/bin/ri         \
  --slave    /usr/bin/rails rails /usr/local/lib/jruby/bin/rails      \
  --slave    /usr/bin/gem   gem   /usr/local/lib/jruby/bin/gem        \
  --slave    /usr/bin/rake  rake  /usr/local/lib/jruby/bin/rake

Check the result

$ update-alternatives --display ruby
ruby - auto mode
 link currently points to /usr/local/bin/ruby1.9
/usr/bin/ruby1.8 - priority 20
 slave gem: /usr/bin/gem1.8
 slave irb: /usr/bin/irb1.8
 slave rails: /usr/bin/rails1.8
 slave rake: /usr/bin/rake1.8
 slave ri: /usr/bin/ri1.8
/usr/local/bin/ruby1.9 - priority 30
 slave gem: /usr/local/bin/gem1.9
 slave irb: /usr/local/bin/irb1.9
 slave rails: /usr/local/bin/rails1.9
 slave rake: /usr/local/bin/rake1.9
 slave ri: /usr/local/bin/ri1.9
/usr/local/lib/jruby/bin/jruby - priority 10
 slave gem: /usr/local/lib/jruby/bin/gem
 slave irb: /usr/local/lib/jruby/bin/jirb
 slave rails: /usr/local/lib/jruby/bin/rails
 slave rake: /usr/local/lib/jruby/bin/rake
 slave ri: /usr/local/lib/jruby/bin/ri
Current `best' version is /usr/local/bin/ruby1.9.

Switch versions

$ sudo update-alternatives --config ruby
There are 3 choices for the alternative ruby (providing /usr/bin/ruby).

  Selection    Path                            Priority   Status
------------------------------------------------------------
* 0            /usr/local/bin/ruby1.9           30        auto mode
  1            /usr/bin/ruby1.8                 20        manual mode
  2            /usr/local/bin/ruby1.9           30        manual mode
  3            /usr/local/lib/jruby/bin/jruby   10        manual mode

Press enter to keep the current choice[*], or type selection number: 1
Using '/usr/bin/ruby1.8' to provide 'ruby'.