What is a “convivial” tool? What a strange term! Ivan Illich coined this usage in his book Tools for conviviality in which he says

After many doubts, and against the advice of friends whom I respect, I have chosen “convivial” as a technical term to designate a modern society of responsibly limited tools.

and then adds

I am aware that in English “convivial” now seeks the company of tipsy jollyness, which is distinct from that indicated by the OED and opposite to the austere meaning of modern “eutrapelia,” which I intend. By applying the term “convivial” to tools rather than to people, I hope to forestall confusion.

Does that help? Probably not.

The idea is basically this: unless the people making things have complete control over the tools that they use, personal freedom and personal relatedness are impossible. A tool that has this malleable quality – and by extension, a society using those tools – he calls convivial.

I came across the book quite by accident. In 1988 I quit, in disgust, my job at Microsoft, and went to Europe. When I returned to North America I stayed with a Canadian friend, at his parents’ house. His mom had a copy. (I wonder why – I should ask her.) I read it, enraptured.

It forever changed my life. Since then I have not been able to see technology except through its lens. This made me a dour critic of technology; it prevented me from getting excited about things that excite others; it even, perhaps, prevented me from having a “career” in technology. I was (and am!) deeply, and almost unconsciously, philosophically opposed to most aspects and artifacts of technology. I went apostate. I read lots of books, most of them written in 1973. Everything pointed to real food (ie, organic, grown from heirloom seed), to craft, to livable (walking) cities, to human scale. I rode my bicycle everywhere. I felt that technology was the enemy of everything I found myself caring about.

Some time in 1990 (I think it was) an odd conjunction occurred. I visited a family friend and talked about Forth – he wanted to make his own fuel-injection computer. Returning to Seattle, I read everything I could find about Forth. The Engineering library at the University of Washington has a lot: copies of the Caltech manual; the FORML (Forth modification lab) proceedings; copies of Forth Dimensions (the Forth Interest Group’s ex-magazine).

I had known about Forth since I was sixteen; but I hadn’t plumbed its depths until that week. I made up a packet of articles and hand-written notes and sent it off.

Shortly thereafter I ran into Trimpin, a local artist. I had seen a performance of a work of his – Circumference – at Bumbershoot (a big arts festival in Seattle) a year or two before. This performance involved a roomful of percussion – drums, timpani, garbage cans – all played by “robot hands”. Each instrument had a drumstick poised over it, attached to a solenoid, which was attached via a homemade interface to Trimpin’s computer. Using MIDI and MIDI sequencing software (Performer) he controlled this roomful of instruments. It was breathtaking.

His studio was in my neighborhood, and one day I met him on the street, getting an espresso – remember, this was Seattle!

We fell into a collaboration and I was able to realize two dreams: to use Forth, and to program the Motorola 6809, a processor I had been fascinated by since reading about it in Byte magazine in the late 1970s. I wrote a Forth development system, based on a terrible “object-oriented” Forth for the Macintosh. In a few days’ time I was able to write an assembler for the 6809, a Forth cross-compiler, and a simple “chat” protocol that allowed me to type commands on the host machine (the Mac) that were executed on the target (a small 6809-based embedded computer). All this was possible because of the simplicity and transparency of Forth.

I enjoyed this process tremendously. I felt empowered. I had never enjoyed programming in C this much. I went back to the library to figure out why Forth was so much fun, and discovered ... but’s that another story. ;-) Someday I’ll write about tripping over lambda.

Over the next ten years we collaborated on a series of projects. These were mostly handmade, idiosyncratic – and often musical – kinetic sculptures. Trimpin would collect modern industrial “junk” parts, and piece together a contraption; I would program it, always in Forth. I enjoyed aspects of this collaboration immensely. I worked in his studio – an appealing environment, much more Gepetto’s workshop than high-tech office. I was combining technology and art. I was able to try out new (for me) ideas. I wrote a multitasker. I wrote code to generate and consume MIDI. I wrote an aleatoric music generator.

The largest program I wrote – which sequenced a forty-foot-tall sculpture consisting of four octaves of marimbas, xylophones, and wooden milk bottles, and composed simple musical sequences on the fly – consumed 6k of object code. (This is a permanent installation in the lobby of the Science Museum of Minnesota, in Saint Paul.)

Forth impressed me. It liberated and empowered me. It was a small tool – one that I could understand deeply and entirely. I could make it entirely my own and I have. I have written several Forths – two for the PC, and three for “target” machines: 6809, embedded 8086, and ARM.

Why is this interesting? Because I realize, looking back, that Forth is a convivial tool. I didn’t know that going in; I wasn’t sure, at the time, of the source of my sense of joyful liberation; but now I am sure that that is the reason.

Fast-forward to the present. After “looking in on it” several times over the last few years, I have finally taken the plunge and really dug into the Lua programming language, and I love it. I haven’t programmed much in it yet, but the bit I have done I have enjoyed immensely. I’m having the same feelings about Lua that I had about Forth. Is there a similar explanation? I think there is.

Lua is small – its implementation is about 16000 lines of C code – very modest for a “modern” program. This is about six times the size of my latest Forth (also written in C), which I wanted to be as small as possible. So Lua is only six times bigger than the smallest Forth I was able to write in C.

Lua, like Forth, has a few deep ideas that, once mastered, open infinite possibilities. Like Forth, it was designed to be extensible. Lua is well-documented, well-written, and has a simple C API, so it can be easily “glued” to other programs.

Lua is, by design and intention, a malleable tool, of such modest scope that it is possible for someone, investing a few weeks of study, to learn the system so thoroughly as to “call it their own”. At this point Lua too becomes a convivial tool.

I am excited about Lua in a way that I have not been about Python, OCaml, or Haskell – three languages that intellectually and philosophically interest me. I have been confused by this sudden passion (about Lua), and wondered at its source. This idea of conviviality is so familiar to me, so ingrained, so unconscious, that I don’t consider it any more. But it rules my (technological) passions, even when I don’t recognize it.

Somehow, last night I was able to step back and see the answer, in Lua’s conviviality.