ronin

Clay Shirky: Gin, Television, and Social Software

“And television watching? Two hundred billion hours, in the U.S. alone, every year. Put another way, now that we have a unit, that’s 2,000 Wikipedia projects a year spent watching television.”

I found it hard to pull just a single quote of this piece out, it’s a quick read that just makes you start thinking. If the calculation of how much effort has gone into Wikipedia is even close, this is an amazing way to look at it.

My consumption to production ratio is so low it’s embarrassing.

Leonard Lin: Internet Asshattery, Armchair Scaling Experts Edition

The hack for the iPlayer from last week was closed by the BBC, but only by more obsfucation. Therefore, there is a patch for last weeks script which fixes the problem.

Reading the comments there are a few people out there working on making this better, and it looks like there is a script to generate an RSS feed for the iplayer website.

From the “it’s almost certainly been done better somewhere else” department, here is my script to fire off a Gnome Notification after a shell command finishes.

a python script:

#!/usr/bin/python
from pynotify import *
import sys

def notify(message=""):
    n = Notification("Command Line Completed", message)
    n.show()

init("cli notify")
if len(sys.argv) > 1:
    notify(sys.argv[1])
else:
    notify()

Then just add it to your path and you can append it onto some command:

echo monkey && mynotify.py "some message"

You then get a notification like so:

Elliotte Rusty Harold: North and South

WS-* is North Korea and REST is South Korea. While REST will go on to become an economic powerhouse with steadily increasing standards of living for all its citizens, WS-* is doomed to sixty+ years of starvation, poverty, tyranny, and defections until it eventually collapses from its own fundamental inadequacies and is absorbed into the more sensible policies of its neighbor to the South.

Greg Jorgensen: Abject Oriented Programming

The number of lines of code in the application is a common measure of the importance of the application, and the number of lines a programmer can produce in a day, week, or month is a useful metric for project planning and resource allocation.

Lovely analysis of how projects actually work, of course the funniest part is the commenters who just don’t get the irony:

Overloading is actually the practice of using the same function name twice, with each handling different inputs.

In the comments for an earlier post Martin Paljak has posted a follow up to the original info about the Estonian OpenID project.

An InfoQ article on Ruby threading and the implications of the approach taken in YARV. Nicely written up. I think I would probably prefer an Erlang approach which seems much more high level and would suit Ruby more than native Threads.

Looks like there’s going to be an OpenID for every Estonian. Cool.

Simon Willison asks how Smart Cards help with Phishing. I believe it’s because they are a form of 2FA where only one of the 2 Factors is ever exposed and hence all the credentials can’t be phished.

I’m not an expert though, and of course a quick google search turns up some examples of 2FA being phished.

btw, I first read this as “OpenID for all Etonians”, which I thought was kind of weird, but not totally out of the question.

The XML configuration madness continues. Serialised XML for application configuration? That can’t be good.

I guess that the development process goes like this:

• Write config file in xml, test, change, test change.
• Serialise file
• Release to test environment.
• Discover problem
• Deserialise file, investigate.
• Edit source xml, test, change, test, change.
• Serialise file.
• Rinse, repeat.

At some stage we’re all going to drown under the sea of xml configuration files piling up all around us.