But even if that isn't in the cards (and it isn't for most of us, for all sorts of reasons), there's still a whole lot of value in learning the language enough to go through and make a few things from scratch.
I tend to agree with ESR on the subject: "LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot." (http://www.catb.org/esr/faqs/hacker-howto.html)
If you're willing to trade complete purity away, try Ruby. It's basically everything you want from Lisp without the mess. Give up purity, get comprehensibility.
Blocks are a really great way of doing things. You can even investigate the block source code as a string if you really want to.
Dynamic method definition is well supported and predictable. Data structures are easy to compose and operate on. It's basically all the power but in a more comprehensible way. There's a reason why Rails came out of Ruby. It's naturally powerful.
You might as well say functions are bad because without reading the source code for the function you don't know what the function does.
A macro that looks like one thing but does something else is a bad macro. We don't throw away functions just because someone can write a function named "sort" that actually randomizes it's argument rather than sorting
This wouldn't be a problem if those surprises were rare and clearly marked, but the entire reason for macros to exist is to carry the surprises. As a consequence, having macros as the default (ok, second choice, not much better) tool of your language is bad. It's not that macros are bad by themselves, but they shouldn't be used often.
Besides, powerful tools do not get well together with dynamically typed languages.
Abstractions that surprise you are bad. That doesn't mean the tool used was necessarily bad.
> This wouldn't be a problem if those surprises were rare and clearly marked, but the entire reason for macros to exist is to carry the surprises.
See above RE: surprised. Also, I can usually identify a macro from indentation, as most macros tend to have lambda lists similar to:
((FOO BAR &key BAZ) &body b)
which slime will pickup on and indent appropriately.> It's not that macros are bad by themselves, but they shouldn't be used often.
If by "use" you mean "write" I agree. I do write macros far less often than I write functions, and this is common advice for lisp programmers anyways.
> Besides, powerful tools do not get well together with dynamically typed languages.
Not all lisps are dynamically typed, even common lisp has optional type declarations and typed racket takes this further. Also the GP post suggested Ruby, so that's not a great alternative by this argument.