Farewell, N900

Exactly 1023 (!) days after I first switched on my Nokia N900 (still back in Norway), it stopped working as a phone. It just won’t recognize the SIM card anymore, although other phones think that the card is just fine. This leaves me with an internet and gaming tablet similar to the predecessors of that family.

I was one of the enthusiasts, who spent 600 bucks on the N900 in the idealistic believe that an open phone platform could be a viable alternative to the lock-in world, Apple was creating at the time (and still is, with its iThings). It also seemed to be a good choice compared to the early Android devices available back then. However, from the beginning, I was doubtful that a single non-nerd will buy a phone that was advertised with the slogan raw computing power! I was very pleased with the hardware of the device, which seemed very robust and durable, compared to many other phones. However, with Nokia’s move to Windows Mobile, this was not an option for a replacement. So now I’m a happy owner of a Samsung Galaxy S III LTE, which makes a very slick impression so far. Yay!

BTW: I’m a computer scientist, and don’t tell me that 1023 days is a coincidence! This is exactly the number after which a 10 bit counter (not that anyone [i.e. anyone sane] would be using one of these) runs over. I really have to finish that post about coincidence detection in the brain I drafted some time ago…


NP: Amon Amarth – Where silent gods stand guard

BBQ and range finding code

The other day we had a very nice oriental-style BBQ at my place. Susi made a Couscous salad, while I made some hummus, a bell pepper salad, a salsa with Habanero chilis, and some marinated olives. On the meaty side, we had lamb chops and chicken wings. Very nice food indeed!

The evening ended with us all sitting still in the semi-dark of my terrace watching out for shooting stars. And we even saw some. Even one, which we will remember forever 😉

In the other life (work), I’ve written an algorithm for finding the bordering elements of contiguous ranges in a given array of ordered values. I’ve used rapid prototyping in Python before transferring the solution to C++. The Python code goes like this:

n = [1, 2, 3, 4, 5, 6, 7,    9, 10, 11, 12,      14, 15, 16]
end = len(n) - 1

ranges = []

def get_right(left, step):
    if left == end:
        return left
    leftmost_r = None
    i = last_i = end
    while True:
        match = n[i] - n[left] == i - left
        if (i == end and match) or i == leftmost_r:
            return last_i
        last_i = i 
        if match:
            i += step
            leftmost_r = i
            i -= step
        if step != 1:
            step /= 2

left = 0
while True:
    right = get_right(left, (len(n) - left) / 2)
    ranges.append((n[left], n[right]))
    if right == end:
        left = right + 1

The basic assumption for the algorithm to work is that n contains sorted values. This allows us to do a kind of binary search, if the currently looked at range (from left to i) does not fit the criterion for a match (namely that n[i] - n[left] != i - left). Maybe this is useful for someone!


NP: Agnostic Front – Gotta go

Nerd celebrity

The other day, at that small workshop on Creating, Documenting & Sharing Network Models in Edinburgh, I had the pleasure to listen to a very nice, spontaneous, and entertaining lecture by Steve Furber (a principal designer of the ARM processor, which powers all modern smart-phones). He talked about the history of hardware design in general and explained the role of the different tools for synthesizing circuits from high-level functional descriptions.

A very much recommended book that also circles around the history of hardware is The Soul of a New Machine by Tracy Kidder. And I got reminded of the almost ancient TV show Triumph of the Nerds. Both are definitely worth checking out!