Para la posteridad:

#!/usr/bin/python26                                                             
# kevent proc demo - luis peralta                                               
# http://www.ziritione.org                                                      
#                                                                               
# tested on python 2.6 % freebsd 7.2                                            

import sys
import select

if __name__ == '__main__':
    print sys.argv
    kq = select.kqueue()
    ke = select.kevent(int(sys.argv[1]),
                       select.KQ_FILTER_PROC,
                       select.KQ_EV_ADD|select.KQ_EV_ADD,
                       select.KQ_NOTE_FORK|select.KQ_NOTE_EXEC|select.KQ_NOTE_TRACK, select.KQ_NOTE_EXIT)
    events = kq.control([ke], 0, 0)
    while True:
        events = kq.control([], 1, 0)
        if len(events) > 0:
            for event in events:
                if event.fflags & select.KQ_NOTE_FORK:
                    print event.ident, "forked"
                if event.fflags & select.KQ_NOTE_EXEC:
                    print event.ident, "called exec"
                if event.fflags & select.KQ_NOTE_EXIT:
                    print event.ident, "exited"
                if event.fflags & select.KQ_NOTE_CHILD:
                    print event.ident, "is child, parent ", event.data

Se puede probar así: python2.6 kevent-test.py $$ &

Hace un tiempo conté cómo generar un hash FNV con Python, esta vez le ha tocado al PHP. En principio la traducción debería haber sido directa, salvo porque el cabroncete del PHP y las operaciones sobre bits con número de tamaño mayor a 32 bits no se llevan nada bien. Vamos, es que es básico. Así que solución apoyándonos en la librería GMP y su extensión para PHP.

function FNV1a32_hash($str) {
        $prime = "16777619";
        $h = "2166136261";
        $i = 0;
        $s = strlen($str);

        while ($i<$s) {
                $h = gmp_xor($h, ord($str[$i++]));
                $h = gmp_mul($h, $prime);
        }
        return dechex((float)gmp_strval(gmp_and($h, "0x00000000ffffffff")));
}

Camarada, dump y load son tus amigos:

$ svnadmin dump /ruta/repo/viejo > /tmp/repo.dump
$ svnadmin create /ruta/repo/nuevo
$ svnadmin load /ruta/repo/nuevo < /tmp/repo.dump

Después de ver esto, que es un programita para Mac que te saca un mosaico a partir de frames de un vídeo. Como bien dicen, utilidad tiene poca más que curiosear.

Así que yo me he hecho mi mini versión, thumbr, en shell script que hace lo mismo o algo parecido (la primera idea ha sido otra vez exponerlo como servicio web, pero te puede torrar la máquina si te despistas). Necesitaréis imagemagick y mplayer para que funcione.

#!/bin/bash
#
# thumber script by luis peralta - http://www.ziritione.org
# inspired by http://www.threewordtitle.com/thumber/
#
# needs: mplayer, imagemagick
if [ $# -lt 2 ]
then
  echo "usage: $0 video-file output-thumber-image"
  exit 1
fi  
TILE_SIZE=32
TMPDIR="/tmp/thumbr-$$"
mplayer -really-quiet -ao null -vo jpeg:quality=100:outdir=$TMPDIR -sstep 1 "$1"
N_FRAMES=`echo "sqrt($(ls -l $TMPDIR|wc -l))" |bc`
montage $TMPDIR/*jpg -mode Concatenate  -resize ${TILE_SIZE}x -tile ${N_FRAMES}x "$2"
rm -rf $TMPDIR

Y aquí tenéis una prueba del resultado con el vídeo que tenemos en la página principal de 11870.com. También podéis descargar el script sin necesidad del corta y pega. Para mejorarlo un poco: que el tamaño de los tiles se pueda especificar en la línea de comando (a 32 píxeles ahora a cascoporro), junto con el sstep del mplayer para especificar el salto entre frames (a 1 segundo ahora).

La supuesta ley, establecida por Jon Postel (uno de los gurús de los primeros estándares de internet), dice:

«Sé conservador en lo que haces, sé liberal al aceptar lo de otros»

Que ha sido refraseada, quizá para evitar demasiadas interpretaciones, muchas veces así:

«Sé conservador con lo que envías, sé liberal con lo que recibas»

Que quizá tiene un poco más de contexto de redes. Parece algo fácil de entender y con lo que no estar muy en desacuerdo. Pero es jodidamente difícil cumplirlo.

Estos días estoy parseando unos ficheros CSV que siguen una determinada especificación (si se la puede llamar así) para insertarlos en una base de datos relacional. Y, ahora que he acabado, la conclusión es que no ha sido nada fácil:

1. Definir los modelos de datos según la especificación: 4 horas
2. Hacer un programa que siga la especificación del formato: 6 horas
3. Resolver todo aquello no aclarado en la especificación y lidiar con los errores de los ficheros: 15 horas

Conclusión: he pasado más de la mitad del tiempo intentando que el parseo no cascase aunque el formato de entrada fuera incorrecto. Vamos, aplicar la ley de Postel cuesta un 150%.

Nota: el gustirrinín de ver cómo te lo comes todo sin cascar, no tiene precio ;)