The art of the metaobject protocol

What Hacker News says

1. NelsonMinarMay 2025
   Declarative languages are fun. Prolog is the iconic one. You may be more familiar with Make.

   For OO, every serious software engineer should read The Art of the Metaobject Protocol sometime in their lives.

   thread
2. Phiwise_Sep 2024
   By analogy, programmers like LISP over other syntax for the same reason that creative children like LEGO over other toys. It's not that the pieces in the box are more beautiful than any other individual example of molded plastic, but because they are purpose-built to be the maximizing mold such that a box full of them gives more flexibility and potential than a box of any other shape you might choose. Lisp syntax is the way it is to create a human-machine interface with as much similarity between the two sides as possible, so the human approaches machine power when you write code, and the machine approaches human reasonability when you inspect running code.

   For examples, McCarthy's original purpose was to demonstrate the effectiveness of a symbolic differentiation process he had dreamt up, so he devised the syntax and meta-circular evaluator of lisp to make it maximally obvious from the program text that the differentiation system was mathematically correct, while keeping it maximally obvious from the program model definition that it was computationally concrete. In response to new trends in the programming field, Lispers write mind-bending books like "Let over Lambda", "The Art of the Metaobject Protocol", or "Software Design for Flexibility" to show that, when your syntax and model is right, you can radically change how you solve problems not by rewriting your spec or switching languages but by just adding more lisp to the lisp you already have, which has the same simplicity as radically increasing the sculptures a child can make by just adding more lego to the lego they already have.

   Lisps, on the other hand, tend to add features as just more convenient versions of things they can already do: Macrology for self-adapting code? Just lisp functions on lisp data structures corresponding to lisp functions. Actors for a concurrent execution model? Lisp functions as lisp data parameterized by higher-order lisp functions. Composable continuations for error handling? A lisp function exploring a lisp data structure of lisp data structures of lisp functions. It's turtles all the way down. Paul Graham points out that you can understand the social hype the presence or absence of a feature like operator overloading as a consequence of friction-ful syntaxes, while lispers care much less because replacing a function you don't prefer with one you do for your use case is straightforward in a friction-free syntax. When he decided to build a reddit clone for tech entrepreneurs he didn't need an outside data system just to get started, he only had to spin up a pool of threads for sessions to directly modify s-expression literals in memory, which he could save or modify by printing straight to disk and load by just reading the lisp syntax back into memory like all lisp code is, with no execution intermediary like languages such as the Pythons tend to have complicating things enough to make comparatively big services like a whole database for a private gossip forum worth the effort. The syntax doesn't make lisp first-order beautiful, it makes lisp the hacker's local maximum, which is second-order beautiful, and honestly isn't much harder to get into the habit of reading once you know it's worth it.

   Show morethread
3. igouyMay 2024
   Here's Alan Kay lavishing praise

   minute 54 https://www.youtube.com/watch?v=oKg1hTOQXoY&t=634s

   on "The Art of the Metaobject Protocol"

   https://www.adamtornhill.com/reviews/amop.htm

   thread
4. galdorAug 2023
   For anyone finding CLOS interesting, "The Art of the Metaobject Protocol" is the next logical step. A good way to dig deep into how CLOS is built.

   It should be a mandatory read for anyone looking to design a programming language with object concepts.

   thread
5. dalyJun 2023
   Lisp in Small Pieces

   The Art of the Metaobject Protocol

   thread
6. dalyNov 2022
   I can highly recommend this talk by Gerald Sussman:

   Programming is (should be) fun. ( https://www.youtube.com/watch?v=2MYzvQ1v8Ww&ab_channel=ACMSIGPLAN )

   I've been programming for 52 years. I still program, basically because it IS fun. That said, it is only fun if you have an VERY high tolerance for frustration. Programs, like art, are only finished when you stop working on them. Literate programs have raised the bar for Pulizer-worthy programs.

   Knuth, in Salon interview (https://www.salon.com/1999/09/16/knuth/), said

   ...Besides demonstrating the techniques of clear, efficient coding, Knuth has sought to bring a deeper sense of aesthetics to the discipline. "You try to consider that the program is an essay, a work of literature," he says. "I'm hoping someday that the Pulitzer Prize committee will agree." Prizes would be handed out for "best-written program," he says, only half-joking. ...

   There are a few programming books I've re-read a few times, just for the joy of it, which is the essence of quality literature. These are:

   Lisp In Small Pieces by Christian Queinnec. I believe this is the best programming book ever written.

   The Art of the Metaobject Protocol by Gregor Kiczales and Jim des Rivieres. This is mind-expanding.

   Let Over Lambda by Doug Hoyte. This is the very foundation of programming.

   Every time I re-read these books I find more understanding and great intellectual pleasure. If there ever was a prize for the literature in the field of programming, these are my candidates.

   If you have a potential candidate, please add it in the comments.

   Show morethread