Fully 30% of the window height is administrative debris. There are ten arrow buttons. The window close control is directly above the Edit menu.

Complexity is not your friend. Fitt’s Law is not your enemy.

import lazyboy as lzb

lzb.add_pool('Keyspace', servers=['127.0.0.1:9160'], debug=True,
           slow_thresh=100)
conn = lzb.get_pool('Keyspace')

What this does is return a connection object with tracing enabled. Every call made to Cassandra will be logged at the DEBUG level, and any call which takes longer than slow_thresh milliseconds will be logged at the WARNING level. When you use Lazyboy, you’ll see logs in this form:

lzb.slice_iterator(lzb.Key("Keyspace", "ColumnFamily", "RowKey"), count=1)

# -> DEBUG:DebugTraceClient:72ms: 127.0.0.1:9160 -> get_slice(('Keyspace', 'RowKey', {'column_family': 'ColumnFamily', 'keyspace': 'Keyspace', 'super_column': None, 'key': 'RowKey'}, SlicePredicate(column_names=None, slice_range=SliceRange(count=1, start='', reversed=False, finish='')), 1), {})

lzb.slice_iterator(lzb.Key("Keyspace", "ColumnFamily", "RowKey"))

# -> WARNING:DebugTraceClient:861ms: 127.0.0.1:9160 -> get_slice(('Keyspace', 'RowKey', {'column_family': 'ColumnFamily', 'keyspace': 'Keyspace', 'super_column': None, 'key': 'RowKey'}, SlicePredicate(column_names=None, slice_range=SliceRange(count=10000, start='', reversed=False, finish='')), 1), {})

This should be pretty self-explanatory. You can see what calls were made to the Thrift client, the exact arguments, and how long it took. If you’d like to use a custom logger, you can pass a logging instance in the log keyword:

import logging

lzb.add_pool('Keyspace', servers=['127.0.0.1:9160'], debug=True,
           slow_thresh=100, log=logging.getLogger('Lazyboy'))
conn = lzb.get_pool('Keyspace')

You might want to do this to enable debugging, since the default logger configuration is set higher than DEBUG.

Compile.el is really great for this kind of thing, since it lets you quickly navigate over the lines mentioned in the program’s output. It’s quite efficient, and I enjoy it immensely. One note of interest: pep8.py doesn’t output line numbers in order, which confuses compile-mode. I just pipe the output through sort to work around this.

The code is on GitHub: python-pep8.el and python-pylint.el.

The problem is that when you hold the phone, you cover the speaker and the headphone port. Whoops: No sound for you. Assassin’s Creed is far from the only game that does this. It seems like such a no-brainer, I don’t know why everybody chooses this orientation. Maybe developers are targeting iPod Touch instead of iPhone? Its headphone jack is in the top-right position when in the same orientation. It seems like a trivial thing to add, but nobody seems to do it. Hell, you could probably detect the type of device and put it in the right orientation automatically. Nobody does, and it sucks, and it bugs me whenever I try to play a game.

The History of every major Galactic Civilization tends to pass through three distinct and recognizable phases, those of Survival, Inquiry and Sophistication, otherwise known as the How, Why and Where phases. For instance, the first phase is characterized by the question ‘How can we eat?’ the second by the question ‘Why do we eat?’ and the third by the question ‘Where shall we have lunch?

I think this applies directly to programming as well. I’d characterize the questions as:

1. How can I do it?
2. Why did I do it like that?
3. What tool will do it for me?

At first, a new programmer just wants to know how to make something work – You could also call this the Why doesn’t this work? question. There’s a whole industry around helping people – not just programmers – with the this problem. The failure of this approach is its tendency to create cargo-cult coders, programmers who can get something done, but can’t explain their choices or method. Many have no desire to, or may not even realize that they should. Their world is full of (in the words of Rumsfeld) unknown unknowns.

I think the advancement of a programmer is strongly linked to self-examination, figuring out why you did something and if there’s a better way. If you don’t understand the failings of your approach, you have no chance to improve it. Programming is strange, and hard, and unnatural, and it’s important to be vigilant about the code you write. Humans in general are creatures of habit, and programmers seem to be particularly vulnerable its stultifying effect. We rely heavily on techniques and patterns, and it’s easy to fall into the trap of habit and stop reflecting.

Asking why is one of my favorite interview tactics. I’ll look over the candidate’s site, or a project they worked on, and find something interesting or unusual to ask them about. People who are strong candidates have answers, and poor candidates don’t. Even if their reasons are dumb, or you don’t agree with them, the ability to explain their choices shows that they thought about the problem.

One of the questions in Coders at Work was, (paraphrasing) Do you think programming is engineering, craftsmanship, or something else? I think it depends on the programmer – programming is what you make of it. Some programmers are craftsmen, some are engineers, and there sure are a lot of lowest-bid contractors out there.

It’s a very immature discipline, relative to the engineering or craftsmanship parallels. We’re still in the survival stage now, but it’s time to start challenging ourselves, reaching out for sophistication.

This is the second full-size Moleskine I’ve filled; This one lasted from August 2008 to December 2009, which is about as long as the first one. I went through a number of pens and inks on the first, but settled on a Pilot Knight fountain pen filled with Noodler’s Bulletproof Black by the time I finished it. I used the same pen through the second one, though I switched to Noodler’s Heart of Darkness and swapped the regluar medium nib for an italic.

I wrote on the right-hand page, and pasted a photo on from the day I wrote the entry on the opposite page. It’s a good feeling – the journal ends up with a nice heft, and it gives you a sense of progress. It adds literal weight to the words inside.

I’m declaring it a failure.

Why?

I reevaluated what I consider important. Owning lots of cool stuff not only seemed unimportant, it suddenly felt suffocating. It has to be stored and maintained and moved. I spent so much time and energy spent on these things which did nothing to improve my life.

I resolved two things:

1. I would get rid of all the unnecessary stuff I have.
2. I wouldn’t buy any more.

Minimalism is hard. Step one is incredibly hard. As humans, we find significance in all sorts of insignificant things. Nearly anything we come into possession to is imbued with this near-mystic emotional value. Maybe the thing itself isn’t important, but it reminds you of the time you got it, or who you got it from. I tried to turn a critical eye, but the proportion of things I got rid of to the things I didn’t was completely backwards.

Fortunately, I found the second goal easy. It has much value; it’s a minimalist preemptive strike. You don’t have to discard that which you don’t acquire.

I think there are multiple reasons why I failed, but the primary one is simply that I wasn’t minimal in my approach to minimalism. I saw minimalism as an end, but my chosen means was to boil the ocean.

While I consider this attempt a failure, I’m not giving up. It’s hard to reverse the trend of a few decades, but even a small step towards minimalism is a step in the right direction. So I’ll strive for it, and try to be more pragmatic in my decisions.

I WANT TO KNOW IF YOUR ITEM IS STILL AVAILABLE FOR SALE?

Sent from iPhone

It is.

Hello

Thank for your reply? Am very interested in buying your item and i will like to buy this item now reason is that i want to buy it for my son and i will be offer you $850 for the item so i will provide you $150 for the shipping cost so provide me your paypal email so that i can make the payment.

Thank

I was only asking $750, so it’s pretty clear that this guy is a scammer.

Your offer of $1000 is very generous, but not enough. I couldn’t possibly accept any less than $1200.

ok…no problem i will pay $1200 for the item and send me your paypal email address so that i can make the payment…ok

I’m very sorry, I meant $1300. I apologize, I must have mistyped. It can be a little hard to ger thinga righy since I spilled that beer on the keyboard.

In addition to the $1300, I will also need two beers.

ok…no problem i will pay $1300 for the item and send me your paypal email address so that i can make the payment…ok

$1300 and two beers. I’m not sure how you can send me payment in beer over the Internet, as nobody has invented BeerPal yet.

Dylan, I haven’t heard back from you, and it makes me very sad. I’m sure your son would like this MacBook Pro very much, and it’s quite a bargain for $1300 and two beers.

Additionally, the animation when switching Spaces is significantly slower and less smooth.

His argument is a straw man. My post is about a specific application – simple, flat data, where the primary concern is ease of syntax for accessing that data. He generalizes that position into one of OOP vs. non-OOP, which is not even remotely close to what I wrote.

So, let me be clear. OOP is, generally, good. His tips on writing OOP code are also generally good. In fact, I wrote a class to make dependency injection painless. Other paradigms, like functional programming, are also good.

This is not about that. This is about what’s faster for simple data storage: arrays or stdClass instances. The answer was, and still is, arrays.

I took the code from the previous post and re-ran it against PHP 5.3.0 on Snow Leopard. Everything else is is the same as in the other test. I added two new measures. One using $x = array('a' => 'a', 'b' => 'b'), and one with an object class with a constructor, like so:

class AnObject
{
    public $a;
    public $b;

    public function __construct($a, $b)
    {
        $this->a = $a;
        $this->b = $b;
    }
}

Here are the results:

As you can see, things are better than in PHP 5.2, but arrays are still faster in every case.