Tom Hennigan

It appears that Chrome Remote Desktop for Linux starts up an X display on :20 by default. To launch apps on this display from the command line simply set the DISPLAY variable to :20.

$ DISPLAY=:20 xterm

Or:

I don't tend to do this all that often so it's not quite in my muscle memory:

Got the following error after updating Xcode for iOS 7 this morning:

Agreeing to the Xcode/iOS license requires admin privileges, please re-run as root via sudo.

I was trying to figure out how rvm and it's .ruby-version works under the hood (if you cd into a directory containing a .ruby-version file it sets your env up so that you're using a specific rvm). It turns out that they create a bash function named cd that is called instead of the builtin cd and basically decorates a call to builtin cd with a check for the .ruby-version file in the target directory.

I didn't really want to go digging to find the definition of the function, and so TIL that in bash you can ask it to dump the function definition for you using either declare or type:

Recently I've seen the following on the Mac version of iMessage:

"The registering device does not have appropriate credentials"

Quick fix, run the following in terminal:

grep is one of my favourite tools to use in the shell, it's infinitely useful and insanely fast to use. One gripe I had was that sometimes you want to highlight matches in output without removing lines that didn't match. Modifying a stackoverflow answer I knocked up highlight which will highlight stdin or a file based on a regular expression:

The export PATH=... statement in my bash_profile seems to be getting longer and longer, with OS X's lack of a proper package manager meaning I've got things installed manually, via brew and via ports. I think expressing the PATH like this is a little neater than lots of export PATH="$PATH:..." lines:

Working with XML in Python is quite nice, but when trying to render a document back to XML after manipulating it, you can get some weird shortnames for namespaces in the result. Take the following example:

from xml.etree import ElementTree xml = ElementTree.fromstring(""" <document xmlns="http://www.lol.com/" xmlns:foo="http://www.foo.com/" xmlns:bar="http://www.bar.com/"> <something> <foo:thing>Hello,</foo:thing> <bar:thing>world!</bar:thing> </something> </document> """) print ElementTree.tostring(xml)

Which yields:

<ns0:document xmlns:ns0="http://www.lol.com/" xmlns:ns1="http://www.foo.com/" xmlns:ns2="http://www.bar.com/"> <ns0:something> <ns1:thing>Hello,</ns1:thing> <ns2:thing>world!</ns2:thing> </ns0:something> </ns0:document>

The XML parser doesn't maintain the namespace short names, so you get ns%d in your output XML. It's obviously perfectly valid XML, just a bit unsightly. To fix it up, a simple solution if you know the namespaces in advance, is to register them with ElementTree before rendering:

from xml.etree import ElementTree xml = ElementTree.fromstring(""" <document xmlns="http://www.lol.com/" xmlns:foo="http://www.foo.com/" xmlns:bar="http://www.bar.com/"> <something> <foo:thing>Hello,</foo:thing> <bar:thing>world!</bar:thing> </something> </document> """) namespaces = { '': 'http://www.lol.com/', 'foo': 'http://www.foo.com/', 'bar': 'http://www.bar.com/', } for prefix, uri in namespaces.iteritems(): ElementTree.register_namespace(prefix, uri) print ElementTree.tostring(xml)

Which yields:

<document xmlns="http://www.lol.com/" xmlns:bar="http://www.bar.com/" xmlns:foo="http://www.foo.com/"> <something> <foo:thing>Hello,</foo:thing> <bar:thing>world!</bar:thing> </something> </document>

If you don't know the namespaces at runtime, it seems that a good solution is to use ElementTree.iterparser to pull them out like so:

Sometimes it's useful to be able to edit a commit message from a previous commit (my spelling can be awful at times). If you've not pushed your changes, it's relatively simple to reword a previous commit. First off, find the parent revision before the last commit you want to rename, you can find this using git log. Then run git rebase --interactive <parent_hash>, git will fire up $EDITOR, with a list of the commits you are going to replay. Each is formatted like:

pick <hash> First line of commit msg.

To reword the commit message, change the line for the commit you want to rename to:

reword <hash> First line of commit msg.

One thing that's quite useful when you're programming is knowing when a method was called. A naive approach for this would be to add glue code into the method, and have some mechanism to know who wanted to know when the method was called etc.

However a lot of the time the requirements for someone interested in a particular method fall into a few categories, they are:

Before it runs what arguments was it called with.

After it ran what was the return value.

Was there an un-handled exception in the method.

The delegate pattern is a neat approach that can provide a neat answer to these sort of questions. It is heavily used in objective-c, and now in python using mixins and decorators we've got much the same (if not better)!

My solution has two parts:

The DelegateProviderMixin class, that provides methods for adding/removing delegates for all delegatable (is that a word!?) methods, or for specific methods on an instance.

For any method you want to enable delegates on, simply add the @notify_delegates annotation to allow the delegates system to notify delegates before and after any calls to that particular method.

The source is available at https://gist.github.com/tomhennigan/5245713, and here's an example to help get you started using it:

Yesterday I got trolled fairly hard by hadoop's sorting options so I figured I would write up my findings to stop anyone who had the same issues being trolled like I was.

It turns out that if you only supply a single field number to a -k flag in mapred.text.key.comparator.options then it has the same behaviour as GNU sort, and assumes you want to sort on all fields from there that position to the end of the line. This means that when you try and secondary sort using -k1 -k2n you're infact just sorting on fields 1 -> stream.num.map.output.key.fields (the -k2n flag is ignored because it has already sorted on field 2).

Anyway, the simple fix is to explicitely set the ranges using -k{from},{to}{opts} for each field. The correct configuration on Hadoop 0.20.2 for a secondary sort on a numeric field is as follows:

Partitioner:

org.apache.hadoop.mapred.lib.KeyFieldBasedPartitioner

Job configuration:

stream.num.map.output.key.fields = 2

mapred.text.key.partitioner.options = '-k1,1'

mapred.output.key.comparator.class = 'org.apache.hadoop.mapred.lib.KeyFieldBasedComparator'