Equars People - All

Days of Autumn

2008-10-15T19:00:00Z

My favourite blog right now is The Boston Globe Big Picture.

Wireless Italian law

2008-10-08T10:36:00Z

I copy here the last update of our page about the laws regulating wireless networks in Italy, “Wireless: la normativa italiana” (italian only, sorry). Take this as an experiment to test the compliance amongst italian blogs (and company sites!) of the original text CC License.

Dal 2001 al luglio 2005
Il decreto Pisanu (27 luglio 2005)
Il decreto Landolfi (4 ottobre 2005)
Il decreto legge n. 248 (27 dicembre 2007)
La direttiva europea 2006/24/CE (15 marzo 2006)
Il decreto legislativo n. 109 (30 maggio 2008)
I limiti di potenza attuali

Normativa dal 2001 al luglio 2005

Fino al 2001 il riferimento legislativo per l’utilizzo di apparecchiature operanti nelle bande di frequenza [2,4 - 2,4835] GHz (comunemente detta banda a 2.4 GHz), [5,15 - 5,350] GHz e [5,47 - 5,725] GHz (comunemente dette bande a 5 GHz), utilizzate per la trasmissione wireless LAN, era dato dal DPR 447 del 5 Ottobre 2001. Il decreto stabiliva che tali frequenze potessero essere impiegate solo nell’ambito di LAN ad uso privato, mentre per connettere una WLAN alla rete pubblica occorreva un’autorizzazione generale del Ministero nonché il pagamento di un canone.

Decreto del Presidente della Repubblica n. 447 del 05 Ottobre 2001,
Regolamento recante disposizioni in materia di licenze individuali e di autorizzazioni generali per i servizi di telecomunicazioni ad uso privato
http://www.ipzs.it/Pubblicazioni_ministeri/ [ … ] /02_2002_3s.pdf

A partire dal gennaio 2002, il regolamento di attuazione dello stesso DPR 447 del 5 Ottobre 2001 consente l’utilizzo di dispositivi di WLAN che operano sulle bande di frequenza appositamente assegnate, senza più la necessità di richiedere alcuna concessione.
Il quadro regolamentare definitivo per l’utilizzo della tecnologia Wi-Fi in ambito pubblico è dato però dal cosiddetto decreto Gasparri del 28 Maggio 2003, che regola le condizioni per il rilascio delle autorizzazioni generali per la fornitura al pubblico dell’accesso Radio-LAN alle reti ed ai servizi di telecomunicazioni.

Decreto Gasparri 28 Maggio 2003,
Regolamentazione dei servizi Wi-fi ad uso pubblico
http://www.comunicazioni.it/ [ … ] / DM_2003_05_28.pdf

La delibera dell’Autorità per le Garanzie nelle Comunicazioni (num. 102/03/CONS) precisa che non è necessario disporre di licenza o autorizzazione per l’erogazione di servizi di connettività di rete nel caso l’attività commerciale non abbia come oggetto sociale principale l’attività di telecomunicazioni (es. bar, alberghi, centri commerciali)

Delibera n. 102/03/CONS,
Disposizioni regolamentari in materia di autorizzazioni generali
http://www.agcom.it/provv/d_102_03_CONS.htm

Il Decreto Pisanu (luglio 2005)

Con il decreto “Misure urgenti per il contrasto del terrorismo internazionale”, noto come decreto Pisanu, del 27 luglio 2005, (modificato con la legge 31 luglio 2005, n. 155) alcune delle norme citate precedentemente sono state variate. Le norme si applicano ai fornitori di una rete pubblica di comunicazioni o di un servizio di comunicazione elettronica accessibile al pubblico. In particolare:

L’articolo 6, comma 1, impone la non cancellazione di tutti i dati relativi al traffico telematico, escluso il contenuto delle comunicazione e limitatamente alle informazioni che consentono la tracciabilità degli accessi e dei servizi.
L’articolo 6, comma 3, modifica alcuni articoli del Decreto Legislativo 30 giugno 2003, n. 196 (“Codice in materia di protezione dei dati personali”) e stabilisce che i dati relativi alle telecomunicazioni telematiche devono essere essere conservati per sei mesi e poi per ulteriori sei mesi.
L’articolo 7 invalida la delibera dell’Autorità per le Garanzie nelle Comunicazioni (num. 102/03/CONS), indicando che è necessario richiedere un’autorizzazione al questore per chi mette a disposizione terminali telematici. L’autorizzazione va richiesta per chi ne fa attività prevalente o esclusiva, o per chi ha più di 3 terminali installati. Inoltre richiede la “preventiva acquisizione di dati anagrafici riportati su un documento di identità dei soggetti che utilizzano postazioni pubbliche non vigilate per comunicazioni telematiche ovvero punti di accesso ad Internet utilizzando tecnologia senza fili”.

Decreto Legge 27 luglio 2005, n.144,
Misure urgenti per il contrasto del terrorismo internazionale
http://www.comunicazioni.it/ [ … ] /DL_144_2005_07_27.pdf

Legge 31 luglio 2005, n. 155,
Conversione in legge, con modificazioni, del decreto-legge 27 luglio 2005, n. 144, recante misure urgenti per il contrasto del terrorismo internazionale
http://www.parlamento.it/leggi/05155l.htm

Il sucessivo decreto attuativo fissa in modo rigido le modalità di acquisizione dei dati anagrafici dei soggetti utilizzatori; in particolare vengono richieste:

l’acquisizione dei dati riportati su un documento di identità, ”nonché il tipo, il numero e la riproduzione del documento presentato dall’utente”;
la raccolta e l’archiviazione di tali dati ”con modalita’ informatiche” (l’archiviazione cartacea è possibile solo in presenza di non più di tre terminali);
la validità massima di 12 mesi, dall’ultima operazione di identificazione, per gli abbonamenti, forniti anche mediante credenziali di accesso prepagate o gratuite, nel caso che il fornitore renda disponibili apparecchi terminali collocati in aree non vigilate;
la conservazione dei dati stessi fino al 31 dicembre 2007;
lo stesso obbligo di identificazione imposto ai titolari o gestori di un esercizio pubblico o di un circolo privato che mettono a disposizione di clienti o soci apparecchi terminali, ai soggetti che offrono accesso alle reti telematiche utilizzando tecnologia senza fili in aree messe a disposizione del pubblico

Decreto del Ministero dell’Interno del 16 agosto 2005,
Misure di preventiva acquisizione di dati anagrafici dei soggetti che utilizzano postazioni pubbliche non vigilate per comunicazioni telematiche ovvero punti di accesso ad Internet utilizzando tecnologia senza fili […]
http://www.interno.it/ [ … ] /legislazione_650.html

Il Decreto Landolfi (ottobre 2005)

Il decreto del Ministero delle Comunicazioni liberalizza l’erogazione di servizi Wi-Fi nel territorio nazionale, modificando il precedente decreto Gasparri 28 Maggio 2003. In particolare:

L’articolo 1 liberalizza il servizio su tutto il territorio nazionale, eliminando l’obbligo di fornire il servizio in aree a frequentazione pubblica o locali aperti al pubblico.
L’articolo 2 obbliga i soggetti autorizzati a consentire l’accesso indipentemente dalla tecnologia utilizzati, favorendo di fatto gli accordi di roaming tra operatori diversi.
Inoltre questo articolo si introduce il cosiddetto “Diritto d’antenna”: l’installazione di apparati e antenne deve essere garantita a condizioni “eque, trasparenti e non discriminatorie”. Non ci potranno essere quindi installazioni di apparati in esclusiva per alcuni operatori.
L’articolo 3 indica in 60 giorni il termine della sperimentazione per i soggetti che stanno già fornendo un servizio in maniera sperimentale.
L’articolo 4, riprendendo il decreto legislativo 1 agosto 2003 n. 259, mantiene il regime di autorizzazione generale per i soggetti che vogliono fornire servizi radiolan. Tale autorizzazione è da richiedere alla Direzione generale per i servizi di comunicazione elettronica e radiodiffusione del Ministero delle Comunicazioni.

Decreto Landolfi 4 ottobre 2005,
Decreto sul Wi-Fi
http://www.comunicazioni.it/ [ … ] /Dec4oct05WIFI.htm

Il Decreto Legge n. 248 (dicembre 2007)

Il decreto legge n. 248, “Proroga di termini previsti da disposizioni legislative e disposizioni urgenti in materia finanziaria”, del 28 dicembre 2007, pubblicato sulla Gazzetta Ufficiale n. 302 del 31 dicembre 2007 (successivamente modificato dalla legge n. 31/08 del 27 febbraio 2008) modifica il decreto Pisanu del 27 luglio 2005, prorogandone i termini. In particolare:

L’articolo 34 modifica gli articoli 6 e 7 del citato decreto Pisanu, postponendo il termine per la conservazione dei dati alla data di approvazione della direttiva europea 2006/24/CE e comunque non oltre il 31 dicembre 2008; il termine per la richiesta della licenza al questore è posticipato al 31 dicembre 2008.

Decreto Legge n. 248 28 dicembre 2007,
Proroga di termini previsti da disposizioni legislative e disposizioni urgenti in materia finanziaria.
http://www.governo.it/Governo/Provvedimenti/dettaglio.asp?d=37921

Legge 27 febbraio 2008, n. 31,
Conversione in legge, con modificazioni, del decreto-legge 31 dicembre 2007, n. 248, recante proroga di termini previsti da disposizioni legislative e disposizioni urgenti in materia finanziaria
http://www.parlamento.it/parlam/leggi/08031l.htm

La Direttiva Europea 2006/24/CE (15 marzo 2006)

La direttiva europea 2006/24/CE, “riguardante la conservazione di dati generati o trattati nell’ambito di fornitura di servizi di comunicazione elettronica accessibili al pubblico o di reti pubbliche di comunicazione”, del 15 marzo 2006, pubblicato sulla Gazzetta Ufficiale dell’Unione Europea n. L 105/54 del 13 aprile 2006 chiarifica i dati oggetto del trattamento e i relativi termini di conservazione. In particolare:

L’articolo 5 indica quali sono i dati da conservare per l’accesso Internet, la posta elettronica via Internet e la telefonia via Internet, ovvero
- data e ora del log-in e del log-off del servizio di accesso Internet sulla base di un determinato fuso orario, unitamente all’indirizzo IP, dinamico o statico, assegnato dal fornitore di accesso Internet a una comunicazione e l’identificativo dell’abbonato o dell’utente registrato;
- data e ora del log-in e del log-off del servizio di posta elettronica su Internet o del servizio di telefonia via Internet sulla base di un determinato fuso orario.
L’articolo 6 indica che il periodo di conservazione dei dati non deve essere inferiore a 6 mesi e superiore a 2 anni.

Direttiva Europea 2006/24/CE 15 marzo 2006,
riguardante la conservazione di dati generati o trattati nell’ambito della fornitura di servizi di comunicazione elettronica accessibili al pubblico o di reti pubbliche di comunicazione.
http://eur-lex.europa.eu/LexUriServ/LexUriServ.do?uri=OJ:L:2006:105:0054:0063:IT:PDF

Il Decreto Legislativo n. 109 (30 maggio 2008)

Il decreto legislativo n. 109, “Attuazione della direttiva 2006/24/CE riguardante la conservazione dei dati generati o trattati nell’ambito della fornitura di servizi di comunicazione elettronica accessibili al pubblico o di reti pubbliche di comunicazione e che modifica la direttiva 2002/58/CE”, del 30 maggio 2008, pubblicato sulla Gazzetta Ufficiale n. 141 del 18 giugno 2008 attua la direttiva europea 2006/24/CE del 15 marzo 2006. In particolare:

L’articolo 2 modifica l’articolo 132 del “Codice in materia di protezione dei dati personali, prevedendo un periodo di 12 mesi per la conservazione dei dati di tipo telematico.
L’articolo 3 indica la categoria di dati da conservare. Per quanto riguarda i dati di traffico telematico, le categorie di dati sono:
- nome e indirizzo dell’abbonato o dell’utente registrato a cui è stato assegnato univocamente un indirizzo IP;
- indirizzo IP utilizzato e indirizzo di posta elettronica identificativi del mittente e indirizzo IP e nome a dominio pienamente qualificato del mail exchanger host, per l’invio della posta elettronica;
- indirizzo IP utilizzato, numero telefonico e dati anagrafici identificativi del mittente, nel caso di servizi di telefonia via Internet.

Decreto Legislativo n. 109 30 maggio 2008,
Attuazione della direttiva 2006/24/CE riguardante la conservazione dei dati generati o trattati nell’ambito della fornitura di servizi di comunicazione elettronica accessibili al pubblico o di reti pubbliche di comunicazione e che modifica la direttiva 2002/58/CE.
http://www.parlamento.it/leggi/deleghe/08109dl.htm

Decreto Legislativo n. 196 30 giugno 2003,
Codice in materia di protezione dei dati personali.
http://www.parlamento.it/leggi/deleghe/03196dl.htm

Lenovo Thinkpad Laptop Rocks.

2008-09-01T22:17:00Z

My previous laptop collapsed: in the last few days both the wireless interface and the touchpad stopped working. The disk showed a few bad blocks and the bios had some quirks, while the cdrom stopped working a few months ago. At the end, this laptop it was not worth the money I paid for it, for the overall quality was in the low/medium end, and the price was in the very high end. I don’t think I will ever buy again a Vaio laptop.

Now I’m the happy owner of a Lenovo T61; its quality is an order of magnitude better than the Vaio one. The keyboard has a very good feeling, and it’s by far the best laptop keyboard I’ve ever used. The construction is very solid, everything works with Gnu/Linux with little effort, and last but non least I’ve just paid for it now less € than I paid for the Vaio one year and a half ago. I recommend Lenovo if you want a business laptop.

Non-negative Matrix Factorization

2008-07-02T22:13:00Z

Here it is a small ruby script that calculate the non-negative matrix factorization of a given matrix. I tried to mantain the notation consistent with the one used in the paper of Lee and Seung

The script requires the GSL library.


#!/usr/bin/ruby


require("gsl")



def nmf(v, col, thresh)
   r, c = v.shape

   # w * h = v
   w = GSL::Matrix.alloc(r, col)
   h = GSL::Matrix.alloc(col, c)
   initrand(w, w.max)
   initrand(h, h.max)
   dist = thresh
   iter = 0
   while(dist >= thresh && iter < 1000)
      # multiplicative update rule
      dist, w, h = update(v, w, h)
      puts "#{iter}: #{dist}" #if (iter%10 == 0)
      iter += 1
   end   
   puts "Ended in #{iter} iteration(s) with dist=#{dist}"
   return w, h
end


def initrand(m, max)
   r, c = m.shape
   0.upto(r-1) { |i|
       0.upto(c-1) { |j|
          m[i,j] = rand(max)
       }
   }
end

def update(v, w, h)
   # choose an update rule
   # v, w, h are GSL::Matrix objects
   dist, w, h = update_eu(v, w, h)
   return dist, w, h
end

def update_eu(v, w, h)
   # multiplicative update rule
   # for minimizing euclidean distance
   # v, w, h are GSL::Matrix objects
   dist = dist_eu(v, w*h)
   wt = w.transpose
   ht =  h.transpose
   h = h.mul_elements(wt * v).div_elements(wt * w * h)
   w = w.mul_elements(v * ht).div_elements(w * h * ht)
   return dist, w, h
end


def update_kl(v, w, h)
   # multiplicative update rule
   # for minimizing divergence
   # v, w, h are GSL::Matrix objects
   dist = dist_kl(v, w*h)
   wt = w.transpose
   ht =  h.transpose
   num = v.div_elements(w * h)
   rh, ch = h.shape
   rw, cw = w.shape
   0.upto(rh-1) { |i|
       0.upto(ch-1) { |j|
          h[i, j] *= w.col(i).mul(num.col(j)).sum / w.col(i).sum
       }
   }
   0.upto(rw-1) { |i|
       0.upto(cw-1) { |j|
          w[i, j] *= h.row(j).mul(num.row(i)).sum / h.row(j).sum
       }
   }
   return dist, w, h
end



# Euclidean distance
def dist_eu(a, b)
   # a,b are GSL::Matrix objects
   dist = 0
   (a-b).collect { |d| dist += d * d}
   dist
end

# Kullback-Leibler divergence
def dist_kl(a, b)
   # a, b are GSL::Matrix objects
   dist = 0
   r, c = a.shape
   0.upto(r-1) { |i|
       0.upto(c-1) { |j|
          if (b[i,j] == 0) 
             puts "error"
             dist = 2**32
             break
          end
          dist += a[i,j] * Math::log(a[i,j]/b[i,j]) - a[i,j] + b[i,j]
       }
   }
   dist
end

Tanimoto Coefficient

2008-07-01T22:10:00Z

A small Ruby snippet to calculate the Tanimoto coefficient (aka extended Jaccard coefficient) of two real vectors.


#!/usr/bin/ruby

class Array 
   def sum
      inject( 0 ) { |sum,x| sum+x }
   end
   def sum_square
      inject( 0 ) { |sum,x| sum+x*x }
   end
   def *(other) # dot_product
      ret = []
      return nil if !other.is_a? Array || size != other.size
      self.each_with_index {|x, i| ret << x * other[i]}
      ret.sum
   end
end

def tanimoto(a, b)
   dot = (a * b)
   den = a.sum_square + b.sum_square - dot
   dot.to_f/den.to_f
end

# puts tanimoto([1,2,2],[3,3,1])

Pearson Correlation Coefficient

2008-06-30T22:13:00Z

A small Ruby snippet to calculate the Pearson produt-moment correlation coefficient:


#!/usr/bin/ruby

class Array 
   def sum
      inject( 0 ) { |sum,x| sum+x }
   end
   def sum_square
      inject( 0 ) { |sum,x| sum+x*x }
   end
   def mean
      sum / size
   end
   def *(other) # dot product
      ret = []
      return nil if !other.is_a? Array || size != other.size
      self.each_with_index {|x, i| ret << x * other[i]}
      ret.sum
   end
end


x = Array.new(100) {|i| i }
y = Array.new(100) {|i| -i*2 }


sumx = x.sum
sumy  = y.sum
num = (x.size * (x*y)) - (sumx * sumy)
den = Math.sqrt((x.size * x.sum_square) - sumx * sumx) * Math.sqrt((y.size * y.sum_square) - sumy * sumy)
r = num /den

puts "X= [#{x.join(', ')}]"
puts "Y= [#{y.join(', ')}]"
puts "r= #{r}"

ζ(s)

2008-06-18T21:56:00Z

Such a terse and strong abstract, and a really short paper, for an hypothesis that lasts unproved for a century. We shall see if the proof is correct.

Ruby Fiber Ring Benchmark

2008-05-22T15:51:00Z

I stole an exercise from the Erlang world: the ring benchmark

I used the exercise as a way to get acquainted with a new class in Ruby, Fiber (starting from the version 1.9). Fibers are a way to implement asymmetric coroutines in Ruby,

#!/usr/bin/ruby1.9

require 'fiber'
require 'benchmark'

class Ring
   attr_reader :id
   attr_accessor :attach 

   def initialize(id)
      @id = id
      @fiber = Fiber.new do
         pass_message
      end
   end

   def |(other)
      other.attach = self if !other.nil?
      other
   end

   def resume
      @fiber.resume
    end

   def pass_message
      while message = message_in
         message_out(message)      
      end
   end

   def message_in
      @attach.resume if !@attach.nil?
   end

   def message_out(message)
      Fiber.yield(message)
   end

end

class RingStart < Ring
   attr_accessor :message
   def initialize(n, m, message)
      @m = m
      @message = message
      super(n)
   end
   
   def pass_message 
      loop { message_out(@message) }
   end

end


def create_chain_r(i, chain)
   # recursive version
   return chain if i<=0
   r = chain.nil? ? Ring.new(i) :  chain | Ring.new(i)
   create_chain(i-1, r)
end

def create_chain(n, chain)
   # loop version
   # needed to avoid stack overflow for high n
   n.downto(0) {
      chain = chain | Ring.new(n)
   }
   chain
end



n=ARGV[0].to_i
m=ARGV[1].to_i
mess=:hello
tm  = Benchmark.measure {
   ringu = RingStart.new(0, m, mess)
   chain = create_chain(n, ringu)
   m.times { ringu.message = chain.resume }
}.format("%10.6r\n").gsub!(/\(|\)/, "")

puts "#{n}, #{m}, #{tm}"

The comparison with the equivalent Erlang program is of course unfair, for one of the Erlang specialty is the spawning of cooperative processes. Anyway, here are the results:

N	M	Execution Time
Ruby [ms]	Erlang [ms]
10	10	1	0
10	20	2	0
10	50	4	10
10	100	10	0
10	200	18	0
10	500	42	0
10	1000	82	10
100	10	15	0
100	20	23	10
100	50	60	0
100	100	99	10
100	200	186	20
100	500	433	50
100	1000	805	90
1000	10	320	10
1000	20	423	20
1000	50	809	60
1000	100	1479	130
1000	200	2803	250
1000	500	6914	600
1000	1000	15410	1190
10000	10	16168	190
10000	20	17491	320
10000	50	21348	710
10000	100	28314	1480
10000	200	41547	2860
10000	500	81166	7200
10000	1000	147570	14190

Erlang ring benchmark

2008-05-22T15:30:00Z

Trying to be a cool kid, I’ve recently spent some time playing with Erlang. So I’ve found in Joe Armstrong’s Programming Erlang the following exercise:

”Write a ring benchmark. Create N processes in a ring. Send a message round the ring M times so that a total of N * M messages get sent. Time how long this takes for different values of N and M.

Write a similar program in some other programming language you are familiar with. Compare the results. Write a blog, and publish the results on the Internet! ”

(Already a classic now …).

I dutifully complied: here’s my solution.

-module(ringu).
-export([start/2]).

% ----------------------------------------------------------------------

start(N, M) -> 
    Pid_0 = self(),
    statistics(runtime),
    statistics(wall_clock),
    Pid = spawn(fun() -> ringu(N, M, self(), Pid_0) end),
    Pid ! x,
    receive 
        _ -> true
    end,
    {_, TCPU} = statistics(runtime),
    {_, Time} = statistics(wall_clock),
    io:format("~nElapsed time: ~w ms~nCPU time:     ~w ms ~n" ,
          [Time, TCPU]).

% ----------------------------------------------------------------------

ringu(1, M, Pid_1, Pid_0) -> ringu_loop(M, Pid_1), Pid_0 ! itsover;
ringu(N, M, Pid_1, Pid_0) -> 
    ringu_loop(M, spawn(fun() -> ringu(N-1, M, Pid_1, Pid_0) end)).

ringu_loop(1, Pid) -> ringu_fwd_msg(Pid);   
ringu_loop(M, Pid) -> ringu_fwd_msg(Pid), ringu_loop(M-1, Pid).

ringu_fwd_msg(Pid) ->    
    receive 
        X -> Pid ! X %, io:format(".", [])
    end.

Benchmark results, and an (uneven :) ) comparison with an equivalent script in Ruby here.

Oil price

2008-05-21T22:13:00Z

I’d like to reiterate a past meme. This time I restrict the meme to one single prediction: please tell me wether you think the crude oil price will pass the 150$ per barrell in the very near future, and, if you think that of it’s only matter of weeks, dare to say the exact day. I venture myself to bespeak the 30th of June, 2008.

Carlo, Alx, what do you think?

Caching Mephisto with lighttpd and mod_magnet

2008-05-14T22:15:00Z

This blog uses Mephisto, a rails application, and Thin as backend webserver. The frontend webserver is Lighttpd.

While Mephisto has a good caching system, producing a static html file for every visited page, the file is still served via Thin, reducing the speed and the scalability of the system and introducing an unnecessary step.

Lighttpd is very good at serving static files, thus I searched a way to serve a file from the cache directory of Mephisto, if present; I found a hack using mod_magnet.

Hereafter I wrote the relevant snippets of configuration files and how to put every piece in the right position.

Note: the same procedure should apply if you use Mongrel instead of Thin, for the relevant point is to bypass the backend rails webserver and serve all files (whether they exist) from the Mephisto cache.

First I configure Lighttpd to proxy to Thin for the rails application. I assume Thin (or Mongrel) is listening on port 3000 on two hosts.

  HTTP[''host"] == "virtualhost.example.org" {
        magnet.attract-physical-path-to = ( "/var/www/cache_mephisto.lua" ) 
        proxy.balance = "hash"
        proxy.server  = ( "" => ( ( "host" => "10.0.0.1", "port" =>  3000 ),
                                ( "host" => "10.0.0.2", "port" =>  3000 ) ) )
  }

The magnet.attract-physical-path-to = ( "/var/www/cache_mephisto.lua" ) is the magic trick. cache_mephisto.lua is a script written in lua programming language. The whole script is:

  local dir =  "/path/to/mephisto/public/cache/" .. lighty.request["Host"]

  if ( lighty.env["request.uri"] == nil or lighty.env["request.uri"] == "/") then
    file = dir .. "/index.html"
  else
    file = dir .. lighty.env["request.uri"] ..  ".html"
  end

  if lighty.stat(file) then
  lighty.header["Content-Type"] = "text/html"
  lighty.content = { { filename = file } }
  return 200
  end

 return lighty.RESTART_REQUEST

Inside the script you should adapt the variable dir to your Mephisto installation path. I need to append the virtual host name lighty.request["Host"] to the directory, for I run a multisite Mephisto installation; if you use a single site mephisto installation, probably you need to remove this append.

Now for some benchmarks:

serving the file via Thin:

   Requests per second:    1.40 [#/sec] (mean)
   Time per request:       716.007 [ms] (mean)

serving the file from the cache

   Requests per second:    11.46 [#/sec] (mean)
   Time per request:       87.247 [ms] (mean)

Almost a tenfold improvement!

Future works: serve from the cache the image files.

US Economy

2008-04-20T20:06:00Z

A thoughtful article: why Us economy is collapsing

A really interesting movie: money as debt

Postgresql Graph

2008-03-13T11:19:00Z

I wrote a small tool, postgresqlgraph, to monitor and plot the statistics of a postgresql database, using rrdtool.

The tool is able to monitor every database created inside a postgresql installation.

The parameters plotted for each database in the graph are:

numbackends: number of backends:
xact_commit: transactions committed;
xact_rollback: transactions rolled back;
blks_read: blocks read from the disk;:
blks_hit: blocks hit in the cache;
tup_returned: tuples returned (only in postgresql 8.3)
tup_fetched: tuples fetched (only in postgresql 8.3)
tup_inserted: tuples inserted (only in postgresql 8.3)
tup_updated: tuples updated (only in postgresql 8.3)
tup_deleted: deleted (only in postgresql 8.3)

For each parameter the graph shows the maximum and average values, and plots the derivative (rate change).

The software is published under GPLv3 .

A demo is available here.

Please feel free to submit me bugs, critics, improvements, or tell me if you find the tool of any worthwhileness.

SNAFU

2007-11-27T16:00:00Z

I spent a frustrating week of problem solving (or at least trying to…) of obscure integration issues among different programs, like trying to get zabbix to talk with a jabber server (the solution was found in IPV6), reading unuseful logs to debug problems (what the hell do you mean with “connection failed”? To what?) , recompiling software with arcane options, rebooting servers with the swap space full (apache, what are you doing?), or trying to stop a server that continues to reboot itself at boot (Xen, please tell me why…), or fighting with buggy PHP frontend, and, last but not least, investigate why a monitoring software just stopped working.

So I come to wonder if it exists a software that “just works”. If you ever happen to read this rambling and know such a software, please, please tell me. In the meanwhile I coined a law:

Dela’s Law of software: there is no software that “just works”
Corollary to the Dela’s Law of software: if a software seems to “just work”, after some times it will stop to work for an obscure, unknown and very difficult to find reason.

Universal Turing Machine

2007-10-25T21:43:00Z

So, it seems that the simplest universal turing machine has been demonstrated.

The simplest universal turing machine (T. M.) is, well, the simplest: 2 states and 3 symbols (or colors, as they are called by Stephen Wolfram), since a 2-states 2-symbols T.M. can not be universal.

This particular machine has however a subtle issue, for it requires an infinite memory (or ”tape” in the original definition of Turing), not satisfying perfectly the definition of universality given by Davis and Minsky.

The answer to the issue is that the pattern of bits in the memory can be set up without an universal T.M., so the universality is independent from the encoding of the pattern. I wonder if a (2,3) universal T.M. can be built with finite memory.