I’ve planned to release a first version of this plugin as soon as it include some basic features, such as permalink navigation and pages support.

To simulate the light behavior I used a CSS3 gradient on the body background and a text-shadow property on the text. Both of these css3 attributes are then dynamically changed upon the user’s mouse move.

Here’s the snippet of the JQuery-flavored javascript I used:

$(document).ready(function() {
    $('body').mousemove(function(event) {
        $('#instructions').hide();

        // compute the center of the page and the distance between the center and the mouse
        // coordinates
        cx = Math.ceil($('body').width()  / 2);
        cy = Math.ceil($('body').height() / 2);
        dx = event.pageX - cx;
        dy = event.pageY - cy;

        // introducing a little parallax for the biggest light cone
        x0 = Math.ceil(cx - (dx * 0.2));
        y0 = Math.ceil(cy - (dy * 0.2));
        x1 = event.pageX;
        y1 = event.pageY;
        r0 = 300;
        r1 = 10;

        // another parallax for the text shadow
        sx = -dx * 0.03;
        sy = -dy * 0.03;

        // blur the shadow depending upon its distance
        b  =  (Math.abs(sx) + Math.abs(sy)) * 0.2;

        // simulate the light
        $('body').css('background-image', "-webkit-gradient(radial, " + x0 +" " + y0 +", "+ r0 +", "+ x1 +" "+ y1 +", "+ r1 +", from(#575757), to(#FFFFFF))");

        // simulate the shadow
        $('h1').css('text-shadow', "#444 "+ sx +"px "+ sy + "px " + b + "px");
    });
});

Here’s an image took from the demo, the whole page source code is available on my github account as a gist:

.

Here’s the simple snippet of code you can use (from a linux shell):

curl -u sandro.paganotti@gmail.com:my_password -d "vid=4762107" http://api.foursquare.com/v1/checkin

Foursquare api are really easy to use and lets you invoke up to 200 times each method each hour, so a quite simple exercise can be write a simple program that automatically check-in a selected account in a given array of locations:

require 'rubygems'
require 'restclient'
require 'nokogiri'

counter = -1
debug   = true

travel = [
            # minutes to wait, venue to check-in
            [5 ,4762107],
            [10,2335319]
         ]

RestClient.add_before_execution_proc do |req, params|
    req.basic_auth 'sandro.paganotti@gmail.com', 'my_password'
end

loop do
    time, venue_id = travel[counter = ((counter + 1) % travel.size)]
    puts "sleeping #{time} minutes.." if debug
    sleep time * 60
    response = RestClient.post "http://api.foursquare.com/v1/checkin", :vid=>venue_id
    puts  ['checkin','message'].inject(Nokogiri::XML(response.body)) { |s,r| s.send(:at, r) }.inner_text
end

By invoking this code an infinite loop will check-in the provided account into each of the given venues waiting a configurable amount of time between each of them.

Here’s the result:

sandropaganotti$ ruby venue.rb
sleeping 5 minutes..
OK! We've got you @ WC2010 Soccer City Stadium. This is your 2nd checkin here!
sleeping 10 minutes..
OK! We've got you @ Service Station Cafe. This is your 1st checkin here!
sleeping 5 minutes..

update 19/06/2010: my speakers showcase gets a dedicated post at euruko2010 official blog from Ela. Thanks guys !

Euruko 2010 is over. It was a great week-end spent among cool people having fun and talking about Ruby. As Matz said “we have a nice community”, and that’s absolutely true. To honor this conference (and to test some CSS3 features ^_^ ) I’ve developed a page showcasing the speakers and their talks. For each of them you may find a short summary and some resources (slide, etc..).

Working with CSS3 highlight some browser performances problem I was unaware before, for example I tried to have a scrolling background under a shadowed box, you can try this in your browser and notice how it is slow. However if we turn the shadows off the scrolling become smooth again (try this).

Ok, nothing left to say, hope you’ll enjoy the showcase:

So I tried to assign weights using the relation type as discriminator, to make an example take the word ‘sword’ and its relations:

related-term        relation type           assigned weight
weapon:             hypernym                5
backsword:          hyponym                 2
blade:              part_meronym            3
broadsword:         hyponym                 2
cavalry sword:      hyponym                 2
cutlas:             hyponym                 2
Excalibur:          instance_hyponym        2
falchion:           hyponym                 2
fencing sword:      hyponym                 2
foible:             part_meronym            3
forte:              part_meronym            3
haft:               part_meronym            3
hilt:               part_meronym            3
rapier:             hyponym                 2
point:              part_meronym            3

The weight I choose for each of the relation types tried to follow the statement
‘The more the words are related the less greater the number is’; so weapon is less
related to sword than broadsword because the first express a concept broader than sword
(also a nuclear bomb is a weapon); the second instead detail the word ‘sword’ and
make true the statement ‘A broadsword is always a sword’ so it’s more related to the
chosen word.

By following this general rule I associated a weight to each of the most common relation types and wrote down a few lines of code in order to compute weights by navigate the relation graph:

def compute_distances(weights = :default, max_depth_allowed = 6)

  # retrieve the list of the weights associated to each relation type
  # (its just an hash {:relation_type => weight})
  weights = CONFIG_FILE['distance']["#{weights}"]
  data = Words::Wordnet.new

  # get a list of sysnsets as a starting point (eg: red, crimson)
  synsets_to_analyze = self.synsets.map{|s| [s.synset_id,0,0]}
  synsets_to_store   = []

  # process the first element of the list
  # until the sysets_to_analyze stack is empty
  while(sys = synsets_to_analyze.shift) do
    sys_id,dis,dep = *sys; next if dep >= max_depth_allowed
    sys = Words::Synset.new(sys_id,data.wordnet_connection,nil) rescue next;

    # save the current sysnset words into an output array
    sys.words.each {|w|  synsets_to_store.unshift([sys_id,w,dis])}

    # put each of the sysnset related to this into the stack unless they
    # are already present
    sys.relations.each do |r|
      synsets_to_analyze.unshift(
        [r.destination.synset_id, dis + weights["#{r.relation_type}"],dep + 1]
      ) if r.is_semantic? and
           !synsets_to_store.find{|s| s.first == r.destination.synset_id}
    end
  end

  # now in sysnsets_to_store you have an array of the words each of them
  # with the weight that separe it from the starting synsets.
 # (now I store them on a db, but is just because the context is the same as the Abacus gem)
  synsets_to_store.each do |s|
    a_id = ArticleKey.find_by_the_key(s[1]).id rescue next
    self.distances.find_or_create_by_article_key_id( a_id, :distance => s[2])
  end

end

Here some of the results for ‘sword’ with depth = 3:

sword:                           0
brand:                           0
steel:                           0
broadsword:                      2
rapier:                          2
tuck:                            2
backsword:                       2
fencing sword:                   2
falchion:                        2
Excalibur:                       2
cutlas:                          2
sabre:                           2
cavalry sword:                   2
saber:                           2
cutlass:                         2
foible:                          3
blade:                           3
hilt:                            3
forte:                           3
tip:                             3
peak:                            3
point:                           3
helve:                           3
haft:                            3
claymore:                        4
scimitar:                        4
saber:                           4
sabre:                           4
foil:                            4
epee:                            4
arm:                             5
basket hilt:                     5
head:                            5
weapon system:                   5
knife blade:                     5
weapon:                          5
widow's peak:                    5
cusp:                            5
razorblade:                      5
cutting edge:                    6
pommel:                          6
knob:                            6
knife edge:                      6
fire ship:                       7
shaft:                           7
slasher:                         7
missile:                         7
Greek fire:                      7
missile:                         7
weapon of mass destruction:      7
light arm:                       7
WMD:                             7
gun:                             7
flamethrower:                    7
pike:                            7
brass knucks:                    7
knucks:                          7
brass knuckles:                  7
knuckles:                        7
W:                               7
tomahawk:                        7
hatchet:                         7
lance:                           7
knuckle duster:                  7
bow and arrow:                   7
projectile:                      7
sling:                           7
bow:                             7
stun baton:                      7
spear:                           7
stun gun:                        7
convexity:                       8
cutting implement:               8
convex shape:                    8
portion:                         8
part:                            8
handle:                          8
grip:                            8
hold:                            8
handgrip:                        8
reap hook:                       9
knife:                           9
sticker:                         9
dagger:                          9
axe:                             9
file:                            9
awl:                             9
lawn mower:                      9
mower:                           9
scissors:                        9
ax:                              9
sickle:                          9
cone shape:                      9
conoid:                          9
cone:                            9
reaping hook:                    9
pencil:                          9
arrowhead:                       9
knife:                           9
pair of scissors:                9
spatula:                         9
spatula:                         9
alpenstock:                      9
instrument:                      10
weapons system:                  11
implements of war:               11
arms:                            11
munition:                        11
weaponry:                        11

Now, as you may notice, there still a lot of tuning to do; for example it is pretty strange that ‘weapon of mass destruction’ is more semantically related to ‘sword’ than ‘dagger’ .

Anyway I’m pretty pleased of the results of this small experiment thus I’m still far from my initial idea: calculate the weight of each word of the dictionary in relation to ‘good’ and ‘bad’ and use these weights to estimate the ‘mood’ of some common trends in twitter.

In the following snippet the two versions (classic and analogic) are compared:

//  Classic version:
  void compute(){
    int black_neighbours = 0;
    for(int z=0; z < neighbours.length; z++)
      if(neighbours[z].rgb == black)
        black_neighbours ++;  

    switch(black_neighbours){
      case 0:
      case 1:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        to_color(white);
        break;
      case 2:
        to_color(rgb);
        break;
      case 3:
        to_color(black);
        break;
    }
  } 

// Analogic version
  void compute(){
    int[] medium_color = new int[] {0,0,0};
    for(int z=0; z < neighbours.length; z++)
      for(int c=0; c < 3; c++)
        medium_color[c] = medium_color[c] + neighbours[z].rgb[c];

    int medium_tone = 0;
    for(int c=0; c < 3; c++){
      medium_color[c] = medium_color[c] / neighbours.length;
      medium_tone = medium_tone + medium_color[c];
    }  

    medium_tone = medium_tone / 3;

    if (medium_tone > 191 || medium_tone < 128 ){
      to_color(white);
    }else if(medium_tone > 159 ){
      to_color(rgb);
    }else{
      to_color(black);
    }
  }

Next I went a step further using ‘medium color’ when the classic rules asked insted to keep the previous cell color. This lead to a general acceleration to white because the medium neighbours color is always more bright than pure black, to balance this behavior I expanded the range of medium_tones which results in black. Here’s the tuned code:

  void compute(){
    int[] medium_color = new int[] {0,0,0};
    for(int z=0; z < neighbours.length; z++)
      for(int c=0; c < 3; c++)
        medium_color[c] = medium_color[c] + neighbours[z].rgb[c];

    int medium_tone = 0;
    for(int c=0; c < 3; c++){
      medium_color[c] = medium_color[c] / neighbours.length;
      medium_tone = medium_tone + medium_color[c];
    }  

    medium_tone = medium_tone / 3;

    if (medium_tone > 191 || medium_tone < 80 ){
      to_color(white);
    }else if(medium_tone > 159 ){
      to_color(medium_color);
    }else{
      to_color(black);
    }
  }

Now a short video of this new behavior:

Here’s the rules:

• if the organism has more than 3 or fewer than 2 neighbours it dies;
• if the organism has 2 or 3 neighbours it survives;
• if a white cell in the matrix is sorrounded by exactly 3 neighbours it became a living organism.

I’ve implemented this Game Of Life using Processing language and trying to push all of the game logic within the organism class in order to really simulate a cellular behavior, here’s the class:

class Spot{
  int[]   rgb, rgb_next;
  int     x,y;
  Spot[]  neighbours;

  Spot(int gx, int gy, int[] c){
    rgb      = c;
    rgb_next = new int[3];
    x       = gx;
    y       = gy;
  }

  void set_neighbors(Spot[][] grid){
    int xp = (x+1 == grid.length ? 0 : x+1);
    int xm = (x-1 == -1 ? grid.length - 1 : x-1);
    int yp = (y+1 == grid[0].length ? 0 : y+1);
    int ym = (y-1 == -1 ? grid[0].length - 1 : y-1);

    neighbours = new Spot[] {  grid[xm][ym], grid[xm][y ], grid[xm][yp],
                               grid[x ][ym],               grid[x ][yp],
                               grid[xp][ym], grid[xp][y ], grid[xp][yp]
                            };
  }

  void compute(){
    int black_neighbours = 0;
    for(int z=0; z < neighbours.length; z++)
      if(neighbours[z].rgb == black)
        black_neighbours ++;  

    switch(black_neighbours){
      case 0:
      case 1:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        to_color(white);
        break;
      case 2:
        to_color(rgb);
        break;
      case 3:
        to_color(black);
        break;
    }
  } 

  void advance(){
    rgb = rgb_next;
    rgb_next = new int[3];
  }

  void draw(int bw,int bh){
     fill(rgb[0],rgb[1],rgb[2]);
     rect(x*bw,y*bh,bw,bh);
  }

  void to_color(int[] c){ rgb_next = c; }
}

There are three methods that worth a look:

• set_neighbors:
  which determinates the sourronding neighbors (as the method name states) by creating an array of pointer to the closest organisms using the matrix passed as parameter as a reference. The first four lines are needed in order to eliminate the boundaries by linking each edge of the matrix to the opposite one.
• compute:
  which implements the real logic of the Game, it is divided into two steps, the first part calculates the number of alive neighbors sorrounding the organism and the second one applies the rules stated above.
• advance:
  due the fact that all of the organisms need to be processed before each of them can switch to the new state, the Spot class record the result of the ‘compute’ method inside a different variable and then, when advance is invoked, it moves this result to the ‘live’ variable.

Here’s a short video of my script in action, the source code is, as usually, available on my github account:

Il capitolo numero 11 tratta di mnemotecnica, la disciplina che studia il modo di memorizzare lunghe sequenze di numeri, e tratta del metodo di Pierre Hérigone, che può essere riassunto nel seguente modo:

1. Associa le cifre del numero che vuoi memorizzare a delle consonanti secondo una tabella nota; ad esempio la temperatura di ebollizione del mercurio, 357°C, diverrebbe mlk;
2. Trova una parola che contenga quelle consonanti in quell’ordine (senza altre ‘consonanti di disturbo in mezzo’); ad esempio per mlk andrebbe benissimo milk, mentre non andrebbe bene multik;
3. Associa la parola appena trovata ad una frase che in qualche modo leghi con il significato originario della cifra, possibilmente in modo che la frase risultante contenga uno stimolo visuale; ad esempio si può immaginare un allevatore stupito dal fatto che le sue mucche producano mercurio invece che latte.
4. Se la cifra dovesse essere molto lunga utilizza una sequenza di più parole seguendo lo schema appena descritto.

Nel tempo libero stò cercando di trasporre questi quattro semplici passaggi all’interno di una gemma: abacus, della quale ho rilasciato giusto oggi la versione 0.0.1; vediamo come si usa:

>> require 'abacus'
=> true
>> include Abacus
=> Object
>> number = HerigoneNumber.find_by_number(357)
=> #<Abacus::HerigoneNumber id: 19081, system: "default", number: 357>
>> number.article_keys.map{|article_key| article_key.the_key}
=> ["hemlock", "milk", "milky"]

Per poter funzionare Abacus utilizza un database sqllite che crea all’interno della cartella home dell’utente (il percorso in realtà è configurabile, ma per questi dettagli vi rimando alle note di installazione su github) e nel quale struttura il/i dizionari di riferimento.

Abacus implementa un parser (molto base ad oggi) XDXF, un formato open per la memorizzazione di dizionari: esistono già parecchie opere convertite più o meno bene in questo formato che possono essere scaricate gratuitamente, io ad esempio ho utilizzato questo dizionario base di inglese:

# da shell:
sudo gem install abacus
wget http://downloads.sourceforge.net/xdxf/comn_sdict05_eng_eng_main.tar.bz2
tar -xjvf comn_sdict05_eng_eng_main.tar.bz2
abacus db:create
abacus db:xdxf:import  eng_eng_main/dict.xdxf
abacus db:herigone:generate

La sfida più interessante di questo piccolo progetto è stata mantenere delle performances adeguate durante la sessione di traduzione numero -> parola, per fare questo in fase di import (con il comando db:herigone:generate) la gemma traduce ogni lemma del dizionario nel suo corrispettivo numerico rendendo la fase di ricerca una semplice SELECT su di un campo indicizzato.

In futuro vorrei estendere questo piccolo progetto aggiungendo due funzionalità di aggregazione semantica: in caso di sequenze di cifre lunghe mi piacerebbe infatti includere un generatore di linguaggio naturale con l’obiettivo creare una frase che almento nell’apparenza manifesti una certa correttezza (sarebbe bellissimo tradurre le prima 1000 cifre del PI in uno strampalato poema no?). Sarebbe inoltre interessante utilizzare wordnet per ridurre la variabilità semantica delle singole parole trovate a quanto di più vicino ad una parola che serva da ‘rappresentante logico’ per la cifra in ingresso (ad esempio per 357 il rappresentante logico sarebbe ‘mercurio’).

Nel frattempo, per chiunque fosse interessato, i sorgenti della gemma sono disponibili sul mio account di GitHub.