Obviously, only the wolves that survive.

Here's an example of something difficult to do in Python. lazy, stateless and minimize are custom macros.

(lazy
  (stateless x float)
  (stateless y (* x x))
  (minimize y) // nothing has been calculated yet
  (print y) // 0.0 ― this is where the first calculation occurs
  (print y) // 0.0 ― the second evaluation of y just reads from the cache
  (print x)) // 0.0 ― this is read from the cache too

The stateless macro caches results locally, backs up everything to a remote server in a background process and reads from the remote cache whenever possible.

And I would like to know where you learned that sort of meta-programming.

Any decent Lisp book will cover how to write a macro. The real challenge is knowing what to write, not how to write it.

I know of no good books on this subject. In my experience, you have to understand what it's like to use many different software paradigms and how they are implemented. Then you can just steal their most relevant features as you need them. This particular system took inspiration from Haskell, R and applied mathematics. Under the hood, it makes heavy use of syntax trees, hash-based lookups, lazy evaluation and Bayesian optimization.

How to practice meta-programming commercially is an even harder question. Most companies don't use a meta-enough language like Lisp and those which do may not need meta-software at all. The only place I can think of where this has net positive commercial value would is a tiny startup working on a very hard problem. Small data comes to mind, but not much else.