What would be nice to have would be "pithy" examples of code to
Erik Naggum <e...
> * Rolf Wester
> | Could you please give me some examples showing in what respect
> | Lisp has a _much_ higher level of abstraction.
>Special variables leaps to mind as the obvious first choice, more
>obvious than closures, the Lisp object reader and writer, the type
>hierarchy and dynamic types, the entire condition system, macros,
>compiler-macros, etc, which I just mention in no particular order.
>Of course, if your point is to gripe about the choice of "much", you
>will never be satisifed with any answer I could give you, anyway, so
>either you accept this or you do not. And if you had had a real
>argument, it would have been expressed properly, so I am inclined to
>believe you are just trolling and will not respond to any further
>trolling-like responses you choose to post, but please feel free to
>argue your case if you have one.
exemplify these sorts of things.
The newcomer (whether troll or real) could easily walk away from this
"Hmm... Special variables. I wonder what those are?"
A quick look at the HyperSpec certainly does _not_ cause the
implications of them to leap out at one; the quick browse raises a lot
more questions than it answers:
- Why did you say "special variable," when all the glossary indicates
is "see dynamic variable"?
- Then there's these other terms, "dynamic extent," "indefinite
extent," "dynamic scope," and "dynamic environment." They all seem
somewhat relevant, but how does it go together?
It definitely isn't a "pithy" explanation.
The section in CLTL2 on "Scope and Extent" explains it a little more
clearly, I think, but it doesn't get to the point of explaining why it
would be considered _important_.
A reasonably "pithy" example is shown here:
It doesn't say anything that would cause Special Variable to "leap to
mind as the obvious first choice."
Note that I'm not disagreeing with the notion that SV's are useful or
important; I _would_ disagree with the notion that this is either
obvious, or even a represents a notion readily accessible to a novice.
I don't think _any_ of the items you list are "obviously obvious;" I
just did a quick review of the set of introductory documents on CL,
and few give much, if any treatment of them.
That could mean (at least :-)) two things:
1. Perhaps you're wrong.
I don't think you're particularly wrong. There could be quibbling
over "who's on first," but the features you describe do appear
like good candidates for "_much_ higher level of abstraction."
2. The literature is doing a bad job of communicating these sorts of
This seems to me to be a _whole_ lot more likely.
There are two books on CLOS (one of which I have seen) which describe
"On Lisp" sells hard the power of macros.
Various references do describe the importance of closures.
But the "You really need to know and understand and use special
variables, the type hierarchy, and custom readers" parts are _not_
"evangelized" in the literature in similar manner to [say] CLOS.
Note that I am _not_ being critical about either CLTL2 or CLHS on
this; they do not have, in their proper scope of intent, the mission
of explaining: "Here are techniques that you should use!"
I think the world could use an "essay" or "book" that describes 7
different applications of readtables, for instance, sort of
paralleling Keene's book on CLOS.
(reverse (concatenate 'string "gro.mca@" "enworbbc"))
"It is easier to optimize correct code, than correct optimized code"
-- Yves Deville