Some stats
First of, some statistics: on Monday, the room had 31 members, the number of posts was above 50, including shared items, comments, pictures from flickr. Mind that these stats are gathered on a moment the actual conference wasn’t even started. Among the items posted in the room were (shameless) plugs of sessions, messages about where to eat Belgian food and a bit of thought sharing on which sessions to attend.

A mini viral campain to get traction
A room without members is nothing, so the first thing we needed to do was get people to actually join the room and participate.
Vladimir and I started a mini viral campaign to do that.Some of the things we did where:

• Post a message on mailing lists, like the lean software development, the scrum and the Belgian xp mailing lists
• For a long time, I’m subscribed to the rss feed from agileplanet.org. I commented on a couple of posts that were about agile 2008, mentioning the room.
• A bit of mailing to personal contacts that I knew were going there.

So far, we managed to indeed spread the virus, albeit very moderate. We also saw others mentioning the room, thus spreading the message more. A big thanks for doing so! I am curious to see how the use of the friendfeed room will evolve over the course of the conference. And more important, I’m very interested to see if the room can capture some of the discussions/feedback/insights, etc that will no doubt occur during the conference. What else would you do to give the room more visibility? Did we forget to do some obvious steps? Any feedback is appreciated.

Screenshots
To close of this post, some screenshots of the room, as it was on Monday noon Belgian time.

Promotion of sessions.

Members of the room.

During the next few days, I will try to post more observations, insights and whatever I can think of for our little room.

I have to admit, I’m becoming a FriendFeed addict. I find myself using the service a lot and I’m curious to see how it will evolve. What I find most interesting on FriendFeed is the concept of rooms they have there. At work, we started using a private room of our own, where we post ideas, share little snippets, etc… Some of my team members were already using delicious, where we agreed on a common tag that is only used by our team, and that works. But having the ability to comment, like, etc on the things you share, gives IMHO a much richer experience. Using FriendFeeds imaginary friends, we actually “source in” the stuff we tag on delicious into our private room for work. The only gotcha there is to not use the delicious sharing feature of FriendFeed, but rather the “blog” feature of FriendFeed, and set it up so that it reads the rss feed from your specific tag.

So, to come back to the original topic of this post, I am very excited to see whether enough people will join and participate on the the Agile 2008 FriendFeed room room, and that it will give me, someone who is not participating in agile 2008, enough information so that I at least get a serious idea of what I am missing.

**edit** If you happen to know existing agile 2008 related forums, mailing lists, groups, etc, please let me know about them, or better, spread the word about this FriendFeed group.

Interestingly, Ruby includes operators and some of them are implemented as methods, so-called operator methods. Let’s try some examples.

irb(main):001:0> 3 + 4 * 6
=> 27

That is what we expect. It shows that Ruby implements operator precedence. * has precedence over +.

* and + are implemented as operator methods. The pickaxe book states that: “If the operator in an operator expression corresponds to a redefinable method, Ruby will execute the operator expression expr1 operator expr2 as if it had been written (expr1).operator(expr2).” This means that the previous example can also be written as:

irb(main):002:0> 3.+(4).*(6)
=> 42

The result is what we expect. Messages are sent from left to right in an expression like this. The precedence rules do not apply when using the message passing form.

But according to the book, the two forms should yield the same result. They don’t.

Classes can implement operator methods as well, as shown in this example:

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

class Number
  def initialize(initialValue = 0)
    @value = initialValue
  end
  def  value
    @value
  end
  def +(other)
    self.class.new(self.value + other.value)
  end
  def *(other)
    self.class.new(self.value * other.value)
  end
end

Let’s try some expressions:

irb(main):003:0> (Number.new(3) + Number.new(4) * Number.new(6)).value
=> 27

This is consistent the precedence rules of the operators. When this expression is rewritten with messages, this is the result:

irb(main):004:0> Number.new(3).+(Number.new(4)).*(Number.new(6)).value
=> 42

Again, this shows that the precedence rules do not apply.

Although I expect that, consistent with other object-oriented languages, no precedence rules apply when messages are sent in sequence, Ruby states that using the operator form and the message passing form should be equivalent, but they clearly are not. That is very confusing and error-prone.

First, download the ruby tar ball:
wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p110.tar.gz
(note: be sure to check on the ruby site to get the latest stable sources, in the mean time, newer patchlevels might be available)

untar the tar ball:

tar -xvf ../ruby-1.8.6-p110.tar.gz

In your home folder, create a ruby directory to hold the installation:

mkdir ~/ruby

Change directory to the untarred directory. In that directory, run configure pointing to your local ruby directory:

./configure –prefix=/home/username/ruby

Then run:

make
make install

You now should have a ruby installation in /home/username/ruby.

In your home folder, edit your .bash_profile file and add the ruby bin folder to your path:

export PATH=”$HOME/ruby/bin:$PATH”

Source this file and run ruby -v

source ~/.bash_profile
ruby -v

SUCCESS:
ruby 1.8.6 (2007-09-23 patchlevel 110) [i686-linux]

Next, install ruby gem, the ruby package manager. Ruby gems can be found here

Get the latest version:

wget http://rubyforge.org/frs/download.php/28174/rubygems-0.9.5.tgz

untar:

tar -xvzf rubygems-0.9.5.tgz

cd rubygems-0.9.5

ruby setup.rb (note, be sure that you have your home backed ruby in your path!!)

Install rake:

gem install –remote rake

gem install fcgi

Do not forget to update the shebang in the dispatcher.fcgi file to the correct path

#!/home/username/ruby/bin/ruby

Then, install rails:

gem install rails

And you are rolling!!!

Note that in order to deploy in production mode, you need to uncomment the ENV[’RAILS_ENV’] ||= ‘production’ line in environment.rb.

Below the deployment recipe I used:


ssh_options[:paranoid] = false
set :user, 'user'
set :password, 'passwd'
set :application, "app"
set :repository, "http://url_to_svn_repository"
set :deploy_to, "/home/username/www.killerapp.com"

end


Thanks to Geoffrey Grosenbach for getting the inspiration for this recipe.

Hope this helps.

After some initial looking around on the web, I thought I’d give drupal a go. I was looking for an excuse to get to know some drupal basics anyway :)

In this post, I’ll describe how I’m setting up this site, especially the multilingual part. I’m still a complete drupal newby, so all suggestions are welcome.

So without further ado, this is what I did. I started with a fresh copy of drupal on the drupal site. I then installed and enabled the following modules:

• Internationalization
• CCK
• Views

In the drupal handbook for the internationalization project, I found an elaborate how-to on getting the whole internationalization thing to work. Key things I learned where:

• Menus: with the internationalization module, it is possible to have different menus for different languages. This is typically not what you want. You rather want one menu structure with text that changes if you switch languages. Therefor, use the “manage strings” functionality found in Administer -> Site Configuration -> Localization.
• The menu items should link to node_name, not to en/node. The internationalization module will rewrite the link to en/node_name at runtime when you have the language set to English.
• Nodes: Make sure to add a language to each individual node, this avoids an occasional piece of content in another language popping up.
• Enable the path module under the core-optional family of modules. You will need to change the default path of a node to e.g. en/node_name for an English page.
• Be sure to enable multilingual support for all content types you are using.
• Do not forget to add the language switcher block to your site ;)

All in all setting up these basic things went smooth, I do have a couple of remarks/questions:

• Is it possible to automatically set the correct path name e.g. en/node_name, rather then to have to do this manually for each individual node?
• How can I theme/style the language switcher so that I only have the little flags, not the language name?
• Are there other tips and tricks, obvious things or deeply hidden features I should be aware about?

All suggestions welcome, thanks in advance!

I learned a lot from this book. In particular I learned how to build a web page from the content out: first write the content and then do the styling. I did some exercises to apply that way of working and the results are astonishing.

I recommend this book to everybody who likes to improve his/her web design skills.

At the time of writing, almost 75% of the functionality is ready. I expect to release the PyUnit runner by the end of the month, as part of JyDT 1.5.0.

In Java and C++, the sematics of the “private” access modifier for a method is: the method can only be called by methods of the class that declares the private method.

In Ruby, the semantics is (taken from the pickaxe book, page 35): private methods can be called only in the context of the current object. A bit further in the book: The difference between “protected” and “private” is fairly subtle and is different in Ruby than in most common OO languages.

Indeed, the difference is subtle, certainly for C++ and Java developers learning Ruby. As the sematics above already indicate, C++ and Java have a class focus, while Ruby has an instance focus. Private in C++ and Java means: private to the class. In Ruby, it means: private to the instance.

There is another aspect of the semantics that is important. In C++ and Java, a private method can be called on a different instance than the one executing the current method. In Ruby, private methods can only be invoked on the same instance, which is enforced syntactically: private methods can only be invoked without a receiver or with self.

Because in Ruby private methods are private to an instance, they can be invoked by methods in a subclass, illustrated by the following code snippet:

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

class Superclass
    private
        def m1()
            puts "Superclass.m1"
        end
end
 
class Subclass < Superclass
    public
        def m2()
            m1()
            puts "Subclass.m2"
        end
end
 
Subclass.new().m2()

The output of the program is:

irb(main):017:0> Subclass.new().m2()
Superclass.m1
Subclass.m2
=> nil

Private methods can also be overridden, as shown in this code snippet:

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Superclass
    private
        def m()
            puts "Superclass.m"
        end
end
 
class Subclass < Superclass
    public
        def m()
            super()
            puts "Subclass.m"
        end
end
 
Subclass.new.m()

The output of the program is:

irb(main):017:0> Subclass.new.m()
Superclass.m
Subclass.m
=> nil

A singleton method can even override a private method of the class of the instance, as illustrated by this code snippet:

33
34
35
36
37
38
39
40
41
42
43
44
45

class MyClass
    private
        def m()
            puts "MyClass.m"
        end
end
 
object = MyClass.new()
def object.m()
    super()
    puts "object.m"
end
object.m()

The output of the program is:

irb(main):013:0> object.m()
MyClass.m
object.m
=> nil

The conclusion is that Ruby has no way to make methods private in the C++ and Java sense. In my opinion, that is a good thing, because private methods are bad for reusability. But I do not believe that using the word “private” was a good choice.

The final graph I wanted to have looks something like this:

• 38
• 29
• 36
• 28
• 34
• 27
• 32
• 26
• 30
• 25
• 28
• 24
• 26
• 23
• 24
• 22
• 22
• 21
• 20
• 20

(more…)