netzstaub

Ecto somehow managed to fuck up all the fixed-width text used for program code in the LISP entries. This will get fixed ASAP, sorry.

Update: it should be better now :). Here is the LISP sourcecode I used to cleanup the entries. I replace P entries with monospace font with PRE entries. This sourcecode uses the HTML pattern matcher which can be found at svn://bknr.net/trunk/bknr/src/html-match . It is a real memory abuser, and quite slow too, but it works 🙂

(defun load-file (file)
  (with-open-file (s file :direction :input)
    (let ((lines (loop for line = (read-line s nil 'eof)
                    until (eql line 'eof)
                    collect line)))
      (reduce #'(lambda (s1 s2) (concatenate 'string s1 s2)) lines :initial-value ""))))

(defun cleanup-ecto (file output-file)
  (let* ((body (cons :html
                    (net.html.parser:parse-html (load-file file))))
         (res (html-replace body
               (html-pattern ((:p :style "font-family:monospace;font-size:13pt;") ?body)
                             (cons :pre
                                   (html-replace ?body
                                                 (html-pattern :br (string #\Newline))))))))
    (with-open-file (s output-file :direction :output :if-exists :supersede)
      (net.html.generator:html-stream s
          (mapcar #'(lambda (x) (net.html.generator:html-print x s))
                  (cdr res))))))

I finally wrote my first “real” javascript program this weekend. I have a lot of articles about biology. Each article can have tables, figures, and references to other articles. Furthermore, each article has a kind of small introductory text, called the “definition”. I wanted to have tooltips showing these figures, tables and definitions when dragging the mouse over a link. For example, if a paragraph features a link to another article, I wanted to have a tooltip showing the title, author and definition of the other article showing up. This would also be the first “real” program written with my “lisp to javascript” compiler.

Continue reading →

This is the second posting of what will be a series about practical uses of the Metaobject Protocol. The MOP enables introspection and customization of the Common Lisp Object System. In the first posting, we saw how to create custom slot definition objects, and how to add new slots to a class definition. In this posting we will see how we can use these custom slot objects to control slot access to our indexed objects.

Continue reading →

I’ll try to write this blog entry in english. I’m not very used to writing in english though, so please bear with me 🙂

I will try to show how to use the Metaobject Protocol for CLOS (the Lisp OO system). When learning how to use MOP, I had quite a hard time finding examples on the web, and the seminal work about MOP (The Art of the Metaobject Protocol) doesn’t offer that much help either. Furthermore, MOP is not really standardized as it is, and most Lisp implementations offer subtly different implementations. The code I’ll present here has been tested with PCL-based Lisp implementations (SBCL and CMUCL, for example), and with Allegro CL. I guess it can easily be ported to other Lisp implementations, but haven’t got around to do it for now.

A good deal of the functionality of BKNR is based on the Metaobject Protocol, namely:

1. the Indices package, which offers object-oriented indices on CLOS objects.
2. the XML import/export package, which offers XML bindings for CLOS objects,
3. the Datastore package, which offers persistent CLOS objects and support for logged transactions.

The Metaobject Protocol is a “meta”-layer above CLOS which allows both introspection and customization of the Object System.

Continue reading →