It is a truth universally acknowledged that some songs are better than others. And it ought to be pretty widely acknowledged that there are some people who can take a perfectly good song and perform it in a way that makes you wish you were temporarily deaf.

The second thought came to me this morning. Our neighbour on one side is a perfectly nice old Aussie bloke who likes music from a certain period and/or genre. The genius of the Shadows frequently features on his playlist. Top hits of the late 60s and early 70s can often be heard, especially since he's a little deaf and likes to turn it up a bit. But this is all fine... or was, until he played Richard Clayderman whilst we were eating breakfast.

To be fair, it may not have been Mr Clayderman. I'm sure there are other instrumentalists who make their livings by reducing good songs to feeble elevator muzak... in any event it got me thinking about what makes a good song. Or rather, a good "track", and by that I mean a performance of a song, rather that just the song itself.

Here's my theory: in order to be listenable, a track has to have at least one of:
(a) an interesting melody that's balanced between predictability and surprise
(b) interesting lyrics that mean something to the listener
(c) a genuine and moving performance

Time for some examples. Let's take (c) first, because I'm feeling perverse. The Sex Pistols 'God Save The Queen' has no real melody and the lyrics aren't all that hot ("potential H-bomb"? What?). But it works (for me) because it's played with a sneering, raucous enthusiasm that makes a very simple song work. The same's true of, say, Iggy Pop's 'I Wanna Be Your Dog': four chords, not very many words and yet it can grab some people by the scruff of their brain. Or (c) can be achieved by just a voice; personally, I could listen to Cerys Matthews reciting the digits of pi for hours just to hear her voice.

Moving away from tracks to songs: it's easy to find examples for (b). And it's this that Mr Clayderman's performance was making me ponder this morning. Since there were no words, all you could hear was the melody and when he performed Foreigner's 'I Wanna Know What Love Is', it showed up just how boring the melody of that song is. Not that it's a song I particularly like anyway, but if it works at all, it only works with the words. As a piece of music, it's tedious.

Or we could go back a generation or two: the first verse of Cole Porter's 'Night And Day' is all sung on one note. The words are what's important. Or take almost anything by AC/DC: there's more melody in one bar of any of Angus's solos than in any verse, but (especially when Bon Scott was writing them) the lyrics carry the song. Or for an example that's a whole subculture: rap. No melody, all words.

So finally, we come to (a): songs with melodies that can lift even simple lyrics. This is what (for me) separates real musicians from wannabees. Example one: Kate Bush's 'Wuthering Heights'. Now, I quite like Ms B's music, but I wouldn't argue that the words make the song. Or even that the words make sense half the time... but you could play the melody of that song without any words and it stands up as a damn good piece of music.

Example two (and this is going to date me): any one of a whole bunch of tracks by Yes. Let's take 'Close To The Edge': the lyrics are incomprehensible stoned-hippy trash, and yet (assuming you're ok with progressive rock) they're carried by interesting music.

And then there are the exceptions that prove the rule: tracks with none of the above. Well, you could turn on the radio and wait ten minutes and you're bound to hear an example or two. Anything by Good Charlotte would do: worthless, lazy songwriting. Churning out 'product' with as much attention as the average burger-flipper pays to the hundredth Big Mac of the day.

But then again... there are the tracks with two or even three of the Key Attributes. In the 70s you could have heard Carole King produce a whole album of them (Tapestry). In the last few years, Elbow have done the same. The art of songwriting is far from dead, and one great song can remind me that music is worth persevering with.

Of course, these are my examples. Yours will be different. But I reckon that in every track you really love, there will be at least one of (a), (b) or (c).

Posted via LiveJournal app for iPad.

So here's an interesting study done on a sample size of one (me). I'm pondering a blog entry, and I have two ways to write it. I can (a) get up, walk to the study, unlock one of the Linux laptops waiting patiently, fire up the LiveJournal web page and then type, on a proper keyboard. And it'll be a fast machine, with a sprightly web browser to find interesting and relevant links.

Or, (b), I could use the LiveJournal app on the iPad. Which means two-finger typing on a screen keyboard, fighting the autocorrect. And a slow browser, with the sluggish copy-and-paste that iOS 5 has brought to the original iPad (thanks, Apple, I was worried the iPad was too fast before you released iOS 5). So, in terms of the actual task I want to do, no contest.

But (b) means I don't have to get up yet. And the iPad's already here. And I'm comfy. Damn.

Posted via LiveJournal app for iPad.

• Firefox stores cached data by hashing the URL to a value.
• The hash algorithm is weak, and generates duplicate values for similar URLs.
• The cache can only store one cached URL per has value.

def hash(url):
        #Hash starts as zero
        h=0
        #Iterate through the characters of the URL
        for c in url:
                #Take the ASCII value of each character
                cv=ord(c)
                #Rotate the hash value left four bits,
                #as a 32-bit value
                bits1=(h&0xF0000000) >> 28
                bits2=(h&0x0FFFFFFF) << 4
                h = bits1 | bits2
                #XOR the ASCII character value with the
                #hash
                h = h ^ cv
        return h

ben@quad-14:~/working/hashing$ python
Python 2.6.2 (release26-maint, Apr 19 2009, 01:58:18)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from hashcheck import hash
>>> print "0x%08x" % hash("http://worldofsolitaire.com/decks/paris/5/12c.png")
0x40d8c8e9
>>> print "0x%08x" % hash("http://worldofsolitaire.com/decks/paris/5/13s.png")
0x40d8c8e9
>>>

>>> print "0x%08x"%hash("http://khm2.google.com/kh/v=52&x=118346&y=80466&z=17")
0x198cc05f
>>> print "0x%08x"%hash("http://khm2.google.com/kh/v=52&x=118350&y=80470&z=17")
0x198cc05f
>>>

>>> print "0x%08x"%hash("http://khm2.google.com/kh/v=52&x=118346&y=80466&z=17&s=")
0xcc05d095
>>> print "0x%08x"%hash("http://khm2.google.com/kh/v=52&x=118350&y=80470&z=17&s=")
0xcc05d095
>>>

>>> ((3*118346)+80466)%8
0
>>> ((3*118350)+80470)%8
0

substring="Vk52edzNRYKbGjF8Ur0WhmQlZs4wgipDETyL1oOMXIAvqtxJBuf7H36acCnS9P"      #Nonrepeating A-Z, a-z and digits
def differenceEngine(s,a):
        """Use string a to return a deterministic but pseudo-random substring from within substring s"""
        result=""
        #Take the characters of a, which MUST all be digits
        offset=0
        for c in a:
                try:
                        v=int(c)
                except ValueError:
                        #This exception fired if the character is not a digit, which is wrong, but
                        #we should cope without crashing.
                        continue
                offset += v
                #Use the value of this digit as an offset into the string, and take
                #the character at that position.
                p=s[offset%len(s)]
                result += p
        return result

def substringFor(x,y,nmd=None):
        """Return the substring parameter for a URL, given the x, y and nmd values.
        The x and y should be integers, the nmd should be a string - if no date is
        included in the URL, pass an empty string or None."""
        arg=str(x)+str(y)+str((3*x)+y)
        if nmd:
                arg += nmd
        return differenceEngine(substring,arg)

• The hash algorithm is based on characters, so if you use the 'add a substring parameter' approach, base that substring on the characters of the URL, not parameter values.
• Use as many different characters as possible in your substring so that it varies as much as possible; "Galileo" doesn't allow for very many different substrings.
• Build yourself a test setup (feel free to use the hash method above) that you can pass URLs through to spot collisions.  Use that to tune your URL construction code to minimize the collision rate.

class Shape
{
    virtual void Draw{}
    { }
}

class Circle : Shape
{
    override void Draw{}
    { }
}

• It's made up of 81 cells


• They're arranged into 9 rows, 9 columns and 9 squares, each of which contains 9 cells.


• Each cell either contains a number (we'll call these solved), or is blank (unsolved)

• For each solved cell in turn, remove the number it contains from all the unsolved cells in the same row, column and square.


• If, as a result of that, an unsolved cell is left containing only one number, that cell is now solved.


• Keep doing this until either the puzzle is completely solved, or there are no more solved cells to process.

current mood: contemplative

• Back at the end of last year, I had to change jobs, quite suddenly and not out of choice, having been made redundant. It wasn't a pleasant parting of ways, and it turned legal (you should read that phrase as roughly equivalent to and then it turned gangrenous). During times like that blogging is neither fun nor advisable: you don't want to say anything that might get quoted out of context against you. All the legal stuff carried on until a couple of months ago.


• My new job (like many) started off fairly undefined and has only recently evolved to the point where I could say for sure what it is I'm responsible for and where we're going. During times like that, blogging is tricky, since finding your feet in a new organisation is difficult enough without potentially revealing all your incorrect assumptions to everyone you work with :)


• I just flat out haven't had the time or mental bandwidth to come up with anything worth writing about.

static PyObject *wbxml_xml2wbxml(PyObject *self, PyObject *args) {
/*A WB_UTINY is an unsigned char, so we can allow conversion directly from the Python string*/
WB_UTINY *xml;
WB_UTINY *wbxml;
WB_ULONG wbxmllen;
int status;
WBXMLConvXML2WBXMLParams    params;
WB_UTINY *errstr;
PyObject *result;
 
    /* Verify and read a string arg (xml) */
    if (!PyArg_ParseTuple(args, "s", &xml))
        return NULL;
 
    /* Pass that to libwbxml2 */
    params.keep_ignorable_ws = FALSE;
    params.use_strtbl = TRUE;
    params.wbxml_version = WBXML_VERSION_11;
    status = wbxml_conv_xml2wbxml(xml,&wbxml,&wbxmllen,¶ms);
    if(status == WBXML_OK) {
        errstr = NULL;  /*we return None to mean no error*/
    } else {
        errstr = (WB_UTINY *)wbxml_errors_string(status);
    }
 
    /* Build the return tuple of wbxml, error.
    The wbxml string is binary, so we need to convert it with a z#
    rather than a z.*/
 
    result = Py_BuildValue("(z#z)",wbxml,wbxmllen,errstr);
 
    /* Free the buffer that came back from the converter (thanks, Bob!) */
    wbxml_free((void *)wbxml);
 
    return result;
}

[customization] removes some of the predictability from the user interface. One of the benefits of a common user interface is that once you learn it, you can apply the rules generally. But if each user could customize how drag/drop works, then the knowledge you developed with drag/drop wouldn't transfer to other people's machines.

Infinite customizability also means that you can't just sit down in front of somebody's machine and start using it. You first have to learn how they customized their menus, button clicks, default drag effects, and keyboard macros.

current mood: contemplative

1. Open-source database.  There is no religious reason for this.  It's a budget thing.


2. That interfaces well with Python.  More on this below.


3. And that supports Unicode properly.  I mean; has tools that support input and output of international characters sets.  And that does Unicode via the Python interface.


4. Supports transactions.


5. Accessible from Windows tools (ODBC, Python)


6. Runs on Linux.  All our serious development servers run Fedora.

1. Whatever we think we're going to be doing, it probably won't happen the way we think it will.  Columns will change meaning.  Entities will be discarded and new ones appear.  Be flexible.


2. We're going to be gathering data from a zillion different sources.  Any data we capture is going to be dirty and need auditing and cleaning.


3. There's going to be so much data that any manual task applied to the thousands of records we'll have might mean that we'll run out of time.  Automate.

current mood: tired