PPSN 2010 and Evolving Ants

For the next days I will be attending PPSN 2010, in Krakow, Poland. I was here for the venue two years ago and it was a conference that I enjoyed very much. Mostly because of the model which is different from the standard ones (poster only format, absence of parallel sessions and a summary presentation of the papers by a senior session chair).

I will be talking about my lastest work which ties together two techniques that I’ve always wanted to do some serious work with them: Ant Systems and Genetic Programming. In this first paper, I am using GP to evolve an Ant System component. A key issue in AS research is how to design the communication mechanism between ants that allows them to effectively solve a problem. We propose in this work to evolve the current pheromone trail update methods. We tested with the TSP and initial results show that the evolved strategies perform well and exhibit a good generalization capability when applied to larger instances.

Doing this work was also very fun and it was all made in Lisp. I just need to improve the code a bit and package it nicely before making it free available.

Anyway, I wish PPSN 2010 will be an interesting conference!


Original implementation of Javascript in CL

Thanks to a tweet from Tiago Charters de Azevedo, I learned today that Mozilla’s CVS tree still contains the original implementation of Javascript written in Common Lisp. I always found interesting to see examples of Lisp being used in places most people wouldn’t dream of (even if later it’s replaced by another language implementation).

The README states:

“js/semantics contains experimental code used to generate LR(1) and LALR(1) grammars for JavaScript as well as compile and check formal semantics for JavaScript.  The semantics can be executed directly or printed into either HTML or Microsoft Word RTF formats. This code is written in standard Common Lisp.  It’s been used under Macintosh Common Lisp 4.0, and Allegro Common Lisp 5.0.1 for Windows, but should also work under other Common Lisp implementations.”

Now I need to take a look at this code more carefully, just for the fun of it!

Going to Evo* in Istanbul

Although a bit late for this post but the year started with a good news: the paper I co-authored with Salma Mesmoudi was accepted at EvoBIO 2010. So, I am going to Istanbul to attend the Evo* set of conferences and workshops. This paper results from my final time at INRIA with Salma. We are still collaborating but due to my constant movements we weren’t able to finish it sooner. Let’s see if we can continue to work on some of possibilities that are open with this work.

And for the record, our paper is titled “Variable Genetic Operator Search for the Molecular Docking Problem”, and the abstract is:

The aim of this work is to present a new hybrid algorithm for the Molecular Docking problem: Variable Genetic Operator Search (VGOS). The proposed method combines an Evolutionary Algorithm with Variable Neighborhood Search. Experimental results show that the algorithm is able to achieve good results, in terms of energy optimization and RMSD values for several molecules when compared with previous approaches. In addition, when hybridized with the L-BFGS local search method it attains very competitive results.

[UPDATE]: Just received the news that the paper was nominated for the Best Paper Award!

Using Twitter

A long time ago I created a Twitter account and tried. Didn’t explore it much and it was left more or less abandoned. Some days ago, for no apparent reason, I’ve decided to give it a second try and use it as a source of information and a way, perhaps, to keep contact with some persons I know. So far so good! Anyway, you can follow me here for some quick texts.

Starting with Haskell


Around ten years ago I learned to program in Lisp, Common Lisp to be more precise. And since then I believe I never actually learned a new language that impressed me, and excited me, so much as was the experience of learning Lisp.

Well, yesterday I started to learn more seriously Haskell. For quite some time my interest in the language has been increasing. From several blogs posts, comments and discussions on the web, it is almost impossible not to be curious. Yes, I’ve heard of Haskell for a very long time but it seems the buzz on my ears raised a lot recently. And so, I’ve decided to take a look. In the worst case scenario, it would a be just a few hours of playing around with a new language.

Up until now, I didn’t do much. Installed the Haskell platform, haskell-mode in Emacs (although I ended up using Vim too to code) and searched for some basic tutorial. My starting choice is “Learn You a Haskell for Great Good!”. It looks nice. Seems suitable for a beginner and starts in a simple way. The first real chapter is the second one, which I just did yesterday. I was very impressed with it. And perhaps more important, very happy with the experience. To be honest, I don’t remember a similar feeling with other languages… except Lisp! Although this “Starting Out” chapter introduces just some very basic Haskell stuff, it is already a lot to feel the language and the potential of it. The last example was very cool. Suppose you want to find the right triangle that has integers equal or smaller than 10 for all sides and has a perimeter of 24. With tuples, list comprehensions it’s just a matter of writing:

[(a,b,c) | c <- [1..10], b <- [1..c], a <- [1..b], a^2 + b^2 == c^2, a + b + c == 24]

Simple, concise and very neat! I still didn’t do anything proper with Haskell. I am just in the very very very beginning but it looks promising. I could be wrong about it sure, but the feeling is nice.

Also, recently, I started to take a look at Clojure, another Lisp. I had some hopes that would be a very nice experience. Unfortunately, it was not. For some reason, I am unable to appreciate the “beauty” of a JVM language. But let’s see how Haskell will fare when I start to try it with the kind of stuff I’m interested in.