I disagree, with Lisp you have metaprogramming exercises under every book, be CACS, SICP or the ones for S9 (s9fes Scheme) from Nils.

That for Scheme; under Common Lisp loop it's hell and, well, on PAIP you implement a Scheme Lisp interpreter.

Heck, on Scheme you need to understand eval and apply and how do they operate recursively.

More? Both Scheme and CL have books exercises on implementing a mini-Prolog.

On Forth: immediate. You have a raw Forth core, implement do...loop and if, then, else. Have fun.

Really? The Lisp reader is much simpler than the parser of a language like C. You can get away with basically a tree-walking interpreter though every time I write something like that I have to nail down details involving quote, eval and all that.

I really enjoyed the beginning of Graham's On Lisp but walked away disappointed from the end in that he avoided any really difficult metaprogramming problems, most of the time when he's using macros it is for performance, usually he has an example that uses plain function pointers. Except for the continuation example you can work his examples in Python [1] including the query language and the mini-Prolog [2], but Python already has yield, async, await, etc.

If you like S-expressions you can go to town building out classes full of static methods in Java that let you write things like

   Variable<Integer> v = variable("v");
   Expression<Integer> x = add(literal(75),v));
   v.set(110);
   eval(x);

Sure Lisp doesn't make you write all the functions and classes to represent that, but the Java version is typed and can make the autocomplete in your IDE sing [3]

Forth is something special. The idea that words have a compile-time and run-time meaning is brilliant and lets you make a programming language without a lot of CS knowledge. I wrote one in high school for my TRS-80 Color Computer Computer.

I'd say though the metaprogramming techniques in On Lisp and other Lisp books are about the continental shelf but the dragon book is about the ocean.

[1] It's not quite the same as the mini-CLOS he works but I've developed so many metaobject facilities for Python using metaclasses, annotations, magic methods, etc.

[2] See the Jena rules engine for a really beautiful (would be pedagogical if it had a few more comments) implementation in Java of something Prolog-adjacent which is capable of both forwards and backwards chaining. The genius of Prolog is that it's simple to implement and with WAM faster than you would think possible even if it looks like it fell off a UFO. Try to write a lot of it though and the various methods for doing imperative programming in it look less clever than awkward, so the interesting developments are pure like Datalog.

[3] With some annoyance thanks to type erasure, you can't override a function to take an Expression<String> or an Expression<Int>, you have to unerase the types by putting them in the function names or something like that.

Forth it's easy, but Lisp the core implementation can be easy, yes, but you need to implement Lisp in Lisp, similar to Forth under itself.

Heck, I tested for...next from Eforth under PFE Forth with Forth words, not C. Forth may be the only good case for an easy syntax.

I mean, the Lisp syntax it's dumb easy too but you need to develop the rest of features. Is not just about lists, car and cdr. Altough if you get eval/apply the rest writes itself, such as map and proc.