>It is very possible and practical to parse conventional languages down to an AST tree, work on the tree, and run that code.
Yes, of course.
>Sometimes I wonder if the LISP cult is just trying to pretend Noam Chomsky was never born.
Life is great at our cult, you see?
Now, seriously, what you propose is to transforme "conventional language" (say, Java) to AST, work on it, and then spit out conventional language again. This is fine.
The problem is that in those cases, when you write a "macro" (an AST->AST function), you then need to learn:
* the semantics and structure of the AST
* all the functions/methods/classes your Conventional Language tells you to use for manipulating the AST
The point of Lisp is that you are writing the code in what is an AST as well.
And this AST is written as Lisp lists.
And Lisp is very good at manipulating lists, it has a ton of built-in functions for them.
And thus, for writing the AST->AST function ("macro"), you don't need to learn anything new, if you already know Lisp.
An additional bonus is that your macros are mostly clear, easy to read. Because they are written in a mostly similar way to the rest of your code.
Another bonus is that Lisp was created with AST->AST transformation in mind from the ground up. Macros work almost transparently; you can specify them to work on read-time or on compile-time. They can also work at run-time if necessary. You can do AST->AST at runtime and have the Lisp implementation compile it to machine language at runtime.
This isn't so easy (or practical) to do with conventional languages...