a layered lisp

lisp in the small is always beautiful. it's almost like poetry and the language seems made for the problem.

i've seen glimpses of that again and again. µKanren, core.logic, core.typed, carefully crafted blog posts about lisp, paul grahams posts and even books about compilers for languages like haskell.

at it's core, these things are very simple. but lambda by lambda, abstraction by abstraction and layer by layer something truly beautiful is built.

the parts fit together well. no, not well, as if they're made for each other.

you see it when you explore scheme. when you begin to understand what clojure might be about. when understand those few lines that say so much.

but where are the systems where everything is like this? do they exist, are they possible?

a layered lisp where we start with lambda, gain a let, possibly macros and then go on defining relational logic, build up comprehensive libraries to make up something resembling clojure, but without those dark secrets inside.

why are there three or more compilers for clojure? why not one with many possible backends? why not nanopasses, tiny functions that when composed make up this bigger thing, this complex idea that only dawns on you after you've almost surrendered and then with joy discovered that there is so much more?

where is the system that is both math and a real programming language at once, but still built from those tiny pieces, bit by bit?

do they exist?

most likely. scattered little beauties, all over our minds and dreams and research papers. some even make it into this practical world, where we forget where they came from.

but i believe they exist. i've seen glimpses, here and there. small pieces that my dreams put together.

i can't quite make out if i'll ever see them come together, but i really really hope so. not just because they are so beautiful and simple and so different, but also because i think that if they meet they will change the way we think about what we do. they will change what we are able to do.

because that's what we're after, i think. to extend our senses, to be able to do more than we could normally do.

now? maybe try reading sicp again, or htdp, or the nanopass paper, or continue implementing a scheme or just dreaming.

piece by piece, assembling them almost randomly, but they still fit together somehow, because at some level they build on the same beautiful layer, so many steps down.

a layered lisp.

i want to see more of it.