[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Comments on the gray book

The gray book (Art of the Metaobject Protocol) is harder to criticize
than the pink book (Metaobject Protocol Specification) because it says
right up front that it isn't talking about the real MOP or even the real
CLOS and it leaves lots of things out that were too hard to explain.
Here's what I thought of after an initial reading.

I found this generally pretty readable and about as understandable as
can be expected.  It seemed to me that it is pretty easy to read along
in this book thinking you understand what it's saying, and then discover
that in fact most of it went in one ear and out the other.  This is
because the concepts being set forth are fundamentally complicated and
confusing because of their circular structure.  It's easy to get lost.
Don't take this as negative criticism, this presentation is still far
better than any other MOP presentation I have seen.  It's inherently a
difficult subject.  Maybe there should be a quiz, or exercises at the
end of each chapter.

One more specific comment is that although efficient implementability is
mentioned as a design goal, I don't think the book really touches on
what is necessary to achieve that, which in my opinion depends
fundamentally on keeping the programmer at arm's length from the
implementation through the use of abstraction.  I got the impression
that in this book, "efficient implementability" ends up meaning to take
an incredibly inefficient toy implementation and make it incrementally
better.  That's fine as a pedagogical technique, but somewhere in there
the other side of the coin, making protocols that are abstract enough to
work in implementations based on fundamentally different architectural
decisions, needs to be addressed.  This is certainly not an easy thing
to do, but if it isn't done the value of The Art of the Metaobject
Protocol will be greatly diminished.  It's possible that you think
chapter 4 already addresses this question, but after reading it a couple
of times I don't think so.  I don't think chapter 4 even fully addresses
the popular cop-out response: the standard metaclasses can do it a
special efficient way that's completely different from the way it's done
if any user-defined methods are applicable.  And of course I would rather
see protocols defined in a way sufficiently abstracted from the
implementation that no cop-out is required.