C[omp]ute

From: andrew cooke <andrew@...>

Date: Sun, 8 May 2011 05:27:18 -0300

I just found this on my heard drive; it was written quite a while ago, but
never posted.

Andrew


This is a curious book.  When I heard of it, about 6 months ago, I found mixed
online reviews.

All the references I need are online, carefully indexed by Google.  I only buy
books that give more than that; books that require, and reward, a complete
read.  So I skipped Pro-Django.

But I continued to stumble over references.  One day, chatting online with a
less-than-impressed reader, I offered to buy their copy for $10, curious to
understand the range of reactions.  Deal.

Others may also be curious, so here is my explanation of the mixed reviews.
As you might expect, it is both better and worse than I expected: it's smart,
but a dumb kind of smart.

I can illustrate that with the section that introduces signals.  These are
events raised by Django that you subscribe to, with names like pre_save and
post_save.  Those names might remind you, as they did me, of the way CLOS (the
Common Lisp Object System) lets you extend methods before or after they are
called.  And then, if you gaze out of the window, as I did, you might start to
think that signals are just another way of decorating methods.

Pro-Django says nothing of this, but it does give a lot of details about
signals.  If you like details, that's great.  But I'm too old for details: I
need generalisations.

Generalisations are good, even if you're not senile.  They're good because
they lead places you already know.  Places like: if signals are like method
decorations, what happens when the method raise an exception?  Hmmm.

Now Pro-Django explains how exceptions interact with signals, in grey box, a
page later, because it has all the details.  That's the problem: it's just
another bloody detail.  There's no arch to bring it all together.

But before you nod sagely in agreement, could you have done any better?  I
don't think I could.  Writing books is hard.  This is a meaty book, dense with
facts hard-earned from hours of reading code.  How do you tie all that
together?  One way is with examples.  He has examples.  Good, meaty examples.
Another way is with careful hierarchical structure.  Also present (although
the page design doesn't show them too well).  He's trying.

It's not great.  I don't know how to do great; the author doesn't either.  But
I still found it worth reading, slowly.

To do the book more justice, I can explain why the first chapter - the one you
can download for free - is so drab.

The first chapter is a summary of standard, but slightly obscure, Python
techniques.  Things a newbie programmer doesn't know, but anyone that has
lived with Python for years does: decorators, metaclasses, etc.

I read that, and was bored.  But imagine that you only know Python through
Django.  From that perspective, the chapter is critical.  And with that
insight, I think you can get a better understanding of rest of the book: it
does for Django what that first chapter does for Python.

The first chapter is a terrible example for anyone that knows Python in depth,
because it's old news.  But I don't know Django as well as I do Python, so the
rest of the book is much better.

It's still not a great read.  You need to stop, think, and build the
generalisations yourself.  Which makes it slow, hard work.  But, for me, it
was worth the effort.