It turns out that there are some situations in Python where it is useful toknow what your superclass is. In particular, itwould be nice for mixin classes to be able to know when they are aboutto call methods on object() instead of on some actual user class.

It would be nice if the objects returned by super() directly exposed away of determining this. Unfortunately they do not, and they don't evendirectly expose what the next superclass is, although given a super object you

The yearly on-campus technical conference has just wrapped up for anotheryear, so it seems a good time to write down my rules of thumb forpicking what conference talks to go to, in the hopes that I'll rememberthem for next year. (This year, I only remembered them about halfwaythrough.)

First, I should note that this is about picking interesting talks, notrelevant ones. With rare exceptions, I don't go to talks at our localtechnical conference to be educated,

On modern machines, the temptation is to make heroically big swap sizes;you'll hardly notice giving your swap 5G or 10G, and it means that youcan just forget about the whole worry that you've madeit too small. But this can be counterproductive, because too much swapcan be dangerous.

The problem with a too large swap is that it lets your system thrashitself more and more into overload, instead of outright exploding andthen recovering. When a system is overloaded enough,

The amount of memory that a program needs in order to actually get somework done is called its Resident Set Size (RSS). The total amount ofvirtual memory a program uses is called various things; ps uses VSZ(Virtual Size, presumably), for example.

The premise of paging things out to your swap space is that mostprograms don't need to use all of their memory all of the time;their RSS will be smaller than their VSZ. The difference can bepushed out to swap space