Just something I was playing around with today that I thought I might share.

I was curious about how to get network statistics in windows so I've been reading MSDN all day trying to work it out. I've written a little bit of python using the ctypes module to access the API on network statistics. All I can say is that doing these things on Linux is so much easier as you can just access the /proc directory and parse the system files there that contain such information.

I wrote a bandwidth-usage Dashboard Widget for Adam Internet a while ago. They have since changed their quota system to use "onpeak" and "offpeak" quotas, breaking my old Widget. I've now updated it for the new system.. I may create a nicer widget at some point, the current code is a bit of a mess, and I have an idea for presenting the on/offpeak data better...)

Admittedly there's probably around zero other Adam Internet customers reading this, but it should appear in search engines, should someone be looking for such a widget..

Anyway, how it looks:

Months ago I was required to design and model some part of computer system architecture. I decided to do a very small microcode processor.

For those who are unfamiliar with microcode allow me to explain the significance. In computer system design there are two approaches to designing instruction decoders. The first is called the hardwired approach. For each possible instruction in our instruction set the decoder designers spend a lot of time with truth tables. Each bit in the instruction is mapped through logic pathways to produce an appropriate result on the processor control lines. This is a very efficient decoding approach as instructions are decoded extremely fast. The problem is that if you change the instruction set or even modify the components in the processor, the decoder will need a complete overhaul. This becomes expensive.

The second approach is called microcoding. Here we design a dynamic instruction set that can be reprogrammed (called microprogramming believe it or not). The idea is that we store the entire instruction set and the values of each control line in a very small very fast memory device. When an instruction enters the decoder, the decoder simply looks up the values of the control lines for the input instruction and writes them out onto the bus. This is not as fast as a hardwired approach because memory devices have much greater latency than logic gates however it makes changing the instruction set (adding, removing or modifying instructions) very easy. We don't have to spend a lot of time completely redesigning the decoder whenever we add, remove or modify other components in our system. We simply reconfigure the decoder to behave differently when it receives an instruction.

Short film my brother and I made over the last few weekends. Shot on my new Canon 5D Mark II

As the "final commit" mentions, 387 days and 330 commits after the I started, tvnamer and tvdb_api are at a point where I'm happy to release "version 1.0"!

tvnamer is probably of most interest, it's an automagical TV episode renamer, turning files from "some.show.s01e01.hdtv.blah.avi" to "Some Show - [01x01] - The Real Episode Name.avi", using information from thetvdb.com

To install, simply do..

This is a simple Python implementation. Note the global variables p and a should in general be re-generated each pass. p is any prime and a is the primitive root of p.

Something I always missed from Foobar2000 is the option to "Stop playback after current song"

For some reason it never occurred to me it would be trivial to write an AppleScript to mimic this for iTunes..

tell application "System Events"
    set cur_app to name of the first process whose frontmost is true
    set visible of process cur_app to false
end tell

After looking for a way to import Python modules when given a valid filepath I came across a description of a technique to do so here.

What I did not like about this approach was the use of null_module. In his approach you needed to have a module called null_module somewhere in your PYTHONPATH. This was then cloned and the information about the actual module you wish to report overwrites this module. In short, he was using null_module as a skeleton module for the import. This is unnecessary.

To do the entire import in a much nicer way you can simply do:

This is going to be mostly a code post.

First thing we need is a method of getting the coordinate of elements in the document. Here is a function I created to do that.

/**
 * Get the offset coordinates of the element.
 * @param {Object} element The element.
 * @return {Object} An object with four properties named x1, x2, y1 and y2 containing the elements left, right, top and bottom edges respectively.
 */
function getElementPosition(element) {
    var elementX = 0;
    var elementY = 0;
    var elementW = element.offsetWidth;
    var elementH = element.offsetHeight;
 
    while (element.offsetParent) {
        elementX += element.offsetLeft;
        elementY += element.offsetTop;
        element = element.offsetParent;
    }
 
    elementX += element.offsetLeft;
    elementY += element.offsetTop;
    elementW += elementX;
    elementH += elementY;
 
    return {x1: elementX, y1: elementY, x2: elementW, y2: elementH};
}

During my recent struggle with the JavaScript canvas object I was looking for a method to draw ellipses. Originally I was trying to use the arcTo() and even got desperate enough to have a quick play around with the bezierCurveTo() and quadraticCurveTo( ) functions before the obvious solution dawned on me.

In the event anybody else wastes their times looking for a way to do this try the following:

var e = document.createElement("canvas");
document.body.appendChild(e);