Some time ago. Mamiya Press Super 23 + Sekor 90/3.5 + 6x9 back + Fuji PRO 160 long expired.

I tried to make the least modifications as possible to the original source, so that the change can be made with a patch, if the original author considers it (this is also why I didn't change the name of the mode either.) You can download it, and read instructions of installation and usage here:

deft-multidir on GitHub

As always, feedback is highly appreciated.

At first I thought that it would be nice to write the posts using Lisp alone. Using some HTML-generating library it would be easy to write posts like I write Lisp. However, posts have much more text than markup, and within lisp (unless you write some reader macro, that I may explore in the future), you have to add all those quotes, backquoting to eliminate special characters, etc. Posts look like this:

(fmb-new-post
 "Let Over Lambda--50 years of Lisp"
 :body (__ (h:p  "Hoy por casualidad he encontrado esta referencia, "
               (h:a '((href . "http://letoverlambda.com/index.cl/guest/chap2.html"))
                  "Let Over Lambda, Closures") " de Doug Hoyte. Es
                  curioso que sin haberlo leído antes, la solución que
                  he dado al problema de extraer la descripción de una
                  entrada del blog sin " (h:em "tags") " HTML ha sido
                  así usando un " (h:em "closure") "."))
 :categories '(español spanish programming lisp common-lisp blog)
 :hours 23
 :minutes 06
 :day 9
 :month 'october
 :year 2011)

I was happy because I could practice Lisp any time I wrote a post. However, this is not very comfortable, and when I had to include code snippets things got worse.

At the same time, I got impressed by the work of Reg Braithwaite with his blog Homoiconic. Thanks to the formatting capabilities of GitHub, he can write just Markdown files, and, with a directory structure that resembles years and months, he can write his blog. The name is representative, also, as it is the characteristic of programming languages that can treat code as data and vice versa (such as Lisp). However, I find much more interesting org-mode than Markdown, so I decided I wanted to do something similar.

Being written in Common Lisp, I had no library or implementation of the complete org-mode, so I decided, also to test other lisps, to use Emacs-Lisp and to use the characteristics of org-mode directly to produce the HTML that goes into posts, and even to support its tangling feature (more on that later). Also, it allowed me to have a directory in which all the posts live, and be able to browse them just using GitHub (where this blog now lives), as now GitHub also renders org-mode content (not quite correctly, but acceptably.)

The code that generates the HTML from the org-mode files is the following. It uses a function to obtain all the .org files, and with them, obtains the file properties, title, date, and categories, and generates the HTML with org-export-region-as-html:

(defun fmb-import-org-posts ()
  "Import all posts written in .org files.
Search all .org files, create a buffer for each of them,
extract all the initial properties (export properties), and then generate
the HTML equivalent of the body. Add it to the list of actual posts, that
will be ordered by date finally."
  (dolist (f (fmb-files-in-below-directory "content/posts"))
    (with-current-buffer (find-file-noselect f)
      (let* ((file-properties (org-infile-export-plist))
             (title (plist-get file-properties :title))
             (date (plist-get file-properties :date))
             (categories (plist-get file-properties :keywords))
             (body-as-html (org-export-region-as-html
                            (point-min)
                            (point-max)
                            t 'string)))
        (multiple-value-bind (secs mins hours day month year)
            (org-parse-time-string date)
          (fmb-new-post title
                        :day day
                        :month month
                        :year year
                        :hours hours
                        :minutes mins
                        :categories (mapcar #'(lambda (s) (intern s))
                                            (split-string categories nil t))
                        :body body-as-html))
      (kill-buffer)))))

Categories are extracted from the #+KEYWORDS option. For example, the few initial lines of this post:

#+TITLE:     Using org-mode to create posts
#+AUTHOR:    Diego Sevilla
#+EMAIL:     dsevilla@ditec.um.es
#+DATE:      2012-03-11 dom
#+DESCRIPTION:
#+KEYWORDS:  general org-mode emacs english
#+LANGUAGE:  en

Some time ago I decided to change my Common-Lisp based blog generator
to an Emacs-based one. And it was to learn Emacs-Lisp (compared

Finally, as the great site nakkaya.com, I can offer, through org-babel-tangle, the generation of the files shown in the entry. See, for example, this entry about the Ferret compiler. This open the world of Literate Programming also to this blog. All in all, a winning configuration.

It is REALLY amazing how fast she learns. At her age, she uses almost all Spanish constructions well, verbs (including irregular ones), nouns, slang expressions, tenses, etc. I used the Harinezumi 2++ for this. It is not very good in interiors, but in B&W gives a nice vintage feeling. For those of you not knowing Spanish, at the end of the video she says something like `Wait for me, I'll be right back'... :)

(define-skeleton add-new-post
  "Add a new post with the current date and time. Ask for the post title."
  "Post title: "
  "(new-post" \n
  > "\"" str "\"" \n
  > ":body \"" _  "\"" \n
  > ":categories '('general)" \n
  > ":body-format 'string" \n
  > (format-time-string
     ":hours %H :minutes %M :day %e :month %m :year %Y)"
     (current-time)) \n )

La función new-post me permite añadir una entrada al blog. Es código Common Lisp, por lo que se ve que comienza por un parémtesis. El patrón (definido por el macro de Emacs-Lisp define-skeleton después me pregunta por el título de la entrada (el uso de la variable str hace que me pregunte a la hora de insertar el patrón). Después, añade el cuerpo vacío y también la fecha actual de la entrada obtenida de la función de Emacs-Lisp (current-time). Finalmente, el carácter _ indica la posición en la que queda el cursor, con lo que puedo empezar a escribir el cuerpo de la entrada.

¡Incluso soporta varios párrafos!

El código para hacerlo en Emacs-lisp es el siguiente:

(defun org-to-html ()
  (interactive)
  (when (mark)
    (save-excursion
      (let ((text (buffer-substring-no-properties (point) (mark))))
        (delete-region (point) (mark))
        (insert
         (with-temp-buffer
           (insert text)
           (org-export-region-as-html (point-min) (point-max) t 'string)))))))

Lo que hago pues es seleccionar el texto que escribo en formato org y llamar a esa función org-to-html, que me transforma el texto seleccionado en HTML, incluso el trozo de código anterior, con coloreado de sintaxis que no necesita del embellecedor de código JavaScript de la página…

Just to show a little Emacs-Lisp script I wrote the other day. We're in the process of translating all our class material into English, and thought of getting some help from Google Translator. Selecting a phrase and calling the insert-translation function substitutes current text with its traduction into English. You know, Google Translate fails a fair bit, but it helps, and you don't have to write all the slides again...

Pero es que además la actualización no va bien. Siempre quedan flecos sueltos. En algunos la barra izquierda no sale cuando acercas el ratón. No hay manera de configurar cómo aparece esa barra, a no ser que te vuelvas loco y busques por Internet y te des cuenta de que tienes que instalar el paquete compizconfig-settings-manager, y ahí tienes una pestaña "Unity" que sirve para configurar también la barra lateral (tamaño, aparición, etc.). Por último, por ejemplo, si teníais configurados applets para mostrar la carga de CPU, red, etc., o el tiempo, temperatura, etc., estos tampoco aparecen directamente. La solución es instalar manualmente (y ejecutar y posteriormente configurar) los paquetes indicator-weather para el tiempo, e indicator-multiload para que muestre el uso de CPU, memoria y red. Al ejecutarlos, se establecen en la barra superior tal que así:

Por cierto, que en este caso, no me aparece el icono del tiempo, ni tampoco el icono de terminar la sesión, que está escondido hacia la derecha. Tampoco se pueden mover los iconos, porque el botón derecho no lleva esa opción.

ACTUALIZACIÓN: Por lo que veo aquí instalando el paquete gnome-session-fallback se puede seleccionar "GNOME Classic" en gdm o LightDM... Menos mal.

Sólo el aspecto de la mujer revela que no está destinada ni a los grandes trabajos de la inteligencia ni a los grandes trabajos materiales. Paga su deuda a la vida, no con la acción, sino con el sufrimiento, los dolores del parto, los inquietos cuidados de la infancia; tiene que obedecer al hombre, ser una compañera pacienzuda que le serene. No está hecha para los grandes esfuerzos ni para las penas o los placeres excesivos. [...]

Ahí queda eso. Creo que ningún ser humano se echó tanta mierda (con perdón) encima con un sólo párrafo... Incomprensible, incluso para la época. Mucho menos para ser considerado un reputado filósofo.

BLOG> (hash-table-count
       *words-to-post-hash*)
18119

18119 palabras diferentes. Ahora los posts que contienen "corba", y sus títulos:

BLOG> (gethash "corba" *words-to-post-hash*)
(#<POST {100A12E8A1}> #<POST {100A12E881}> #<POST {100A12E521}>
 #<POST {100A12E4E1}> #<POST {100A12E4C1}> #<POST {100A12E3E1}>
 #<POST {100A12E021}> #<POST {100A12DBA1}> #<POST {100A12D321}>
 #<POST {100A12CEE1}> #<POST {100A12C821}> #<POST {100A12C641}>
 #<POST {100A12C5A1}> #<POST {100A12C361}> #<POST {100A12C2E1}>
 #<POST {100A12B4E1}> #<POST {1003344011}> #<POST {1003343EB1}>
 #<POST {10033437B1}> #<POST {10033436B1}> #<POST {1007887F81}>
 #<POST {1007887221}> #<POST {10078870A1}> #<POST {1007886801}>)
T
BLOG> (mapcar #'post-title (gethash "corba" *words-to-post-hash*))
("¿Por qué un Weblog?" "5.000.000.000" "CCM page, reloaded"
 "Recent articles on CCM" "German book on CCM" "CCM Wiki updated"
 "Some thoughts on Web Services" "New version of the CCM tutorial"
 "Stefan Tilkov on RPC Web Services" "Trabajo en la tesis" "CORBA Reborn?"
 "Interesting post on XML messaging by Stefan Tilkov" "Sistemas Distribuidos"
 "Prácticas de Sistemas Distribuidos" "Un día de trabajo con mi tesis" "FreeNX"
 "Fowler, inversion del control" "Ser profesor tiene sus cosas buenas"
 "Función C++ rara del día" "The S stands for Simple"
 "Conversión sencilla de tipos CORBA" "Parecía que nunca iba a llegar..."
 "Más avances: Cátedra SAES-UMU" "SOAP, entre lo peor de la década")

Lo cual es, por cierto, una magnífica lista de entradas para esa palabra... Esta información también me permitirá añadir al final un conjunto de "posts relacionados" en cada entrada.

[dsevilla@dsr ~]$ pacman -V

 .--.                  Pacman v3.5.4 - libalpm v6.0.4
/ _.-' .-.  .-.  .-.   Copyright (C) 2006-2011 Pacman Development Team
\  '-. '-'  '-'  '-'   Copyright (C) 2002-2006 Judd Vinet
 '--'
                       Este programa puede distribuirse libremente bajo
                       los términos de la licencia GNU General Public License

El juego de palabras es claro. pacman, de "package manager", y también del conocido juego del comecocos.

(defun blog-img (img-file &key alt anchor title params)
  (let* ((param-list
          (cons `(src . ,(format nil "~A/~A" *base-img-url* img-file))
                (cons `(alt . ,(or alt "Blog image.")) ; alt is obligatory
                      (when title `((title . ,title))))))
         (param-list-1 (append param-list params))
         (img-html (img param-list-1)))
    (if anchor
        (a `((href . ,anchor)) img-html)
        img-html)))

¿No es bonito? En particular me gusta el uso del seudoquote. Las funciones img y a generan el HTML para las imágenes y para los enlaces, respectivamente. Un ejemplo de uso de esa función sería:

(blog-img "abc.jpg" :alt "Alt text" :params '((:width . 500)))

donde se elige el fichero img/abc.jpg con un texto alternativo y con el conjunto de parámetros adicionales, entre ellos el ancho de la imagen. Si se especifica un elemento anchor el código que se genera es el siguiente:

(blog-img "abc.jpg" 'anchor "http://wherever.com"  'alt "bah" 'params '(('width . 500)))

<A HREF="http://wherever.com"><IMG SRC="img/abc.jpg" ALT="bah" WIDTH="500"></IMG></A>

[dsevilla@neuromancer:~/svn/blog]$ sbcl --script packages.lisp
Doing pre-calculations...
Generating index page...
Evaluation took:
  0.116 seconds of real time
  0.120000 seconds of total run time (0.080000 user, 0.040000 system)
  [ Run times consist of 0.040 seconds GC time, and 0.080 seconds non-GC time. ]
  103.45% CPU
  325,871,901 processor cycles
  63,697,264 bytes consed

Generating post pages...
Evaluation took:
  0.408 seconds of real time
  0.410000 seconds of total run time (0.270000 user, 0.140000 system)
  [ Run times consist of 0.010 seconds GC time, and 0.400 seconds non-GC time. ]
  100.49% CPU
  1,144,029,612 processor cycles
  167,055,120 bytes consed

Generating categories pages...
Evaluation took:
  0.074 seconds of real time
  0.070000 seconds of total run time (0.070000 user, 0.000000 system)
  94.59% CPU
  209,026,050 processor cycles
  39,985,040 bytes consed

Generating archives pages...
Evaluation took:
  0.086 seconds of real time
  0.090000 seconds of total run time (0.090000 user, 0.000000 system)
  104.65% CPU
  240,093,459 processor cycles
  43,278,720 bytes consed

Generating RSS...
Evaluation took:
  0.084 seconds of real time
  0.080000 seconds of total run time (0.080000 user, 0.000000 system)
  [ Run times consist of 0.020 seconds GC time, and 0.060 seconds non-GC time. ]
  95.24% CPU
  236,784,003 processor cycles
  35,828,208 bytes consed

Esto hace que la optimización, como máximo, sólo pueda reducir esos 0,4 segundos que tarda la generación. Aún así lo intentaré como un ejercicio de programación. La otra idea será ver optimizar el proceso de carga quizá a través de pre-compilación de los ficheros .lisp. Por cierto, para que luego digan que los lenguajes interpretados son lentos... 1 segundo en generar 34MB de ficheros de texto.

La última sorpresa... Por casualidad he probado clisp... Bien, aquí la carga de los ficheros .lisp es instantánea, y la ejecución es incluso más rápida (diría incluso increíblemente rápida:

[dsevilla@neuromancer:~/svn/blog]$ clisp packages.lisp
Doing pre-calculations...
Generating index page...
Real time: 0.186066 sec.
Run time: 0.19 sec.
Space: 24960736 Bytes
GC: 13, GC time: 0.03 sec.
Generating post pages...
Real time: 0.708989 sec.
Run time: 0.69 sec.
Space: 83706152 Bytes
GC: 36, GC time: 0.06 sec.
Generating categories pages...
Real time: 0.051339 sec.
Run time: 0.05 sec.
Space: 11157832 Bytes
GC: 5, GC time: 0.0 sec.
Generating archives pages...
Real time: 0.249124 sec.
Run time: 0.25 sec.
Space: 13408648 Bytes
GC: 6, GC time: 0.02 sec.
Generating RSS...
Real time: 0.891364 sec.
Run time: 0.88 sec.
Space: 20991880 Bytes
GC: 9, GC time: 0.05 sec.

Comparando el tiempo de ejecución visto por el usuario:

[dsevilla@neuromancer:~/svn/blog]$ time clisp packages.lisp
real	0m2.320s
user	0m1.970s
sys	0m0.310s

[dsevilla@neuromancer:~/svn/blog]$ time sbcl --script packages.lisp
real	0m10.405s
user	0m9.940s
sys	0m0.440s

Esto es, ¡5 veces más rápido en general clisp que sbcl! Sin embargo, mirando los datos de cada parte, hay resultados muy extraños e inconsistentes. Por ejemplo, clisp tarda casi un segundo en generar RSS, mientras que sbcl tarda 0,08 segundos (un orden de magnitud menos). Estudiaré el código para ver dónde puede estar el problema, pero por ahora, usaré clisp para generar el blog, aunque use sbcl, con el magnífico entorno Slime para Emacs para seguir programando y probando.

Pero lo que más me ha sorprendido es que el blog actualmente, al ser generado estáticamente, ocupa 34 MBytes de datos, está compuesto por 1393 ficheros HTML, y tarda unos 5 segundos en generarse. No está mal para ser un lenguaje interpretado. Y podría ser mucho más rápido si supiera optimizarlo bien, y arreglara algún que otro algoritmo que podría hacerse más rápido. También si pre-compilara el código en vez de hacerlo cada vez que se genera el blog (esto lo añadiré al script de generación, que recompile los ficheros sólo si han cambiado).

Al ser tantas entradas, he tenido que añadir una opción de dividir todos las entradas en páginas, a un número de 50 entradas por página (de la página principal salen 13 subpáginas). Ha sido algo complicado integrar la generación de várias subpáginas en lo que ya tenía, pero no me ha llevado mucho (una media hora). En parte ha sido más complejo porque Common-Lisp no tiene una operación para partir una lista (la de las entradas) eficientemente, y he tenido que hacerla yo. No es muy compleja, pero tampoco trivial si quieres hacerla eficiente.

(defun categories-links ()
  (if *categories-links*
      *categories-links*
      (setf *categories-links* (multiple-value-bind (max-n-posts min-n-posts)
          (loop for c being the hash-values in *posts-for-category*
             maximizing (car c) into max
             minimizing (car c) into min
             finally (return (values max min)))
        (apply #'concatenate 'string
                (loop for k being the hash-keys in *posts-for-category*
                   using (hash-value v)
                   collect (format nil "<a href=\"category-~A.html\"
                             title=\"~A topic~:*~p\" rel=\"category tag\"
                             style=\"font-size: ~Apx;\">~3:*~A</a> "
                             (string-downcase k)
                             (car v)
                             (+ 9 (round
                                   (/ (- (car v) min-n-posts)
                                      (/ (- max-n-posts min-n-posts) 10)))))))))))

Y eso sin contar con el cálculo de *posts-for-category*.

martina, emma

A través de Flickr:
De hace algunos meses.

Lipca Rollop Ennit 8cm/2.8 + Fuji Neopan 400cn

Vino corriendo hacia mí y salió esta foto :)



She came running to me and I shot this! :)

La otra cara de esta moneda la han tenido lenguajes y paradigmas que cambiaban la manera de programación hacia esquemas que hicieran más fácil escalar en el número de hilos/cores a la vez que permitían una programación más natural de programas multihilo. Estos nuevos paradigmas también evitaban, por diseño, los problemas que se dan con los candados, reentrancia, etc.

El paradigma sobre el que hablaré hoy es el de los actores. Este mecanismo, que data de 1986, se utiliza en Erlang y en Scala, por ejemplo, pero no he encontrado ejemplos de cómo implementar este mecanismo en C++, salvo un artículo de 1993 de Kafura, Mukherji y Lavender en el que no se hace uso de ninguna característica «moderna» de C++, como los tipos parametrizados o la sobrecarga de operadores.

En resumen, el mecanismo de actores se basa en definir un actor como un objeto reactivo que se ejecuta en su propio hilo. Son similares a los objetos stricto sensu, en el sentido de que se les puede enviar invocaciones (en mi caso eventos), y los actores responden ejecutándolos, como los objetos normales. No obstante, son diferentes porque las invocaciones se ejecutan de manera que no causan problemas de concurrencia. ¿Cómo? Pues asegurando que todas las invocaciones sobre un actor se ejecutan en un mismo hilo. En este sentido, un actor también aglutina, en general, un hilo de ejecución propio en el que se ejecutan las llamadas al mismo (esto puede no ser así exactamente, pero la idea es la misma).

Existe una diferencia con los paradigmas tradicionales de programación. Por ejemplo, para no causar problemas de concurrencia, todos los métodos de un objeto se podrían marcar como «synchronized» al estilo de Java. Esto, efectivamente, hace que no haya problemas de concurrencia (al menos los más usuales), ya que todas las invocaciones a un objeto se realizan en exclusión mutua. Sin embargo, una invocación a objeto normal lleva consigo asociada un hilo de ejecución, y el hilo de ejecución del objeto llamante es el que realiza la llamada al objeto llamado, con lo que también se tienen que prevenir problemas como interbloqueos, esperas de candados, etc.

En resumen, sería casi como un sistema basado en eventos en donde los objetos se envían mensajes que son a su vez procesados en los hilos respectivos de cada actor. Ahora bien, ¿cómo implementar en C++ este mecanismo sin ser excesivamente intrusivo, teniendo en cuenta que el mecanismo de envío de eventos no existe en C++? Pensé en utilizar boost.signal, pero éste no asegura que el objeto receptor va a ejecutar la señal en su propio hilo. Los requisitos que establecí pues para el desarrollo fueron los siguientes:

1. El mecanismo debe ser poco intrusivo, en el sentido de que las clases que quieran beneficiarse de este mecanismo no tienen por qué escribirse heredando de un interfaz en particular, sino que sólo tienen que definir una serie de tipos para saber tratarlas como actor.
2. Cualquier clase puede definir de manera sencilla qué eventos puede recibir y cómo actuará ante cualquier evento, y estos serán los únicos requisitos que tendrá que especificar la clase.
3. Las clases pueden modificar de forma sencilla qué eventos producen y reciben.
4. Las clases no tendrán que preocuparse de tratar con hilos, asincronía, almacenamiento y reproducción de eventos, etc.
5. El mecanismo de envío de eventos debe estar integrado en el lenguaje C++ de forma natural. Por ejemplo, con un operador que muestre que se está enviando un evento: objeto << mensaje;.

Con estos requisitos, pensé hacer la clase actor que pudiera aceptar como parámetro cualquier otra clase, y convertirla así en un actor. Este mecanismo es poco intrusivo, sólo obligando a que la clase que se quiere beneficiar de este mecanismo especifique qué eventos es capaz de recibir. La clase actor que me quedó fue la siguiente, con comentarios al estilo de la literate programming (si alguien está interesado le puedo pasar el código sin los comentarios):

template <typename Klass>
struct actor
{
    typedef typename Klass::events_type VariantType;

Uno de los requisitos que tiene que proveer la clase que se va a convertir en actor es ofrecer el tipo VariantType con los distintos eventos que va a poder recibir. Para esto se usará el tipo boost.variant como se verá después.

    typedef actor<Klass> self;

    actor (Klass& a)
        : delegate_ (a)
    {
        thread_ = boost::thread (boost::ref (*this));
    }

Cada actor posee su propio hilo. Esto, por supuesto puede modificarse después. Sólo quería hacer una prueba de concepto. En scala existen schedulers que enlazan actores con hilos.

    // Thread func.
    void operator()()
    {
        std::cout << “running thread” << std::endl;

        while(!stop_)
        {
            bool b;
            {
                boost::lock_guard<boost::mutex> guard (list_mutex_);
                b = el_.empty();
            }

            if (b)
            {
                boost::unique_lock<boost::mutex> lock (mut_);

                // wait on the cond. var.

                cond_.wait (lock);
            }

            while (true)
            {
                VariantType vtv;
                {
                    boost::lock_guard<boost::mutex> guard (list_mutex_);
                    if (el_.empty())
                        break;

                    vtv = el_.front();
                    el_.pop_front();
                }

                // Call the delegate without holding the mutex locked

                boost::apply_visitor (detail::event_caller<Klass> (delegate_),
                                      vtv);
            }
        }
    }

El operator()() de la clase actor ejecuta el código del hilo. He utilizado variables de condición porque me parecen más ricas semánticamente. El hilo básicamente extrae eventos de la cola de eventos y los ejecuta sobre el delegate. Como los eventos de la cola pueden ser de diferentes tipos (nótese que este punto es especialmente difícil en C++), hay que utilizar estructuras que permitan tratar diferentes tipos de eventos de forma genérica. Para eso he usado la construcción boost::apply_visitor de boost.variant. Con el uso de una clase especial, detail::event_caller, que se verá más abajo, se consigue llamar a la clase original, a los métodos process(Evento), para cada uno de los eventos recibidos.

    template <typename Event>
    self& operator<<(Event& e)
    {
        std::cout << “Received event” << std::endl;
        {
            boost::lock_guard<boost::mutex> lock (list_mutex_);
            el_.push_back (e);
        }

        // signal that a new event is available

        cond_.notify_one();

        return *this;
    }

El operador << se puede usar para enviar un evento al actor. Esta es una construcción que queda muy natural. Enviar un mensaje es diferente a realizar una llamada, aunque también se puede pensar en un mecanismo de llamada a función modificado. Al final, el envío de mensajes, como se verá después, será algo así como actor << Clase::Evento(valores);.

    void join()
    {
        thread_.join();
    }

    void stop()
    {
        stop_ = true;
        cond_.notify_one();
    }

private:
    Klass& delegate_;

    typedef std::deque<VariantType>  event_list;
    event_list el_;
    bool stop_; // stop?

    boost::thread thread_;

    boost::mutex mut_;
    boost::mutex list_mutex_;
    boost::condition_variable cond_;
};

Por completitud, aquí está la clase detail::event_caller. Es necesaria para visitar un tipo boost.variant a través de la función boost::apply_visitor. Simplemente llama a la función process() correspondiente.

namespace detail

{

template <typename Klass>
struct event_caller : public boost::static_visitor<>

{
    Klass& instance_;

    event_caller (Klass& i)
        : instance_ (i)
    {
    }

    template <typename T>

    void operator()( T const & operand ) const
    {
        instance_.process (operand);
    }
};
}

Llegamos a la clase sobre la que queremos construir el actor, llamada para este ejemplo TestClass. La clase define internamente un par de eventos (Event1 y Event2), y, como comentamos arriba, el tipo events_type, como un boost.variant de los diferentes eventos que puede recibir. Se pueden ver los métodos process() más abajo. En este caso la clase tiene métodos propios para retornar un actor interno. Esto no tiene por qué ser así, y como se ha visto, los actores son independientes de las clases de las que actúan en representación.

class TestClass
{
public:
    typedef actor<TestClass> actor_type;

    struct Event1

    {
        int data;
    };

    struct Event2
    {
        std::string ss;
    };

    // Obligatory

    typedef boost::variant< Event1, Event2 > events_type;

    actor_type& the_actor()
    {
        return *actor_;
    }

    // Ctor.

    TestClass()
        : actor_ (new actor_type (*this))
    {
    }

    ~TestClass()
    {
        actor_->stop();
        actor_->join();
        delete actor_;
    }


private:
    actor_type* actor_;

public:
    void process (Event1 const& e)
    {
        std::cout << “Processed event: “  << e.data << std::endl;
    }

    void process (Event2 const& e)
    {
        std::cout << “Processed event 2: “  << e.ss << std::endl;
    }
};

Por último, ¿cómo se usa este mecanismo de actores? Lo ideal es proveer de mecanismos que sean semánticamente ricos y que sigan el principio de mínima sorpresa. Con las clases de arriba podemos escribir código sencillo como el siguiente:

    TestClass::Event1 ev;
    ev.data = -2;

    TestClass::Event2 ev2;
    ev2.ss = “abcdef.”;

    TestClass tc;

    TestClass::actor_type& ac = tc.the_actor();

Primero se crean un par de eventos de los dos tipos que puede recibir la clase TestClass, y se obtiene el actor ac. Se puede usar ese actor para enviar eventos a la clase:

    // Send the event2
    ac << ev2;

    // Send message
    ac << ev;
    for (int i = 0; i < 2000; ++i)
    {
        ev.data = i;
        ac << ev;
        ac << ev2;
    }

Aquí se envía primero un evento de tipo Event1, y luego otro del tipo 2. Después se entra en un bucle que envía ambos mensajes, modificando el primer evento con un dato distinto. El programa va mostrando la salida de eventos de la clase en orden:

...
Processed event: 1996
Processed event 2: abcdef.
Processed event: 1997
Processed event 2: abcdef.
Processed event: 1998
Processed event 2: abcdef.
Processed event: 1999
Processed event 2: abcdef.

Un último apunte. Las diferencias con los actores de otros lenguajes dinámicos (Scala, por ejemplo), son que en estos lenguajes se puede especificar un procesado basado en máquinas de estados, como por ejemplo, cuando se recibe el evento 1, después sólo se puede recibir el evento 2. Esta máquina de estados se puede implementar. Es una primera implementación de prueba.

No dudéis en contactar conmigo para ideas o comentarios.

Explicaré por qué. No pude ir al principio de la charla porque estaba dando clase en el máster de la asignatura «Software como servicio y distribuido» hasta las 5 de la tarde, y la conferencia había empezado a las 4. Con todo, cuando llegué estaban en turno de preguntas, y pude hacerme una idea de lo que había sido la presentación, aunque me habría gustado verla desde el principio.

Parece que no fue excesivamente técnica, al menos en la parte que nos interesa a los informáticos, porque una de las preguntas que se hicieron tuvo que ver con el lenguaje de programación o entorno que utilizaban. La respuesta del ingeniero informático:

- Utilizamos C#. Cuando entré a trabajar en la empresa venía de experiencia de programación en C++. Cuando me explicaron lo que tenía que hacer me eché las manos a la cabeza. Eso no se podía hacer con C++. Aprendí en un par de semanas C# e hicimos el programa.

Como se puede suponer, tengo miles de comentarios a este respecto. Primero, sí que pude ver el interfaz gráfico que habían hecho. Interfaces con esa complejidad estamos acostumbrados a hacer en C++ y Qt para SAES en la Cátedra de Software libre, y no nos echamos las manos a la cabeza. El hecho de que un ingeniero en particular no tenga el conocimiento suficiente, o tenga que tomar una decisión acelerada no sé si debería decidir una estrategia para el futuro. Además, aprender en un par de semanas C# no parece lo más adecuado para hacer un programa de calidad, pero en fin. Continuaba:

- La salida de este programa son ficheros XML que utilizamos para comunicar con los equipos de carrera

Esto es mi favorito. Al nombrar XML parece que todo el mundo dice «ah, claro». XML ya hace que los programas interactúen mágicamente... En fin. ¿Por qué no JSON/YAML? Reconozco que esto es más una manía mía, pero ¿por qué en los nuevos desarrollos de bases de datos (CouchDB, MongoDB) no se utiliza XML sino formatos más sencillos y expresivos?

Me hubiera gustado preguntarles por sus ciclos de desarrollo, pruebas, etc., pero como había llegado tarde, ahí se quedó.

La conversación, a raíz de otra pregunta, giró hacia la colaboración de estos grupos con la Universidad. Uno de los ponentes (no recuerdo su nombre) había estado trabajando para Red Bull anteriormente, y contaba proyectos de colaboración que sus antiguos patronos tenían con Universidades. No es el caso de Hispania, según decía, por problemas políticos, o por problemas de medios de las universidades (laboratorios con material especializado, etc.)

En este punto hice una pregunta, dado que tenemos experiencia en colaborar con una empresa, pregunté que para tener una colaboración a nivel de informática no se necesitaban laboratorios especializados (sólo ordenadores y personas). Uno de los ingenieros del equipo (presumo) me interrumpió gritando que «¿Cómo que no necesitas? Para empezar necesitas un superordenador». Intenté responderle a medio hacer la pregunta que no se necesita un supercomputador in situ sino una persona que sepa cómo hacer los programas paralelos que aprovechen en superordenador, y una conexión internet para conectarse al CESGA o al Mare Nostrum (en los tiempos de Internet, los ordenadores no tienen que estar en tu habitación, aparte de que tenemos Ben Arabí, creo recordar de la última vez que estuve allí... Además, ¡¡programan en C#!!, ¿qué supercomputador???)... Cuando me dejó terminar la pregunta, la respuesta del ponente era la misma, cuestiones políticas que escapaban a su nivel de puesto de trabajo que hacía que no se colaborara con la Universidad tampoco en informática. Creo que nuestra experiencia en testing, modelado, etc., sería interesante para ellos, pero aquí estamos.

Finalmente, fallo garrafal (según mi punto de vista). Se quejaban de que tenían un presupuesto limitado, y utilizan software propietario, licencias, etc., en vez de sacar partido al software libre (incluso para C# existe Mono...).

Espero que los ingenieros en otras ramas estén más al día, porque si no, el equipo va a ganar pocas carreras :)

Fotos del concurso de fotografía en Mula del pasado domingo. De esta me gustó especialmente el fondo de colores otoñales. No creía que iba a conseguir esto en Mula :)

# modprobe ramzswap
# /usr/lib/initramfs-tools/bin/rzscontrol /dev/ramzswap0 --init
# swapon /dev/ramzswap0

DiskSize:         1014604 kB
NumReads:            226
NumWrites:     5962
FailedReads:              0
FailedWrites:             0
InvalidIO:        0
NotifyFree:              19
ZeroPages:      826
GoodCompress:            99 %
NoCompress:             0 %
PagesStored:         5117
PagesUsed:     1331
OrigDataSize:         20468 kB
ComprDataSize:      5072 kB
MemUsedTotal:       5324 kB

Del archivo. Hace algún tiempo celebró mi colegio los 50 años. He visto esta foto y me ha gustado.

Rolleiflex 3.5f + Fuji neopan400

Con su muerte se va uno de los escasos intelectuales comprometidos, uno de los más preclaros, por su coherencia y su capacidad para unir acción social, literaria y política. Siempre fue una persona fiel a sus principios. Hoy día, cuando se echan tanto en falta referentes de todo orden, su presencia pública era un lujo.

Rodríguez Ibarra ha criticado que la izquierda defienda "con tanto ahínco" la propiedad intelectual y ha asegurado que un cambio en el modelo de negocio de las industrias de los contenidos no va a "acabar con la creación", algo que cree que demuestra el hecho de que "nunca ha habido tanta creación cultural como hoy".

Now imagine hashing resources into points on the circle. They could be URLs, GUIDs, integer IDs, or any arbitrary sequence of bytes. Just run them through MD5 or SHA and shave off everything but 8 bytes (and if anyone tells you that you shouldn’t use MD5 for this because it isn’t secure, just nod and back away slowly. You have identified someone not worth arguing with). [...]

• SIGMA 30mm 1.4 EX DC HSM for NIKON, un objetivo grandioso para formato DX, que fue el objetivo preferido cuando usaba la D200.


• Nikon Zoom-Nikkor 55-200 AFS DX f/4-5.6G ED, un zoom sin pretensiones, pero que no está nada mal, y además pesa muy poco. Lo he usado poco, pero es ideal si quieres tener un zoom largo y no quieres cargar con un objetivo tocho.
  


• SIGMA 17-70 f. 2.8-4.5 DC SLD Macro, un zoom muy versátil desde gran angular (17mm) hasta telefoto medio (70mm) y con una gran apertura (f/2.8) y con características de macro.

(a.k.a. wonders of iso 3200)



I saw her in the bathroom and I had to do this :)



Nikon D700 + Nikkor 50mm/1.4.

¡Aquí está! ¡Qué bonita es! :) Con un día de vida en el hospital. No he tenido tiempo ni de subir más fotos, pero todo se andará :)

Here she is! How beautiful she is! Just one day after birth at the hospital. I haven't had time to upload any more photos, but hopefuly I will in the near future :)

D700 + 50mm/1.4 AF

Los medios de comunicación de izquierdas han atizado en las últimas semanas al papa...

“En aquellos países donde se difunde la fe católica, la enfermedad del SIDA se expande menos que en las regiones donde se reparte el profiláctico”

“Hay que tener cuidado y no rasgar el producto con las manos; en fin, la manicura en África no destaca”

“Y si a esto sumamos que los ciudadanos del Tercer Mundo no saben leer, el uso del preservativo puede ser un peligro”

“Prácticamente toda la población del continente se encuentra en zonas donde el clima es eminentemente caluroso, lo que hace dificil la conservación de los preservativos”

“Aun si entendieran lo que leen, es dudoso que los africanos lleguen a aplicar directrices como la de tener cuidado al desplegar la funda. Muchos habitantes de zonas rurales del continente negro tienen unas manos que pueden ser no aptas para la manipulación del preservativo”.

She's comming but not here yet :) Just to be prepared, we bought a d700 to get just great photos of her :)



This is her room, that we prepared with such care and eagerness. I just have to fix that bulb and it will be done. Note the nice frame made by my mother with her name. Lovely.



Nikon D700 + Stone Age Tamron 17mm/3.5.

• hippie-expand
  


• Introducción a CEDET.


• Respuestas en stackoverflow.com: aquí, aquí, y aquí.

oh my!



Lipca Rollop TLR. Ennit 2.8 (@2.8) + Fuji Neopan 400CN. 400 ASA, C-41 B&W.

Pentax 67 + 105/2.4 + Fuji Astia 100f

View On Black

Polaroid Land Camera 250 + Fuij FP-100c.



Emma is reaching her 9th. month... Martina is nearly here! :)

Polaroid Land Camera 250 + Fuij FP-100c.



Emma is reaching her 9th. month... Martina is nearly here! :)

• Coding without comments y Code Tells You How, Comments Tell You Why, de Jeff Atwood, con comentarios sobre el conocido como literate programming, introducido por Knuth para implementar, entre otros, su TeX. En el último artículo introduce una cita que me parece muy ilustrativa:
  
  
  
  

  Programs must be written for people to read, and only incidentally for machines to execute.

  
  
  
  


• Después, una reflexión de si la capacidad o incapacidad para escribir en tu idioma materno afecta a tus capacidades de programación: Does Bad Writing Reflect Poor Programming Skills?, lo cual tampoco había pensado nunca, pero es una reflexión válida. Como batallita, comentaré que una de las preguntas que más me sorprendió de cuando hice mi entrevista en Google fue que uno de los que me entrevistaron directamente me preguntó «Virtual methods in C++?», y yo lo miré como diciendo... ¿qué? Me estaba pidiendo, por supuesto, que se lo explicara. Perfectamente, una cosa tan sencilla no iba a tener problema en explicárselo. Sin embargo, me puse a contárselo y no me salían las palabras exactas... ¿Habré hecho yo métodos virtuales en mi vida?, me preguntaba yo... unos cuantos miles... en fin...
  


• Finalmente, al hilo de los comentarios en el código, unas cuantas razones de por qué los programadores no comentan su código, entre otras, porque "I'm the greatest programmer ever!"... :)
  

Los creyentes, como todo parece indicar, creen. A pesar de la vasta cantidad de cosas en las que creer, los creyentes se decantan casi unánimemente por amigos imaginarios, seres superiores intangibles e inaprensibles que dirigen el Cosmos y, por ende, la vida humana. Algunos de ellos incluso gustan proclamarlos miembros de su familia, y los conciben como padres, madres o hermanos. Otros los prefieren en versión consciencia de la naturaleza, o incluso señores de la guerra interestelar.

[...] Al principio se te escapa una risa floja. Je, je, cómo no voy a poder cagarme en dios. Si se te ocurre tener ese desliz en presencia de un creyente, la intensidad de su mirada te convencerá de que en efecto habla en serio. Sal del shock.

Esto, que evidentemente es una gilipollez, puede resultar muy útil cuando se debate con creyentes. Porque está escrito en su mismo lenguaje, en unos términos que pueden entender perfectamente (cuidado: si dices amigo imaginario y no dios pueden enfadarse) [...]

[...] is it good enough for him to be in good shape? Hardly. Maybe it's sufficient for a position on a high-school junior-varsity team, but Amazon's supposed to be more like the NFL than high school J.V., isn't it? I think so.

We were in Hamburg for a few hours. After a walk through the city I just sit down a little expecting someone passing by.



Bronica GS-1 + 110/3.5 + 6x6 back + Fuji Velvia 50.

Yashica 635 + Fuji RAP 100F + +1 close-up lens.



In the same series as the previous one with the P67. A little bit overexposed, but I like it this way. I can't think of a title right now...

Last (and only) snow of the season I took my mother for a walk to see the snow. She feels alone since we lost my father thirteen years ago. I love to share these moments with her, and I like the way she's not looking at me, and thinking on her own things.



Norita 66 + Noritar80/2 + Fuji RAP 100F slide film.

WOW! How long! I almost forgot how to upload photos on Flickr :) I'm sorry for the delay. My computer broke, and I lost all my recent (digital) photos... Curiously, the only ones I still have are those analog negatives I usually shoot :)



It took me some time to configure again things, sort out negs, etc., but I hope to be uploading a little bit more from now on.

Rolleiflex SL 66 + Rollei HFT Planar 80mm/2.8 + Fuji RAP 100F



The rollei is just fantastic.

Rolleiflex SL66 + Rollei HFT Planar 80mm/2.8 + Fuji Velvia 50.

Taken with a Kowa Six :) Fuji Pro 800z. Sometimes size matters...

Pentax 67 + SMC 45mm/4 + Fuji Velvia 50 slide film.

Claramente se me ve el parecido, ¿verdad? Llamémosle su primera foto "lo-fi" :)



You clearly see the resemblance, right? Let's call it his first "lo-fi" photo :)

Norita 66 + Noritar 80mm/2 + Fuji RAP 100F

• Sutter's Mill, de Herb Sutter.


• Visual C++ Team Blog, util para estar al día de las mejoras de C++0x.


• C++ Soup!. Impresionante. Ojo a esta entrada.


• C++ truths, que casualmente es del grupo de investigación donde estuve en EEUU: DOC group (Distributed Object Computing Group), los desarrolladores de ACE y TAO.

Long ago in a forgotten flower...



Nikon D50 + Tamron 90mm macro + rawstudio.