Ian Wienand: Investigating the Python bound method
You work with Python for a while and you'll become familiar with
printing a method and getting
I think there is room for one more explanation on the internet,
since I've never seen it diagrammed out (maybe for good reason!).
In the above diagram on the left, we have the fairly simple
conceptual model of a class with a function. One naturally tends to
think of the function as a part of the class and your instance calls
into that function. This is conceptually correct, but a little
abstracted from what's actually happening.
The right attempts to illustrate the underlying process in some
more depth. The first step, on the top right, is building something
like the following:
As this illustrates, the above code results in two things
happening; firstly a function object for function is
created and secondly the __dict__ attribute of the class is
given a key function that points to this function object.
Now the thing about this function object is that it implements the
descriptor protocol. In short, if an object implements a
__get__ function; then when that object is accessed as an
attribute of an object the __get__ function is called. You
can read up on the descriptor protocol, but the important part to
remember is that it passes in the context from which it is
called; that is the object that is calling the function.
So, for example, when we then do the following:
what happens is that we get the attribute function of
f and then call it. f above doesn't actually know
anything about function as such what it does know is
its class inheritance and so Python goes searching the parent's class
__dict__ to try and find the function attribute. It
finds this, and as per the descriptor protocol when the attribute is
accessed it calls the __get__ function of the underlying
function object.
What happens now is that the function's __get__ method
returns essentially a wrapper object that stores the information to
bind the function to the object. This wrapper object is of
type types.MethodType and you can see it stores some
important attributes in the object im_func which is
the function to call, and im_self which is the object who
called it. Passing the object through to im_self is how
function gets it's first self argument (the calling
object).
So when you print the value of f.function() you see it
report itself as a bound method. So hopefully this illustrates
that a bound method is a just a special object that knows how to call
an underlying function with context about the object that's calling
it.
To try and make this a little more concrete, consider the following
program:
Running this gives output something like
To pull it apart; we can see that Foo.__dict__['function']
is a function object, but then f.function is a bound
method. The bound method's im_func is the underlying
function object, and the im_self is the object f:
thus im_func(im_self) is calling function with the
correct object as the first argument self.
So the main point is to kind of shift thinking about a function as
some particular intrinsic part of a class, but rather as a separate
object abstracted from the class that gets bound into an instance as
required. The class is in some ways a template and namespacing tool
to allow you to find the right function objects; it doesn't actually
implement the functions as such.
There is plenty more information if you search for "descriptor
protocol" and Python binding rules and lots of advanced tricks you can
play. But hopefully this is a useful introduction to get an initial
handle on what's going on!
<bound method Foo.function of <__main__.Foo instance at 0xb736960c>>
In the above diagram on the left, we have the fairly simple
conceptual model of a class with a function. One naturally tends to
think of the function as a part of the class and your instance calls
into that function. This is conceptually correct, but a little
abstracted from what's actually happening.
The right attempts to illustrate the underlying process in some
more depth. The first step, on the top right, is building something
like the following:
class Foo():
def function(self):
print "hi!"
f = Foo() f.function()
import types
class Foo():
def function(self):
print "hi!"
f = Foo()
# this is a function object
print Foo.__dict__['function']
# this is a method as returned by
# Foo.__dict__['function'].__get__()
print f.function
# we can check that this is an instance of MethodType
print type(f.function) == types.MethodType
# the im_func field of the MethodType is the underlying function
print f.function.im_func
print Foo.__dict__['function']
# these are the same object
print f.function.im_self
print f
$ python ./foo.py <function function at 0xb73540d4> <bound method Foo.function of <__main__.Foo instance at 0xb736960c>> True <function function at 0xb73540d4> <function function at 0xb73540d4> <__main__.Foo instance at 0xb72c060c> <__main__.Foo instance at 0xb72c060c>
One of the best way to
It is quite easy to turn 
In mailing list discussions, I've noticed that the practice of replying "+1" to messages with which one agrees has become very widespread.
I think this is interesting for a lot of reasons, such as what it shows about habits picked up in communicating via social network sites that grew out of e-mail percolating back to e-mail. We seem to have really grown to like this idea of "voting" for people's messages, and if there's no "Like" or "+1" button on their message, we'll make our own. (Likewise, apparently a person's name is no longer sufficient to indicate that one is addressing them in an e-mail -- am I right, @dear_reader?)
The problem for me is that I have my venerable awesome e-mail client 
If you ever used 
This is my monthly summary of my Debian related activities. If you re among the people who 
Dpkg and multiarch
The month started with a 
Hopefully everything will be ready in April. I m working hard to meet that deadline (you might have noticed that my blog has been relatively quiet in the last month ).
Thanks
See you next month for a new summary of my activities.
This leap day saw me driving along the river on a rainy, with 4
chickens in the car's trunk, and 3 terabytes of disk (and a half a bale of
straw) in the back seat. I may have not been blogging much lately about
life, because these situations can be hard to explain. (Or because "joined
the Debian haskell team and spent two days working on rebuilds for the ghc
7.4 transition" is not thrilling reading.)
American Psycho is a novel by Bret Easton Ellis. It's a first person
stream-of-consciousness novel about a mid-to-late twenties Wall Street banker
during the late-eighties-early-nineties.
Patrick Bateman is a vain, self-obsessed pleasure-seeker, surrounded by a
gaggle of similarly self-obsessed bankers and socialites. Bateman and his
friends idle away their days thinking about what restaurants to secure dinner
bookings; which nightclubs to be seen at; where to score cocaine and pick up
women. They compete with one another on points of dress etiquette, and the
relative degree of luxury demonstrated by their attire. They are all relatively
interchangeable: the reader could be excused for mixing the identi-kit bankers
up, and indeed they are frequently confused for each other, and other people,
throughout the novel.
Bateman describes in vivid detail nearly every item of clothing worn by
both his male and female associates, describing both their cut and which
fashion house they have come from, occasionally passing judgement. The murders
are typically described with the same vivid detail as his more public
activities.
As well as a yuppie, Bateman is a psychotic, and probably a serial killer:
there is a small amount of ambiguity, partially due to the frequent confusions
of identity between the various male banker characters in the book. It's
possible that Bateman has fantasised his killer side, or embellished it. He's
clearly an unreliable narrator. It takes a relatively long time before this
aspect of his personality emerges. It's also possible that he is a killer, but
the people he kills are so interchangeable that nobody notices, or cares.
There is a passage towards the end of the book that strays into Hollywood
action-thriller levels of absurdity, possibly the only moment in the book where
you have difficulty believing that the events could have occurred as described.
Bateman tries repeatedly to talk to people about his crimes, but never succeeds
in holding people's attention, or being taken seriously. This particular theme
reaches a particularly amusing climax.
Reportedly Ellis wrote the novel without the violent scenes and later added
them in. I can believe that. The novel is carefully constructed to manipulate
the reader in a way I've never been aware of before. The everyday and the
horrific mesh to make the whole seem very consistent and lucid. There is a
small surreal element woven into the story which is so subtle and downplayed
that you can't withdraw into the safety of "this is a fantasy". Similar scenes
recur over and over: heading to a restaurant. Heading to a club. Sex. Murder.
Ellis uses repetition to lull you into a false sense of security before hitting
you hard with an about-face, mid-sentence, like a movie jump-cut. This book
has the dubious distinction of being the second novel ever to have made me feel
physically queezy after reading a passage (and I was reading the other book in
a car, which may have been a contributing factor).
The book has been criticised for the level of violence meted out against women.
Numerically, Bateman describes a roughly even number of male and female
murders. However his female victims are dispatched with a shockingly higher
level of planned sadism: most of his male victims are opportunistic rather than
planned. Some critics theorise that the even male/female victim count is a
deliberate pre-emption on the part of the author from criticism for the
violence against women. I don't quite see the argument, here: Bateman is not a
sympathetic character. He's a monster, and the fact he's a sexist monster is
only one unpleasant facet of many. To me, the disdain and hatred shown
towards homeless people was a far more prevalent problem, not least because it
wasn't limited to murders, or even Bateman: many of the other characters are
cruel towards them.
What would this book be, without the murder? Quite similar to a number of
Ellis' other stories, if their blurbs are anything to go by: explorations of
the emptiness of the lives of privileged, upper class contemporary Americans.
Is the psychopathy central to the story? I think so. The contrast between the
corporate and the murderous is at the core. Would I recommend this novel? I'd
hesitate to do so to anyone with a nervous disposition: otherwise, it has left
a lasting impression and a desire to discuss it further, which you can take as
praise.
With first RC for 
Back in 2005 I saw that a new open standard was being developed for calendaring, and I thought it would be a great idea to implement it. Nothing too complicated - just a really simple implementation...
And thus was born the "Really Simple CalDAV Store".
A few years later, when I got about 90% of the way through implementing the base CalDAV specification, I realised that "Really Simple" and "Calendar" don't actually happen in the universe we inhabit, so after much deliberation the project got renamed to "DAViCal".
Now, in 2012, DAViCal is one of the leading CalDAV servers available, and I spend quite a lot of my time helping people who want to use it. Earlier in the year I was looking at the web server logs and noticed that in a four week period (i.e. as far as my logs go back) there had been several thousand unique sources of hits on the URL that DAViCal uses internally to find out what the latest version is when you browse to the '/setup.php' page.
This got me wondering how many DAViCal installations there are out there, and how big they might be, and so forth but since DAViCal is free open source software, there isn't a simple way to answer those questions.
I thought that it must be time to run a survey of DAViCal users everywhere to try and find out what the scale of the penetration is. How big (and how small) are the installations running DAViCal? What... Well: lets save the questions for the actual place where you can put answers :-)
More than two years ago I wrote