I did some initial experiments with programming for Google Wave. Basically I got the code from the tutorial and created a robot (called Dalek) which automatically translates the entered text (so called blips) from English to Spanish using the Java version of the Google Translate API. Screenshot of the result:

My first wave

Overall impression so far: very easy to use API. Google Wave itself can be terribly slow. Sometimes the syncing of ‘unsynced waves’ takes more than a minute. Next step: thinking of a more serious application.

And for those interested, the actual Java code:

package dalek;

import com.google.api.detect.Detect;
import com.google.api.translate.Language;
import com.google.api.translate.Translate;
import com.google.wave.api.AbstractRobotServlet;
import com.google.wave.api.Blip;
import com.google.wave.api.Event;
import com.google.wave.api.EventType;
import com.google.wave.api.RobotMessageBundle;
import com.google.wave.api.TextView;
import com.google.wave.api.Wavelet;

public class DalekServlet extends AbstractRobotServlet {

   @Override
   public void processEvents(RobotMessageBundle bundle) {
      Wavelet wavelet = bundle.getWavelet();

      if (bundle.wasSelfAdded()) {
         addText(wavelet, "We are the Daleks");
      }

      for (Event e : bundle.getEvents()) {
         if (e.getType() == EventType.WAVELET_PARTICIPANTS_CHANGED) {
            addText(wavelet, "Exterminate... exterminate... exterminate");
         } else if (e.getType() == EventType.BLIP_SUBMITTED) {
            addTranslation(e.getBlip());
         }
      }
   }

   private void addTranslation(Blip blip) {
      if (!blip.getCreator().equals("mjbvrijk@appspot.com")) {
         String originalText = blip.getDocument().getText();
         try {
            Detect.setHttpReferrer("maurits.wordpress.com");

            String translatedText = Translate.execute(originalText, Language.AUTO_DETECT, Language.SPANISH);
            createChildBlip(blip, translatedText);
         } catch (Exception e) {
            createChildBlip(blip, "Translation failed");
         }
      }
   }

   private void createChildBlip(Blip blip, String s) {
      addTextToBlip(blip.createChild(), s);
   }

   private void addText(Wavelet wavelet, String s) {
      addTextToBlip(wavelet.appendBlip(), s);
   }

   private void addTextToBlip(Blip blip, String s) {
      TextView textView = blip.getDocument();
      textView.append(s);
   }
}

I started using Twitter last week. My interest was triggered by a very cool workshop on programming in Scala that was given at the company I work for. Twitter has a nice API which is very easy to use from Scala or any other programming language. I still try to figure out what the business case could be for using Twitter, but for the moment it’s quite fun to do a few daily updates on what keeps me busy and/or interested.

My Twitter ID is @mauritsrijk (direct link). I probably am going to use it to give more frequent updates on my GIMP# activities.

I intend to buy an Android phone. It’s probably going to be the HTC Hero mainly because it’s almost available where I live and it also comes without a simlock, unlike for example the HTC Magic which is exclusive for Vodafone. Next I plan to develop some übercool applications but in the meantime I’ll start with porting a very old game I did more than a decade ago: it was called Groundhog. A screenshot:

Groundhog screenshot

So stay tuned for a Groundhog coming to your mobile…

In 25 years of programming I blogged about the lines of code I have written in several programming languages. I am experimenting with the Google Chart API and created a graphical overview of my personal top 7. Result:

The url to generate the pie chart:

http://chart.apis.google.com/chart?cht=p3&chtt=Top+7&chts=0000ff,32&chd=t:100,70,20,20,5,5,2,3&chs=650x250&chl=C%20(100000)|C%23%20(70000)|Java%20(20000)|C%2B%2B%20(20000)|Pascal%20(5000)|PV~Wave%20(5000)|Basic%20(2000)|Other%20(3400)|

The next bar chart shows all the other languages in which I programmed less than 1000 lines.

The url to generate the bar chart:

http://chart.apis.google.com/chart?cht=bhs&chtt=Other+languages&chts=0000ff,32&chs=350x300&chxt=x,r&chxl=0:|0|1000|1:|Lisp/Scheme|Assembly|Fortran|Perl|Python|Boo|Nemerle|F%23|Ruby&chd=t:1,2,2,2,2,10,20,100,100

I have been reading a lot over the last couple of months. Great books like “The World is Flat 3.0″, “Dreaming in Code”, “My Job went to India”, “The five dysfunctions of a team”, “Clean Code” and quite a few more. However I started to realize that although reading is fun, it tends to keep me in my comfort zone. I should really practice writing. People remember great writers. You hardly ever hear people saying “he was such a great reader” about a person that died hundred years ago.

So I just put down here what I’m doing at the moment. Lately I started to automate some things like writing progress reports for customers. Now please don’t stop reading at the word “progress report”. It might become a bit more interesting than you would expect. Part of my progress report consists of all kinds of metrics about a project: budgets, quality, schedule, etc. These metrics are collected from several systems and JIRA is one of them. Until recently I copied and pasted all this data into OpenOffice, did some magical calculations with a spreadsheet, and finally generated a few graphs which I used in the progress reports. So far the boring part.

However, JIRA also has a very nice RPC plugin which can be used to invoke JIRA operations remotely. And that’s exactly what I’m playing with at the moment. I’m using jira4r as a Ruby client library to automate all my tedious copy and paste actions. First experiments are succesful: with just a couple of lines (3 lines of code to be exact) of Ruby code I’m able to get a listing of all projects registered in a certain JIRA instance. Next step is to find a good library to generate graphs. Oh, and some actual code:

require 'rubygems'
require 'jira4r/jira_tool'

# Replace next url, username and password according to your own JIRA setup
jira = Jira4R::JiraTool.new(2, "http://jira.atlassian.com")
jira.login("soaptester", "soaptester")

# Dump all project descriptions
jira.getProjects.each { |project| puts project.description}

I slowly picked up GIMP# development again. To get my brain in the right mode I added a plug-in in yet another .NET language: Oxygene which is a kind of Object Pascal. From what I’ve seen it is a pretty decent language although I never understood why people would like to type 10 characters (“begin;” and “end;”) instead of 2 curly braces just to open and close a block

For those interested: currently I run Mandriva 2009 with VirtualBox 2.0.2 on my loyal MacBook Pro for development. The fancy IDE I use is called Emacs.

IronRuby and the Fan Programming Language will probably be my next targets.

I started programming in 1983 on a Sharp PC-1251 with an amazing 3486 bytes RAM. It had a Basic interpreter and we had to use it for a Calculus course at the university.

So that’s 25 years ago. That made me suddenly wonder how much code in different programming languages I have written in all those years. A completely useless question of course, but fun nevertheless. I don’t have all the code available anymore so I have to estimate some numbers from memory. The numbers I present include comment and blank lines.

The list:

1. C: 100.000
2. C#: 70.000
3. Java: 20.000
4. C++: 20.000
5. Pascal: 5.000
6. PV~Wave: 5.000
7. Basic: 2.000
8. Matlab: 1.000
9. Lisp/Scheme: 1.000
10. Assembly: 1.000
11. Fortran: 200
12. Perl: 100
13. Python: 20
14. Boo: 20
15. Nemerle: 20
16. F#: 20
17. Ruby: 10

This totals 225k lines of code in 25 years.In other words, about 10k LOC’s per year, or 30 lines per day. Other interesting questions that could be asked:

• how much of this code is still in use
• how much of this code is forever lost
• how much of this code is still archived somewhere on a company network
• how much code would this have been if it all had been written using language xyz
• how many bugs did I introduce over the last 25 years

A new release of GIMP# is available. New in release 0.14 are:

• Nemerle sample added
• Boo sample added
• Visual Basic sample added (I know.. don’t ask )
• F# sample added
• Ported abandoned Sky plug-in (part of PhyModMedia plug-ins)
• GIMP# now uses C# 3.0 features for cleaner code

Have fun.

I almost got my first F# plug-in running on GIMP#. It took me some time to get used to the syntax even with a background in functional languages like Lisp and Scheme. Only thing left to figure out is how I can override a C# function that returns an IEnumerable. What I’ve got sofar is:

override x.ListProcedures() : seq<Procedure> =
let procedure = new Procedure()
procedure.MenuPath <- “<Image>/Filters/Generic”
// And now what?

The C# signature of this routine is

protected abstract IEnumerable<Procedure> ListProcedures() ;

Hope to find an answer pretty soon.

Update 3 December 2007: seems that returning an IEnumerable is quite easy (many thanks to Robert Pickering):

[procedure] :> seq<Procedure>

After Boo comes bah. I’m probably going to burn in hell forever for having done this, but I actually created a Visual Basic plug-in for GIMP. The code is currently in CVS at the GIMP# Sourceforge page. Don’t look at the code unless you have a very strong stomach. Promise to myself: I will never ever create Basic code again. On a more serious note: the performance of the Visual Basic plug-in is comparable to the C#, Boo and Nemerle version!