Elia Scotto

Junky - William S. Burroughs

Fri, 23 Jan 2026 00:00:00 GMT

Junky è un libro affascinante che tratta di un tema singolare in letteratura; la vita di un dipendente dall’eroina. William Burroughs decide di raccontare in prima persona — nonostante usi uno pseudonimo — perché lui stesso è stato dipendente dalla sostanza per quasi tutta la vita. Junky è stato il suo primo successo, ed ha elevato Burroughs a capostipite della beat generation, la corrente letteraria americana di metà secolo scorso, basata su una forte ribellione artistica e sessuale accompagnata da un consumo smoderato di droghe.

La storia si svolge a metà degli anni 40 in America, ed è di fatto la biografia della dipendenza di Burroughs, anche se i fatti narrati non sono tutti totalmente reali. Cosa passa nella mente di un tossico? Come pensa? Qual’è il vocabolario che usa e quali sono le sue unità di misura? Il libro è fenomenale nel raccontare la quotidianità di un eroinomane, sempre alla ricerca della sostanza, o di soldi, sempre a fare attenzione di non esser “pizzicato” dalla polizia. Più che una successione di eventi, il racconto è un viaggio interiore. Le pagine contengono i pensieri quotidiani di un tossicodipendente accompagnati dalla cronaca minuziosa dei suoi frequenti abusi, delle astinenze e le successive ricadute.

Junky è un viaggio scandito da continui spostamenti tra città e nazioni, per sfuggire a possibili arresti, da frequenti visite ai dottori per ottenere prescrizioni per la morfina, dallo spaccio per guadagnare soldi e poter mantenere la dipendenza, ma soprattutto dal costante bisogno quotidiano di eroina. Dalle pagine traspare il vero significato della dipendenza, che prima che esser fisica è soprattutto mentale. Il pensiero di trovare la sostanza diventa il motore sia della storia che della vita di chi, come Burroughs, ne è schiavo. Tutte le pagine non parlano d’altro che di eroina, trasformando il racconto nel diario intimo di un tossico.

La dipendenza viene continuamente interrotta. Una volta al protagonista manca l’eroina, un altra volta sceglie di disintossicarsi e si rivolge a una clinica, un altra ancora finisce in cella. Ogni volta è scabroso il racconto dei dolori fisici che prova quando al suo corpo viene a mancare la dose. Parliamo di febbre, nausea, insonnia, diarrea, dolori diffusi, soprattutto alla spina dorsale, quest’ultimo chiamato in gergo “la scimmia sulla schiena” — uno dei titoli alternativi con cui in Italia è uscito il romanzo. Sono paragrafi raccapriccianti e snervanti, dove spesso il protagonista è costretto ad assumere dosi di altre sostanze per calmare i dolori e compensare lo sbilanciamento chimico. Quando Burroughs si trova in astinenza si rivolge ad altre sostanze, principalmente alcool e erba, ma anche oppiacei vari, cocaina, barbiturici, addirittura prova il peyote messicano, per riuscire a calmare il bisogno di eroina. La cosa più triste di tutte sono le continue ricadute, che perdurano fino alla fine del romanzo. Burroughs non riesce mai a smettere per più di un paio di mesi, che incontra qualcuno che gli offre una nuova dose. Lui non riesce a trattenersi, si fa, e in un attimo si ritrova intrappolato nel solito ciclo distruttivo.

I personaggi nella storia appaiono e scompaiono. Di solito sono clienti o amici che coprono un ruolo per la durata di qualche pagina, poi Burroughs si sposta, cambia città, finisce in cella, e tutto ricomincia da capo con nuovi personaggi, nuovi prezzi, ma identiche sostanze. Le persone più vicine a lui, come la moglie, vengono menzionate raramente, quasi fossero degli intoppi insignificanti davanti all’enorme soddisfazione che prova quando si inietta l’eroina. Eppure la moglie non esita a definirlo noioso e patetico quando intuisce che sta per ricadere nella dipendenza.

Infinte Burroughs nel romanzo non critica direttamente la droga, anzi promuove l’eroina a stile di vita fin dall’introduzione. Nel libro non incoraggia il lettore a farne uso, anzi sembra quasi voglia ridimensionare la propria dipendenza. Parla spesso di vari parametri, come il numero di mesi e di iniezioni quotidiane, quasi a dire che la sua non è una dipendenza tale da dover esser ritenuta grave — una tipica auto-riflessione da tossico. La critica all’eroina fuoriesce dal racconto. Non si può che provare pena per i dolori che soffre il protagonista quando è in astinenza, per la continua lotta nella ricerca di una nuova dose, per il terrore costante di essere scoperto e incarcerato per spaccio, ma più di tutto per la continua ossessione per la droga che occupa la sua mente. Per un junky l'intera vita ruota attorno all'eroina: persino il risveglio viene dominato dal bisogno della dose, senza la quale la normalità resta irraggiungibile.

The question is frequently asked: Why does a man become a drug addict?
The answer is that he usually does not intend to become an addict. You don’t wake up one morning and decide to be a drug addict. It takes at least three months’ shooting twice a day to get any habit at all. And you don’t really know what junk sickness is until you have had several habits. It took me almost six months to get my first habit, and then the withdrawal symptoms were mild. I think it no exaggeration to say it takes about a year and several hundred injections to make an addict.
The questions, of course, could be asked: Why did you ever try narcotics? Why did you continue using it long enough to become an addict? You become a narcotics addict because you do not have strong motivations in the other direction. Junk wins by default. I tried it as a matter of curiosity. I drifted along taking shots when I could score. I ended up hooked. Most addicts I have talked to report a similar experience. They did not start using drugs for any reason they can remember. They just drifted along until they got hooked. If you have never been addicted, you can have no clear idea what it means to need junk with the addict’s special need. You don’t decide to be an addict. One morning you wake up sick and you’re an addict.

Liture, How I Manage My Reading Notes

Wed, 17 Dec 2025 00:00:00 GMT

Useful software often comes out of frustration. When a programmer finds themselves wondering about a tool or a library that doesn’t exist yet, they may decide to write it. At least, they know it would be useful for one user, themself, not to mention the fun of coding. In my case, I needed an easy way to navigate my ebook notes, and all I could find were subscription based services that didn’t fit my casual use. This is how Liture started.

“Readers eat books. Film eats viewers.” — The Wave in the Mind, Ursula K. Le Guin

One of the advantages of physical books is that we can write on the margins. That text filling the white space that the page offers has a name, marginalia, and it’s the old analog way to make that book copy feel ours. By writing on it we can enrich the text with our thoughts, and also highlight our favourite passages as well as the most crucial one to help us revise our reading later on. I tend to use a pencil, a ruler, and some coloured tags attached in the margin for quickly jumping to the best parts in the future.

A lot of great writers in the past have used marginalia. Some of their book copies are still preserved, online we can see photos of the annotations made by names like Herman Melville, William Blake, Mark Twain, Jane Austen, Sylvia Plath, Jack Kerouac. I know that Vladimir Nabokov used to draw maps and object, since some of the original pages were printed on his posthumous book Lectures on Literature, like his annotated copy of Franz Kafka’s Metamorphosis. David Foster Wallace became famous for his heavy use of margin annotations. Some of his copies of Cormac McCarthy and Don DeLillo, filled with various notes, numbers and drawings, are kept exposed at the University of Texas in Austin.

I've read far more books recently than I did a few years ago, and I do most of my readings with an ebook reader. I love printed books. I miss the feeling that touching paper gives, the visual feedback of the progress, the different style for covers and typography used for each book. I still buy physical copies and often second-hand, but I prefer to read in Italian[^1], my original language, and since I'm in Australia, far from Italian bookshops and I don’t want to pollute the planet with my hobbies, I mostly read digital books.

I also have the habit of highlighting in books and sometimes taking annotations, which it's easy using an e-reader. Soon my collection of quotes and notes had grown. For some books, like 21 Lessons for the 21st Century, I had to print my highlights to review them, filling around 15 pages, and then re-highlight the most important parts. Even if I find paper more effective for focus reading than digital text, I become frustrated every time I had to review my highlights and notes from an ebook, since I couldn't find a way to access that data.

I use a Kobo reader and all the content that the user generates is stored inside the device. Export is not officially supported. A few years ago I started maintaining a python script that extracts highlights and notes in different formats, but with a lot of notes it stopped being practical. I needed a way to search my highlights and notes, to save my favourite quotes, to see them grouped by author and book. Also highlighting as well as typing on an e-reader is not that precise, the devices are usually quite slow to respond, so I ended up having a lot of errors and imperfection to fix. I want to edit my content, and also add new notes to enrich it. I needed a new kind of software for this.

Annotations on ebooks should mimic those on physical books; they have to be easily accessible and preserved. Keeping them stored inside devices in proprietary formats is dangerous. They can easily get lost. I started thinking that some of my book notes matter as much as photos of my past, they’re a part of my reading experience and I want to keep them for the future.

Kobo, Kindle, Apple Books, none of them facilitates exporting highlights and notes outside of their own platform, no common format exists for that. That’s where Liture comes helpful. It’s a desktop app to import and manage notes and highlights from the main three book platforms. The user can search and edit content, save the favourite items, and also manually add new authors, books, and notes. No cloud or subscriptions, free for all platforms. I’m using it to keep importing new highlights every time I sync my Kobo on my mac, and the content is automatically stored in a SQLite file that I regularly backup.

“There must be something in books, something we can't imagine, to make a woman stay in a burning house; there must be something there. You don't stay for nothing.” — Fahrenheit 451, Ray Bradbury

I think there’s a lot of potential for great software for readers, and still a lot to do. Big tech companies disregard reading and prefer to focus on more lucrative content, so readers are usually left with old platforms, not frequently updated, missing modern features, and often with incompatible formats. But it's not all lost. Some groups of passionate readers are awakening and trying to fix the situation building new platforms and apps. I would like to do my part releasing Liture. Enjoy and make good use of it!

[^1]: I tell others that I prefer Italian because I find the language generally more expressive than English, but in reality it’s because I fear I might forget it one day. So I read in Italian to keep the language from rusting in my head.

Quel che resta del giorno - Kazuo Ishiguro

Fri, 26 Sep 2025 00:00:00 GMT

La sera è ciò che resta del giorno, come la vecchiaia è ciò che ti resta della vita. Il protagonista dell’opera di Kazuo Ishiguro uscita nel 1989, è un maggiordomo oramai anziano che decide di intraprendere un viaggio, sia fisico guidando la sua auto nelle campagne del sud-ovest dell’Inghilterra, sia nella sua memoria, ripercorrendo scene della sua carriera presso la dimora Darlington. Quel che resta del giorno è stato il primo successo dello scrittore inglese, grazie al quale vinse il Booker Prize che gli permise di esser riconosciuto a livello internazionale, anche grazie alla trasposizione cinematografica con Anthony Hopkins come attore protagonista.

Stevens interpretato da Anthony Hopkins nel 1993

Stevens è un maggiordomo a capo del servizio nella residenza di un lord inglese chiamato Darlington. Dopo la morte del padrone, la residenza omonima passa in mano a un magnate americano Mr Faraday, che nonostante i tagli del personale, necessita di buoni servitori al suo servizio. Stevens decide quindi di prendersi qualche giorno di vacanza per andare a trovare una sua conoscenza che anni prima aveva servito a Darlington hall, Miss Kenton, e convincerla a riprendere il suo vecchio ruolo. Il viaggio in auto lo porta attraverso i panorami della campagna inglese dove si trova a riflettere in una serie di flashback che raccontano episodi della sua carriera con lord Darlington. In queste memorie si intrecciano più trame, come il contesto storico del racconto, descritto tramite la partecipazione politica del lord nelle fasi preliminari della seconda guerra mondiale e la sua decisione di appoggiare l’operato della Germania, oltre che vari avvenimenti che riguardano i personaggi che soggiornano a Darlington hall.

“La sera è la parte più bella della giornata. Hai concluso una giornata di lavoro e adesso puoi sederti ed essere felice. Ecco come la vedo io. Domandate a chiunque e vedrete che vi diranno tutti la stessa cosa. La sera è la parte più bella della giornata.” — Stevens

Il racconto è in prima persona dal punto di vista del maggiordomo, un espediente utile a Ishiguro per narrare vari avvenimenti, come le cerimonie formali tra rappresentanti politici di varie nazioni che avvengono nella residenza, attraverso gli occhi — e le orecchie — di un maggiordomo. Stevens riporta solamente porzioni di conversazioni, battute di personaggi e piccoli incidenti che gli sono rimasti nella memoria, i quali vengono lasciati al lettore come pezzi di un puzzle da comporre per comprendere ciò che non viene direttamente narrato. Il nascondere gli eventi e rivelarli solo in parte durante la narrazione è uno dei tratti caratteristici dello stile di Ishiguro, che ho ritrovato anche nel suo romanzo successivo Non lasciarmi. Oltre a questa unicità, in entrambi i romanzi i protagonisti prendono parte a una storia d’amore che, sebbene ordinaria, è anche inconclusiva. Infatti anche in Quel che resta del giorno, scopriamo che i sentimenti di Miss Kenton per Stevens, in qualche modo si intuiscono dai flashback ma vengono rivelati del tutto nel finale, vengono totalmente ignorati dal maggiordomo. Stevens è profondamente convinto che esista una precisa nozione di grandezza riferita alla professione del maggiordomo. Nonostante la definizione non appaia mai univoca nel libro ma sempre frammentaria, si può ricostruire che essa consista nel reputare onorevole il servire il proprio lord al meglio delle proprie possibilità, ripudiando qualsiasi comportamento inadatto o giudizio sugli avvenimenti nella residenza, oltre che mostrandosi sempre in atteggiamento sobrio e disponibile a qualsiasi richiesta. Stevens intende chiaramente dimostrare a se stesso di poter essere un grande maggiordomo, nonostante non si reputi tale, ed è per questo che decide di non dar corda ai sentimenti di Miss Kenton, sarebbero per lui solo una distrazione inopportuna.

Le capacità narrative di Ishiguro sono eccezionali. Per esempio in una scena, di per se secondaria ma che nel contesto della storia assume un’importanza centrale, Stevens sta leggendo un libro e Miss Kenton gli si avvicina cercando di rubarglielo di mano per scoprire cosa stesse leggendo. Ella vorrebbe fare con quel gesto una qualche breccia nella barriera professionale che ancora li divide e cercare di andare oltre la formalità dei loro discorsi, sempre diretti al servizio della casa e alle nuove disposizioni da attuare. Stevens si rifiuta fermamente, invitandola molto educatamente a non violare i suoi momenti di riposo. Miss Kenton infatti scopre giocosamente che Stevens stava leggendo una banale storia d’amore, ma il maggiordomo mette subito a freno la curiosità della domestica spiegandole che per adempire al meglio al suo ruolo è richiesto leggere, anche romanzi, per poter adottare sempre il vocabolario più adatto ad ogni conversazione. La scena evocativa mostra quanto Stevens sia capace di dedicarsi al suo ruolo, al punto da reprimere i suoi sentimenti e non distinguere più la sua vita privata dal lavoro.

In entrambi i romanzi che ho letto dell’autore, mi sono ritrovato a pormi delle domande non banali. Esse emergono dalle pagine e non vengono mai poste direttamente, siccome i personaggi finiscono per ritrovarsi in situazioni ambigue e moralmente complesse. È una delle specialità dello stile narrativo di Kazuo Ishiguro. Mentre in Non lasciarmi mi ero posto domande sui quali debbano essere i limiti della scienza, in questo libro è impossibile non domandarsi quali siano i limiti nella dedizione al proprio lavoro. Non si tratta di puro stacanovismo, ma piuttosto di chiedersi la fede incondizionata che ha Stevens per il proprio padrone, al punto da sopprimere qualsiasi dubbio, giudizio o addirittura sentimento perché in contrasto con i requisiti per essere un grande maggiordomo, sia giustificata. Più di trent’anni dall’uscita del libro, è ovvio che quel tipo di mentalità è oramai antiquata, allo stesso modo di tutte le riflessioni che Stevens fa a favore di lasciare le decisioni fondamentali per il futuro del paese ad un gruppo di leader, perché a suo dire loro sanno quello che fanno meglio di chiunque altro. Da queste riflessioni emergono le differenze tra il vecchio modo di pensare di inizio secolo scorso, in cui si credeva che un uomo avesse un ruolo assegnatogli nella società e l’unica cosa che dovesse fare e svolgerlo al meglio, senza occuparsi di faccende complesse fuori dalla sua portata, in contrasto con l’uomo moderno, che da importanza all’educazione personale, e si sente libero sia di scegliere la propria strada nella vita, sia di poter esprimere opinioni e preferenze su eventi e decisioni che non lo riguardano direttamente. Miss Kenton nel racconto la pensa diversamente da Stevens, non crede che il suo ruolo definisca la sua intera vita. Sceglie l’unica via liberatoria che ha a disposizione, e decide di sposarsi, provando a costruirsi una famiglia, e smettendo così di essere alle dipendenze altrui. Anche se le cose alla fine non le sono andate per il meglio, ha scelto di esercitare la sua libertà provando a crearsi una vita diversa, rinunciando a dedicare tutta se stessa al ruolo di domestica. Stevens nel finale si rende conto di aver sprecato gran parte della sua vita inseguendo un ideale inconclusivo, e ha il rimpianto di non aver scelto per se un’altra strada per evitare la solitudine alla fine dei suoi giorni.

Leggendo alcune interviste sul romanzo, Ishiguro ha dichiarato essersi documentato a dovere e di aver addirittura letto dei manuali inglesi sui maggiordomi di inizio secolo, che spiegavano le procedure corrette per organizzare il servizio e intrattenere gli ospiti. Dopo mesi di ricerca l’autore ha prodotto la prima bozza del romanzo in un solo mese, chiudendosi in nel suo studio a scrivere anche per tredici ore al giorno, per ridurre al minimo qualsiasi influenza esterna sulla sua immaginazione e concentrarsi solamente sulla scrittura della storia che aveva in mente. Durante questa immersione nel processo creativo, Ishiguro ha detto di aver appositamente evitato di riscrivere o correggere le bozze, ma solo di essersi annotato le successive modifiche da apportare una volta concluso l’intero racconto. Mi vien da pensare che Ishiguro, oltre che a costringere se stesso a scrivere, volesse tentare di avvicinarsi il più possibile alla quella dedizione assoluta al proprio lavoro descritta nel romanzo, così da caratterizzare al meglio Stevens tramite le sensazioni che provava durante tutte quelle ore di intensa produzione.

A simple Common Lisp web app

Wed, 30 Apr 2025 00:00:00 GMT

One of the drawbacks I’ve found when dealing with Common Lisp is the lack of documentation available. Too often, I find published libraries without an explanation of how they are meant to be used or only partially documented, and I need to dig into the source code to understand what they do and to see all the functions available. Even though reading source code is a proven technique to improve one's grasp of a programming language, most other systems come with extensively documented libraries, something appreciated by beginners and a factor that often contributes to a language's popularity.

In my opinion, this lack of good documentation is one of the reasons Common Lisp is often seen as challenging for beginners, which makes it harder for the language to become popular.

Some time ago, when I looked for guidance on writing a generic web app, I was surprised by the absence of a quickstart page to help me set up a simple server—something the Python community has provided for Flask for many years.

“The most underrated skill to learn as an engineer is how to document. Fuck, someone please teach me how to write good documentation. Seriously, if there's any recommendations, I'd seriously pay for a course (like probably a lot of money, maybe 1k for a course if it guaranteed that I could write good docs.)” A drunk dev on reddit

So I put together a short tutorial on how to build a simple web app in Common Lisp, inspired by the Clojure tutorial written for Luminus. The goal is to write a guestbook demo, involving template rendering, connecting to a database to run queries, and exposing routes to the webpage.

To follow the tutorial, you need a Common Lisp implementation, like SBCL, with Quicklisp, the dependency manager. I also recommend having a REPL integrated with your IDE, like SLY for Emacs or Alive for VSCode.

I’ll use more modern CL libraries that have an interface similar to other languages, so it might be a bit easier to follow along.

The server

First things first, I created a new Common Lisp project. To do that with a simple boilerplate, I loaded cl-project in the environment and called the function make-project with a path and a name for the project.

> (ql:quickload :cl-project)
To load "cl-project":
  Load 1 ASDF system:
    cl-project
; Loading "cl-project"
..
(:CL-PROJECT)

> (cl-project:make-project #P"~/guestbook/" :name "guestbook")
writing ~/guestbook/guestbook.asd
writing ~/guestbook/README.org
writing ~/guestbook/README.markdown
writing ~/guestbook/.gitignore
writing ~/guestbook/src/main.lisp
writing ~/guestbook/tests/main.lisp
T

Then I ran this command to let Quicklisp know where my new project is located.

> (pushnew #P"~/guestbook/" asdf:*central-registry* :test #'equal)

I declared the required libraries in the :depends-on property so that Quicklisp would download them from the repo and load them into the environment.

(defsystem "guestbook"
  :version "0.0.1"
  :license "MIT"
  :depends-on (:alexandria        ;; utils
               :uiop
               :cl-ppcre          ;; regex library
               :cl-syntax-annot   ;; for @export annotation
               :clack             ;; Web libraries
               :lack
               :caveman2          ;; Web framework
               :djula             ;; Template engine
               :cl-dbi)           ;; Database
  :components ((:module "src"
                :components
                ((:file "config") ;; files into src/
                 (:file "db")
                 (:file "web")
                 (:file "core"))))

Now, inside src/core.lisp (I renamed the file from main to core) I added two new functions, to start and stop the server, which will be helpful to use from the REPL.

(defvar *server* nil)

(defparameter *app*
  (lack:builder
	  (:static
      :path (lambda (path)
              (if (ppcre:scan 
                    "^(?:/images/|/css/|/js/|/robot\\.txt$|/favicon\\.ico$)" 
                    path)
                  path
                  nil))
      :root *static-directory*)
  ;; Additional middlewares
    guestbook.web:*web*))

@export
(defun start (&rest args
              &key
                (server :hunchentoot)
                (port 3210)
                (debug nil)
              &allow-other-keys)
  "Starts the server."
  (when *server*
    (restart-case (error "Server is already running.")
      (restart-server ()
        :report "Restart the server."
        (stop))))

  (setf *server* (apply #'clack:clackup *app*
                   :server server
                   :port port
                   :debug debug
                   args))
  (format t "Server started"))

@export
(defun stop ()
  "Stops the server."
  (when *server*
    (clack:stop *server*)
    (format t "Server stopped")
    (setf *server* nil)))

*server* contains the server instance and is defined as a variable since we will need to redefine it. *app* is the web application wrapped with a layer by Lack. start and stop instantiate the server with some logging, or raise errors if the action is not successful.

Lack and Clack are the two libraries I used to wrap the web application. The first one allows to define a series of middlewares in the server; for example, I used :static to tell the server where to find all the static assets in the project, inside the directory pointed to by *static-directory*. Other middlewares are available, like logging, managing sessions or providing authentication features. Clack instead is an abstraction layer for the server that provides some parameters to customise it, for example, to quickly swap which server to use between development mode (hunchentoot) and production (woo).

(unless (null *server*)
    (restart-case (error "Server is already running.")
      (restart-server ()
        :report "Restart the server."
        (stop))))

In this portion of the code, I defined a restart action for the debugger. The Common Lisp debugger always has RETRY and ABORT actions for every exception raised. By declaring a restart-case, we are signalling an error and adding custom choices to the ones offered by default by the debugger. The new option I added is called restart-server and, if selected, it first (stop)s the server and then restarts the operation, so the function runs again without raising an error. It’s a smart way to interact with the REPL and improve the developer experience using the language directly.

More on conditions and restart here and here.

At the top of src/core.lisp I set the package definition and some initialisation function calls.

(in-package :cl-user)
(defpackage guestbook.core
  (:use :cl)
  (:import-from :guestbook.config
                :*static-directory*))
(in-package :guestbook.core)

(syntax:use-syntax :annot)

(syntax:use-syntax :annot), from the package cl-syntax-annot, allows us to use some special decoration notation at the top of the function. At the top of start and stop I added an @export tag, which tells the compiler that a function is exported by the package.

Configuration

I put the configuration parameters for the app into a config file; there are better ways, but they’re not necessary for a project this simple.

@export
(defparameter *application-root* 
  (asdf:system-source-directory :guestbook))
@export
(defparameter *static-directory* 
  (merge-pathnames #P"static/" *application-root*))
@export
(defparameter *template-directory* 
  (merge-pathnames #P"templates/" *application-root*))

@export
(defvar *config*
  `(:databases 
      ((:maindb :sqlite3 
        :database-name ,(namestring (merge-pathnames "guestbook.sqlite"
                                                     *application-root*))))
    :schema-file "db/schema.sql"))

The variable *config* needs a specific format to be used with cl-dbi, which is the library that I used to interface with the database. In a real application, it would be good to differentiate between dev and prod mode with different configurations used, for example to point to different databases or to use a different server with Clack.

Database

I created a new file in db/schema.sql and put the SQL code to create a message table.

CREATE TABLE message (
    id       INTEGER PRIMARY KEY AUTOINCREMENT,
    username VARCHAR(50) NOT NULL,
    ts       DATETIME NOT NULL,
    content  TEXT NOT NULL
);

Then I ran sqlite3 guestbook.sqlite --init db/schema.sql from the terminal to create and initialise a new database in the project root.

(in-package :cl-user)
(defpackage guestbook.db
  (:use :cl)
  (:import-from :guestbook.config
                :*config*
                :*application-root*))
(in-package :guestbook.db)

(syntax:use-syntax :annot)

(defun connection-settings (&optional (db :maindb))
  (cdr (assoc db (getf *config* :databases))))

@export
(defun db (&optional (db :maindb))
	"Returns a cached database connection for DB (defaults to :maindb). 
  Uses `connection-settings` and `dbi:connect-cached`. 
	
	Usage: (db) or (db :testdb)"
  (apply #'dbi:connect-cached (connection-settings db)))

@export
(defvar *connection* nil)

@export
(defmacro with-connection (conn &body body)
  "Executes BODY with *CONNECTION* dynamically bound to CONN.
CONN should be a database connection object, typically from `db`.

Usage: (with-connection (db :maindb)
         (dbi:do-sql *connection* \"SELECT * FROM users\"))"
  `(let ((*connection* ,conn))
     (unless *connection*
       (error "Database connection cannot be NIL"))
     ,@body))

This is the first macro of the project. It’s a simple wrapper that provides a new variable *connection* to use inside the body. It raises an error if the conn value that we passed is not initialised. The function db instead returns a valid connection, cached automatically by the library.

Then I defined some functions to perform CRUD operations on the database. format-timestamp converts a universal timestamp value into a readable date-time string.

(defun format-timestamp (universal-time)
  "Converts a universal time value into a human-readable timestamp string,
formatted as 'YYYY-MM-DD HH:MM:SS'."
  (multiple-value-bind (sec min hour day month year)
      (decode-universal-time universal-time)
    (format nil "~4,'0D-~2,'0D-~2,'0D ~2,'0D:~2,'0D:~2,'0D" year month day hour min sec)))

(defun add-message (name message)
  "Inserts a new message into the database with the given NAME and MESSAGE content."
  (with-connection (db)
    (let ((sql "INSERT INTO message (username, ts, content) VALUES (?, ?, ?)")
          (ts (get-universal-time)))
      (dbi:do-sql *connection* sql (list name ts message)))))


(defun delete-message (id)
  "Deletes the message with the given ID from the database."
  (with-connection (db)
    (let ((sql "DELETE FROM message WHERE id = ?"))
      (dbi:do-sql *connection* sql (list id)))))


(defun get-all-messages ()
  "Retrieves all messages from the database, ordered by timestamp descending.
Timestamps are formatted as human-readable strings."
  (with-connection (db)
    (let* ((sql "SELECT * FROM message ORDER BY ts DESC")
           (messages (dbi:fetch-all
                      (dbi:execute
                       (dbi:prepare *connection* sql)))))
      (mapcar (lambda (row)
                (setf (getf row :|ts|) (format-timestamp (getf row :|ts|)))
                row)
              messages))))

The Web App

Finally we can create the web application which I put inside src/web.lisp. It’s a bit longer then the other files so I will break it into chunks.

(in-package :cl-user)
(defpackage guestbook.web
  (:use :cl
        :caveman2)
  (:import-from :guestbook.config
                :*template-directory*)
  (:import-from :guestbook.db
                :add-message
                :delete-message
                :get-all-messages)
  (:export :*web*))
(in-package :guestbook.web)

(defclass <web> (<app>) ())
(defvar *web* (make-instance '<web>))
(clear-routing-rules *web*)

The web framework I am using is called Caveman, developed by Eitaro Fukamachi, who is a very prolific lisper and the author of multiple libraries that I am using, including Lack, Clack, and cl-dbi, all having great integration with each other. <app> is a class defined by the web framework, and I am extending it and instantiating it in *web*. clear-routing-rules is a function inherited from Ningle, another web framework, which clears the route associations inside the web app instance.

Templates

Our web app needs to render some static templates with data, and to do that there’s a great library called djula, which allows us to use most of the same tags and filters that Django exposes in its template engine.

I’m not going to include the templates source here for space reasons, in the repository they're in the templates/ folder.

(djula:add-template-directory *template-directory*)

(defun render (template-path &optional env)
  "Renders a Djula template from TEMPLATE-PATH.
ENV is an optional plist of variables passed to the template."
  (apply #'djula:render-template*
         (djula:compile-template* (princ-to-string template-path))
         nil
         env))

The first function call tells djula where to find the templates in the project. render is a function that receives a template path as a parameter and compiles the template for better performance.

Routes

To allow users to perform CRUD operations, we need to expose a few routes to be called by the web frontend. There are two ways to define routes in Caveman, but this one seems a bit clearer to me than using annotations. defroute is a macro that receives the route path, some parameters like :method and eventually some arguments, and then defines the body to handle the request. Inside the body, we can access the request object via *request* and extract data from it using, for example, the function request-body-parameters.

The routes are self-descriptive. / renders index.html, passing all the messages from the db; /message handles POST requests and inserts the message in the database if the parameters conform; and /message/delete deletes a message.

(defroute "/" ()
  (render #P"index.html"
          (list :messages (get-all-messages))))


(defroute ("/message" :method :POST) ()
  (let* ((body-params (request-body-parameters *request*))
         (name-param (assoc "name" body-params :test #'string=))
         (message-param (assoc "message" body-params :test #'string=)))
    (if (and (consp name-param) (consp message-param))
      (add-message (cdr name-param)
                   (cdr message-param))
      (format t "Missing body parameters: received ~A~%" body-params)))
  (redirect "/"))


(defroute ("/message/delete" :method :POST) ()
  (let* ((body-params (request-body-parameters *request*))
         (id-param (assoc "id" body-params :test #'string=)))
    (if (consp id-param)
        (let ((id (ignore-errors (parse-integer (cdr id-param)))))
          (when id
            (delete-message id)))
        (format t "Missing id parameter.")))
  (redirect "/"))

I also added another function, which defines a method on the web app class. on-exception is a generic function called when an exception occurs in the web application. This method is specific on the parameter type, since it will run only if the exception has code 404 — not found — and in that case I return a specific custom template.

(defmethod on-exception ((app <web>) (code (eql 404)))
  (declare (ignore app code))
  (render #P"404.html"))

Run the demo

Now I can load the project into the environment with Quicklisp.

> (ql:quickload :guestbook)
To load "guestbook":
  Load 1 ASDF system:
    guestbook
; Loading "guestbook"
......................
(:GUESTBOOK)
CL-USER>

Then I can start the server and point my browser to 127.0.0.1:3210.

> (guestbook.core:start)
Hunchentoot server is started.
Listening on 127.0.0.1:3210.
Server started

I can send messages that get saved with a timestamp and then delete them. Pretty simple.

Reducing boilerplate

Lisp became popular for a series of reasons, and one of the most cited is its ability to reduce boilerplate thanks to the metaprogramming capabilities of the language. Lisp hackers are proud of being able to code solutions faster and do exploratory programming, reducing the size of the code they need to write to reach a solution.

When comparing the lines-of-code count of my Common Lisp guestbook against the Python-Flask version, the latter seems quicker and simpler to write — 36 lines of Python vs. 229 of Lisp. Lisp’s strength is its ability to model itself according to the problem the developer is solving. In this case, I am dealing with a simple guestbook demo, so it may not be strictly necessary, but to present the language better I will try to reduce the size of the program by hiding some code and configuration.

First, let’s have a look at the new guestbook app, written in my new custom web framework called flashcl: 29 LOC, properly formatted and stripped of all comments, and not too hard to read.

(in-package :cl-user)
(defpackage guestbook.core
  (:use :cl :flashcl))
(in-package :guestbook.core)

(init-flashcl :sqlite3 "guestbook.sqlite")

(defmodel message
  ((username :col-type (:varchar 50) :accessor message-username)
   (content  :col-type  :text        :accessor message-content)))

(defroute "/" ()
  (render #P"index.html" (list :messages (db-all 'message))))

(defroute ("/message" :method :POST) ()
  (let ((name (form-param "name"))
        (message (form-param "message")))
    (if (and name message (> (length name) 0) (> (length message) 0))
      (db-add (make-instance 'message :username name :content message))
      (format t "Missing body parameters: received ~A~%" (body-params))))
  (redirect "/"))

(defroute ("/message/delete/:id" :method :POST) (&key id)
  (if id
    (let ((id (ignore-errors (parse-integer id))))
      (when id
        (db-delete (db-find 'message id)))
      (format t "Missing id parameter.")))
  (redirect "/"))

Where did start go? It is now part of the flashcl framework, so it’s imported in the package. Here’s the usage reference.

;; --- Run the Application ---
;; Call run-app function from your REPL or add it here to run on load.
;; Call stop-app to stop the server.
;;
;; Example: (guestook::run-app) or just (run-app) inside the package.
;; (run-app :port 5000 :server :hunchentoot)

Then I slightly modified the template delete button to point to the correct route with the id parameter.

I'm going to show just some the new code that I added to write flashcl. I mostly merged the old code in a new file trying to make it as reusable as I could for other web projects, since it's possible to define new database models and routes quickly, with support for static files and templates. I used mito, another library from Eitaro Fukamachi, which is an ORM that works well with SQLite.

First I imported the library and exported only what’s needed by the user.

(defpackage :flashcl
  (:use #:cl)
  (:import-from #:caveman2
                #:defroute
                #:redirect
                #:*request*
                #:*response*)
  (:import-from #:lack.request
                #:request-parameters)
  (:import-from #:mito
                #:dao-table-class ; Re-export metaclass for use in defmodel
                #:connect-toplevel
                #:ensure-table-exists
                #:select-dao
                #:find-dao
                #:delete-dao
                #:insert-dao)
  (:export ;; Setup
          #:init-flashcl
          ;; App Definition
          #:flashcl-app ;; Variable holding the app instance
          #:defmodel
          ;; Routing & Request/Response
          #:defroute
          #:form-param
          #:render ;; Re-export caveman's render (or wrap it)
          #:redirect ;; Re-export caveman's redirect
          ;; Database
          #:db-all
          #:db-add
          #:db-find
          #:db-delete
          #:dao-table-class ;; Re-export metaclass
          ;; Running
          #:run-app
          #:stop-app))

Then I wrote an initialisation function similar to Flask’s, which sets various variables and creates a new instance of the Caveman webapp.

(defun init-flashcl (db-type db-path &optional (template-dir "templates")
                                               (static-dir "static"))
  "Initializes Flashcl environment. Sets DB/Template paths, connects DB."
  (setf *database-path* (get-absolute-path db-path))
  (setf *static-directory* (get-absolute-path static-dir))

  ;; Set Djula's template directory
  (djula:add-template-directory (get-absolute-path template-dir))
  (format t "Set template directory as ~A~%" (get-absolute-path template-dir))

  ;; Connect to SQLite database
  (handler-case (connect-toplevel db-type :database-name *database-path*)
    (error (c)
      (format *error-output* "~&Error connecting to database ~A: ~A~%" *database-path* c)))

  ;; Define the Caveman2 app instance here
  (setf flashcl-app (make-instance 'caveman2:<app>)))

To make it easy to define a new database model for the application, hiding the mito library, I created a macro that ensures the table gets created correctly. mito automatically adds a few fields to the table definition, like id and created_at or updated_at, so we don't have to worry about them.

(defmacro defmodel (name slots &rest options)
  "Defines a Mito DAO class and ensures its table exists.
   Example: (flashcl:defmodel comment
              ((name :col-type (:varchar 20))
               (comment :col-type :text)))"
  (let ((class-options options)
        (table-name (string-downcase name))) ; Use singular name by default
    
    ;; Add table name inference if not present
    (unless (find :table-name options :key #'car)
      (push `(:table-name ,table-name) class-options))

    `(progn
      (defclass ,name ()
        ,slots
        (:metaclass mito:dao-table-class)
        ,@class-options)
      ;; Ensure table exists after class definition
      ;; Note: This runs at compile/load time when defmodel is processed.
      ;; Ensure DB is connected before loading code using defmodel.
      (handler-case (ensure-table-exists ',name)
        (error (c)
          (format *error-output* "~&Warning: Could not ensure table for ~A (DB might not be connected yet?): ~A~%" ',name c)))
      ;; Return the class name
      ',name)))

Then I added some database helpers to perform a few CRUD actions on the db.

(defun db-all (class-name)
  "Selects all records for the given model class."
  (select-dao class-name))

(defun db-find (class-name id)
  "Finds a model instance by ID."
  (find-dao class-name :id id))

(defun db-add (instance)
  "Inserts a model instance into the database."
  (insert-dao instance))

(defun db-delete (instance)
  "Deletes a model instance from the database."
  (delete-dao instance))

Conclusions

To recap, in this tutorial I used some of the latest libraries in Common Lisp to create a simple guestbook webapp. Then I wrote a simple reusable wrapper to make our code more concise, aiming to challenge the Flask framework in Python. The full source code of the two versions it's here and here.

Ultimately I would like to give my opinion on using Common Lisp to write a web server. Common Lisp shines when dealing with low-level tasks like small systems programming or performing intensive computation at scale. When these complex systems need to communicate with the outside world, perhaps via an API, writing a server is the correct way and Common Lisp is capable of delivering that.

But despite the fact that the language is easily adaptable and comes with performant server libraries (Hunchentoot and Woo), I would say that there are better alternatives for developing generic modern web apps. Hot reloading is now a feature present in many web frameworks, and Common Lisp is not really shining for being ergonomic, nor does it come with many built-ins. Clojure, by contrast, is a modern Lisp dialect with great web frameworks, nice documentation and tons of stable libraries. I would definitely choose the latter for a fresh web project, since with CL I get the feeling that I would end up having to write more code than I should to add custom features and middlewares.

I would like to give a shout-out to Alive, which is the only Common Lisp extension for VSCode that implements the REPL with features similar to what SLIME and SLY bring to Emacs. The extension is still under development and not yet a full replacement for Emacs, especially during debugging, but it has great features and a lot of potential to introduce Common Lisp to newcomers, thanks to the VSCode web interface.

Feel free to email me if you have any questions, recommendations, or even complaints.

Le parole di Nabokov

Tue, 11 Mar 2025 00:00:00 GMT

La mia opinione è che Nabokov non lo si legge per la trama. Ogni suo lavoro è una produzione artistica, uno studio meticoloso della prosa che lascia che i lettori sensibili all’estetica, ammaliati dal ritmo della sua scrittura. Nabokov sfida il lettore spingendolo al limite della sua conoscenza semantica, portando vocaboli poco comuni fuori dal loro contesto, trasformando il testo in un gioco stilistico che affascina ma, che al tempo stesso, scatena un complesso d’inferiorità, quando ci si rende conto che una qualità del genere è quantomeno ineguagliabile.

Avendo di recente riletto il suo capolavoro Lolita (ne ho anche scritto una recensione) mi sono appuntato le parole di cui non conoscevo il significato, o di cui non ero del tutto certo, e ho deciso di riportarle in questo articolo con una breve definizione. L’invito a leggere Nabokov è sottinteso.

Per conoscere e capire l’uomo dietro l’elegante scandalo che fu il romanzo, ho guardato How do you solve a problem like Lolita? — in italiano, come si risolve un problema come Lolita? —, un documentario prodotto dalla BBC riguardo al libro. Nabokov nacque in una facoltosa famiglia della nobiltà russa, cosa che gli permise di vivere in condizioni privilegiate durante la giovinezza, e grazie alla quale ottenne accesso alla cultura internazionale. Imparò il francese e l’inglese — si dice abbia iniziato a leggere e scrivere in inglese prima che in russo —, e si dedicò a riempire quaderni di poesie romantiche durante l’adolescenza. Con la rivoluzione russa, l’intera famiglia fu costretta a scappare e Nabokov decise di trasferisci a Cambridge per studiare letteratura francese al Trinity College. Successivamente seguì il padre a Berlino, dove divenne famoso tra gli emigrati russi come scrittore e poeta, nonostante alcune difficoltà economiche. Con l’aumentare dell’antisemitismo in Germania precedente allo scoppio della guerra, decise di trasferirsi con la moglie Vera a Parigi, per poi qualche anno più tardi muoversi negli Stati Uniti, a Manhattan, avendo ottenuto un ruolo come entomologo al museo di storia naturale di New York. L’anno dopo divenne professore di letteratura e girò diversi college americani finendo la sua carriera alla Cornell University, dov’è alcune sue brillanti lezioni vennero raccolte in dei libri, il più famoso dei quali è Lezioni di letteratura. Le opere che composte negli Stati Uniti, tutte scritte in inglese, lo resero celebre a livello internazionale. Le più famose; Lolita, Fuoco pallido e Pnin.

Oltre a essere un professore poliglotta, e un autore di talento, Nabokov era un appassionato di farfalle. Studiò e catalogò diverse specie, scrisse articoli per addetti ai lavori, e finì addirittura per curare una collezione di lepidotteri presso il Museo di Zoologia Comparata dell’Università di Harvard. Nel documentario hanno intervistato un responsabile del museo che ha confermato come Nabokov non fosse un appassionato alle prime armi, ma un preciso catalogatore di specie di farfalle. Egli, fece diversi viaggi nel mondo dedicandosi alla ricerca di specie rare, e creò una serie di illustrazioni delle farfalle che studiava. Cos’hanno in comune le farfalle e la scrittura? In apparenza nulla. Ma se pensiamo allo studio minuzioso dei particolari che hanno in comune le due attività, capiamo che dedizione e precisione sono requisiti essenziali per entrambe. Che il minuzioso studio dei colori dei lepidotteri possa aver contribuito alla precisa scelta delle parole e del tono nelle sue storie? Non lo sappiamo con certezza. Ciò di cui abbiamo invece testimonianza grazie ad alcune interviste è che gli anni passati da Nabokov come entomologo ad Harvard siano stati tra i migliori della sua vita.

Tra le due passioni, quella che noi comuni lettori possiamo apprezzare è la scrittura, nell’eleganza della sua prosa, nel ritmo musicale e cadenzato, nella scelta accurata di ogni vocabolo. Il protagonista di Lolita è un professore di letteratura francese in America — coincidenze? — con cattive intenzioni, ma di farfalle alate nel romanzo nemmeno l’ombra.

Ecco la lista delle parole per me difficili trovate in Lolita.

Chaperon: Donna, per lo più anziana, che un tempo accompagnava una giovane nubile di buona famiglia ai ricevimenti e nei viaggi, per salvaguardarne la rispettabilità.

Marleniforme: A forma rotonda e bombata, simile a una mela Marlene, tipica del Sud-Tirolo.

“D’un tratto la mano di Lo scivolò nella mia, e all’insaputa del nostro chaperon io strinsi e accarezzai e avvinghiai quella zampetta ardente per tutto il tragitto. Le pinne del naso marleniforme della guidatrice erano lucide, avendo perduto o consumato la loro razione di cipria…”

Bistrate: Tinte, oscurate, scurite con il bistro, uba polvere colorante naturale bruno-scura, costituita da idrato di manganese, usata nei colori a olio o ad acquerello.

Chador: Lungo velo nero, indossato dalle donne islamiche conformemente alla tradizione religiosa. Parola di origine persiana.

Voluttà: Il piacere intenso e predominante che si prova nella soddisfazione degli impulsi e dei desideri sessuali

Eclettico: Chi, nell’arte o nella scienza, non segue un determinato sistema o indirizzo, ma sceglie e armonizza i principi che ritiene migliori.

Reptazione: Modo di locomozione caratteristico di molti animali, sia invertebrati che vertebrati (in molti rettili, in particolare i serpenti), per cui il corpo striscia sul suolo e non è sollevato sugli arti, che mancano o sono rudimentali.

Gibboso: Che porta una gobba.

Cicaleccio: Il cicalare di più persone insieme; chiacchierio frivolo.

Solipsizzata: Immersa in una visione solipsistica, isolata nella propria soggettività, come se tutto il resto fosse irrilevante o inaccessibile.

Abbarbicato: Radicato saldamente.

Preprandiale: Che precede il pranzo.

“Io non progettavo di sposare la povera Charlotte per poi eliminarla in un modo volgare, ripugnante e pericoloso, come metterle cinque compresse di bicloruro di mercurio nello sherry preprandiale o qualcosa del genere…”

Farmacopeico: Che si riferisce alla farmacopea, ovvero l'insieme ufficiale di norme riguardanti la preparazione, il controllo e l’uso dei farmaci.

Nevralgica: Pervasa da un malessere acuto, come il dolore lungo il decorso di un nervo.

Blusa: Camiciotto di tela usato dagli operai e dai pittori durante il lavoro.

Canuto: Dai capelli bianchi.

Rotocalco: Periodico, rivista.

Scriminatura: La linea che segna la spartizione dei capelli.

Serica: Di seta, simile alla seta o legato alla seta.

Mefitici: Che hanno odore fetido, irrespirabile, malsano.

Smargiasseria: Chi si vanta di qualità che non ha e di poter fare cose di cui non è capace.

Enfia: Rigonfia, tumefatta.

Berciava: Urlava sguaiatamente.

Nerboruto: Muscoloso, vigoroso, robusto.

Umbratile: Ombreggiato, ombroso.

Incartapecorita: Che ha assunto, per decrepitezza, aspetto e consistenza paragonabile alla cartapecora; raggrinzito, rugoso.

Muliebre: Della donna, relativo alla donna, con riferimento alle sue qualità, alla dignità del suo ruolo.

Esecrabili: Meritevoli di condanna.

Bilioso: Pieno di bile, e per estensione irritabile, collerico.

Azzimato: Adornato, abbellito con molta cura.

Dedalogia: Lo studio e alla teoria dei labirinti o delle strutture complesse e intricate.

Logomanzia: Pratica divinatoria che si basa sull'interpretazione di parole, frasi o suoni per prevedere il futuro o ottenere risposte

“Aveva letto molto. Sapeva il francese. Era versato in dedalogia e logomanzia.”

Ondinista: Chi crede o pratica la culto delle ondine, figure mitologiche legate all'acqua, spesso rappresentate come spiriti o divinità acquatiche simili a ninfe.