Witter – a basic python twitter client for Maemo

So I wrote last week about developing a basic twitter client. And this week I got the main stuff done, and wanted to share the code example here.

In my looking for help developing apps for Maemo from a start of basically no GTK knowledge or python knowledge I found the examples either too trivial, or way over engineered. So I wrote this intending it to be useful (to me), contain only enough capability to basically read my timeline and tweet. I’ve intentionally not added bells and whistles (yet) and it’s a single ‘monolithic’ app. By which I mean it’s all in a single python file, there is no separation of gui and logic, no nice engineered constructs etc etc.

I hope that it does show an intermediate level example of writing an application for Maemo using Python. This is what it looks like in action

This was taken full screen. The app supports switching in and our of full screen. And it adjusts the width of the displayed text to fit. As you can see the shot was taken not long after completing the application.

It also sorts the tweets using the ListStore ability to just tell it which column to sort on. This is very useful as it means I don’t have to mess around myself. Originally I had it sorting on created_at, but since I was loading that as a String it would order Thursday below Wednesday. Rather than cast the string into a meaningful date object of some form, I just used ID instead, which is a Long. Still comparing as a string, but the number always increments so newer tweets always appear t the top.  Obviously if you prefer newer tweets at the bottom, just flip the sort order to Ascending.

So here is the code, it’s a little under 300 lines, but I’ve commented it pretty well (I think) to explain what it’s all doing.

# ============================================================================
# Name        : witter.py
# Author      : Daniel Would
# Version     : 0.1
# Description : Witter
# ============================================================================

#This is the bunch of things I wound up importing
#I think I need them all..
import gtk
import pygtk
import hildon
import urllib2
import urllib
import base64
import urlparse
import simplejson
import socket

#Initially I found I'd hang the whole interface if I was having network probs
#because by default there is an unlimited wait on connect so I set
#the timeout to 10 seconds afterwhich you get back a timeout error
# timeout in seconds
timeout = 10
socket.setdefaulttimeout(timeout)

#the main witter application
class Witter(hildon.Program):
    #first an init method to set everything up
    def __init__(self):
        hildon.Program.__init__(self)
        #being lazy this just uses basic auth and I am not doing anything
        #yet to store uid/pwd so for the moment just put info here
        self.username = "YOUR_USERNAME"
        self.password = "YOUR_PASSWORD"
        #This being a hildon app we start with a hildon.Window
        self.window = hildon.Window()
        #connect the delete event for closing the window
        self.window.connect("delete_event", self.quit)
        #add window to self
        self.add_window(self.window)
        #For this app I wanted a scrollable area for the tweets to show up
        #so I create a gtk ScrolledWindow
        self.scrolled_window = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
        # as well as somewhere to show the tweets we need somewhere to write a tweet
        # this being twitter we cap the input at 140 chars
        self.tweetInput = gtk.Entry(max=140)
        # we also want a couple of control buttons to load up tweets and submit a tweet
        self.buttonloadTweets = gtk.Button(label="Load Tweets",stock=None, use_underline=None );
        # we connect out load tweets button to the getTweets method
        self.buttonloadTweets.connect("clicked", self.getTweets)
        self.buttonnewTweet = gtk.Button(label="Tweet",stock=None, use_underline=None );
        #we connect the Tweet button to the newTweet method
        self.buttonnewTweet.connect("clicked", self.newTweet, self.tweetInput)
        # a vertical box to set the scrollable window and the button box
        # in the display
        self.box1 = gtk.VBox(False, 0)
        #a horizontal box to put our tweet input box and two control buttons in
        self.buttonBox = gtk.HBox()
        # add the Vbox to the window
        self.window.add(self.box1)
        # create a menu object by calling a method to deine it
        menu = self.create_menu(self.scrolled_window)
        # add the menu to the window
        self.window.set_menu(menu)
        # define a liststore we use this to store our tweets and some associated data
        # the fields are : Name,nameColour,Tweet+timestamp,TweetColour,Id
        self.liststore = gtk.ListStore(str, str, str, str, str)
        # create the TreeView using treestore this is the object which displays the
        # info stored in the liststore
        self.treeview = gtk.TreeView(self.liststore)
        # create the TreeViewColumn to display the data, I decided on two colums
        # one for name and the other for the tweet
        self.tvcname = gtk.TreeViewColumn('Name')
        self.tvctweet = gtk.TreeViewColumn('Tweet')
        # add the two tree view columns to the treeview
        self.treeview.append_column(self.tvcname)
        self.treeview.append_column(self.tvctweet)
        # we need a CellRendererText to render the data
        self.cell = gtk.CellRendererText()
        # add the cell renderer to the columns
        self.tvcname.pack_start(self.cell, True)
        self.tvctweet.pack_start(self.cell,True)
        # set the cell "text" attribute to column 0 - retrieve text
        # from that column in liststore and treat it as the text to render
        # in this case it's the name of a tweeter
        self.tvcname.add_attribute(self.cell, 'text', 0)
        # we then use the second field of our liststore to hold the colour for
        # the 'name' text
        self.tvcname.add_attribute(self.cell, 'foreground', 1)
        # next we add a mapping to the tweet column, again the third field
        # in our list store is the tweet text
        self.tvctweet.add_attribute(self.cell, 'text',2)
        # and the fourth is the colour of the tweet text
        self.tvctweet.add_attribute(self.cell, 'foreground', 3)
        # we start up non-fullscreen, and we want the tweets to appear without
        # scrolling left-right (well I wanted that) so I set a wrap width for
        # the text being rendered
        self.cell.set_property('wrap-width', 500)
        # make it searchable (I found this in an example and thought I might use it
        # but currently I make no use of this setting
        self.treeview.set_search_column(0)
        # Allow sorting on the column. This is cool because no matter what order
        # we load tweets in, we always get a view which is sorted by the tweet id which
        # always increments, so we get them in order
        self.liststore.set_sort_column_id(4,gtk.SORT_DESCENDING)
        # I don't want to accidentally be dragging and dropping rows out of order
        self.treeview.set_reorderable(False)
        #with all that done I add the treeview to the scrolled window
        self.scrolled_window.add(self.treeview)
        # Then just 'pack# the scrolled window and a Hbox into the
        # V box
        self.box1.pack_start(self.scrolled_window, True, True, 0)
        self.box1.pack_start(self.buttonBox, False, True,0)
        #and pack the hbox with input field and buttons
        self.buttonBox.pack_start(self.tweetInput, True,True,0)
        self.buttonBox.pack_start(self.buttonnewTweet, False, False,0)
        self.buttonBox.pack_start(self.buttonloadTweets, False, False,0)
        #setup some urllib things to use to fetch twitter feeds
        self.last_id=None

    def quit(self, *args):
        #this is our end method called when window is closed
        print "Stop Wittering"
        gtk.main_quit()

    def create_menu(self, widget):
        #a fairly standard menu create
        #I put in the same options as I have buttons
        # and linked to the same methods
        menu = gtk.Menu()

        menuItemGetTweets = gtk.MenuItem("Get Tweets")
        menuItemGetTweets.connect("activate", self.getTweets )
        menuItemTweet = gtk.MenuItem("Tweet")
        menuItemTweet.connect("activate",self.newTweet)
        menuItemSeparator = gtk.SeparatorMenuItem()
        menuItemExit = gtk.MenuItem("Exit")
        menuItemExit.connect("activate", self.quit);
        menu.append(menuItemGetTweets)
        menu.append(menuItemTweet)
        menu.append(menuItemSeparator)
        menu.append(menuItemExit)
        menuItemFile = gtk.MenuItem("File")
        menuItemFile.set_submenu(menu)
        return menu

    def run(self):
        #this is the main execution method
        # we set things visible, connect a couple of event hooks to methods
        # specifically to handle switching in and our of fullscreen
        self.window.show_all()
        self.window.connect("key-press-event", self.on_key_press)
        self.window.connect("window-state-event", self.on_window_state_change)
        #this starts everything up
        gtk.main() 

    def getTweets(self, *args):
        #Now for the main logic...fetching tweets
        #at the moment I'm just using basic auth.
        #urllib2 provides all the HTTP handling stuff
        auth_handler = urllib2.HTTPBasicAuthHandler()
        #realm here is important. or at least it seemed to be
        #this info is on the login box if you go to the url in a browser
        auth_handler.add_password(realm='Twitter API',
                          uri='http://twitter.com/statuses/friends_timeline.json',
                          user=self.username,
                          passwd=self.password)
        #we create an 'opener' object with our auth_handler
        opener = urllib2.build_opener(auth_handler)
        # ...and install it globally so it can be used with urlopen.
        urllib2.install_opener(opener)
        #switch on whether this is an refresh or a first download
        if self.last_id == None:
            json = urllib2.urlopen('http://twitter.com/statuses/friends_timeline.json')
        else:
            #basically the twitter API will respond with just tweets newer than the ID we send
            json = urllib2.urlopen('http://twitter.com/statuses/friends_timeline.json?since_id='+str(self.last_id)+'L')
        #JSON is awesome stuff. we get given a long string of json encoded information
        #which contains all the tweets, with lots of info, we decode to a json object
        data = simplejson.loads(json.read())
        #then this line does all the hard work. Basicaly for evey top level object in the JSON
        #structure we call out getStatus method with the contents of the USER structure
        #and the values of top level values text/id/created_at
        [self.getStatus(x['user'],x['text'], x['id'], x['created_at']) for x in data]

    def getStatus(self, user,data, id, created_at):
        #at this point user is another JSON structure of lots more values of which we are currently
        #only interested in screen_name
        #append to our list store the values from the JSON data we've been passed for a tweet
        # the funny #NXNXNX type values are colours I chose a slightly blue for the name
        # and black for the tweet. At some point I intend to do some alternating colours for
        # cell backgrounds to make the display clearer
        self.liststore.append([ user['screen_name'],"#2E00B8",data+"\nposted on: "+created_at,"#000000", id])
        #now we process the id, this is so we can do a refresh with just the posts since the latest one we have
        #if we haven't stored the most recent id then store this one
        if self.last_id == None:
            self.last_id=id
        else:
            #if we have an id stored, check if this one is 'newer' if so then store it
            if long(self.last_id) < long(id):
                self.last_id=id

    def newTweet(self, widget, text_widget,*args):
        #The other main need of a twitter client
        #the ability to post an update
        #get the tweet text from the input box
        tweet = text_widget.get_text()
        #see if we have just an empty string (eg eroneous button press)
        if (tweet == ""):
            return

        #we get the text in the input box then we construct the outbound tweet
        #first we need to encode for utf-8
        tweet = unicode(tweet).encode('utf-8')
        #then we need to urlencode so that we can use twitter chars like @ without
        #causing problems
        post = urllib.urlencode({ 'status' : tweet })

        #build the request with the url and our post data
        req = urllib2.Request('http://twitter.com/statuses/update.json', post)
        #setup the auth stuff
        auth_handler = urllib2.HTTPBasicAuthHandler()
        auth_handler.add_password(realm='Twitter API',
                              uri='http://twitter.com/statuses/update.json',
                              user=self.username,
                              passwd=self.password)
        opener = urllib2.build_opener(auth_handler)
        # ...and install it globally so it can be used with urlopen.
        urllib2.install_opener(opener)
        json = urllib2.urlopen(req)
        data = simplejson.loads(json.read())
        #message sent, I'm assuming a failure to send would not continue
        #in this method? so it's safe to remove the tweet line
        # what I don't want is to lose the tweet I typed if we didn't
        # sucessfully send it to twitter. that would be annoying (I'm looking
        # at you Mauku)
        text_widget.set_text("");

    def on_window_state_change(self, widget, event, *args):
        #this just sets a flag to keep track of what state we're in
       if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
            self.window_in_fullscreen = True
       else:
            self.window_in_fullscreen = False 

    def on_key_press(self, widget, event, *args):
        #this picks up the press of the full screen key and toggles
        #from one mode to the other
       if event.keyval == gtk.keysyms.F6:
             # The "Full screen" hardware key has been pressed
             if self.window_in_fullscreen:
                 self.window.unfullscreen ()
                 #when we toggle off fullscreen set the cell render wrap
                 #to 500
                 self.cell.set_property('wrap-width', 500)
             else:
                self.window.fullscreen ()
                #when we toggle into fullscreen set the cell render wrap
                #wider
                self.cell.set_property('wrap-width', 630)

if __name__ == "__main__":
    #this is just what initialises the app and calls run
    app = Witter()
    app.run()

And that’s it. I used esbox to develop and just had it using SCP/SSH to copy accross to my n810 and execute directly there, which was a pretty easy way to develop.

There are lots of things I will now go on to add to this client. Things like checking for replies/DMs. Being able to make easy reference to an URLs in tweets, and reply to people etc etc. But I wanted to show the code of the bare bones working in case it helped anyone else get started with developing apps for Maemo.

Nokia N900 announced at last.

Last year I wrote about my disturbing Nokia obsession. I had realised that I had become a Nokia fanboy, almost without noticing.

I’ve always had Nokia phones, and they’ve always in my mind been better than the competition. A couple of years ago I found myself with a Nokia 770 internet tablet. Not because I had a great desire for one specifically. Simply that it was a cool looking piece of technology which by then was old enough that I picked one up for 75 pounds. I couldn’t say no for that price.

(Image from wikipedia)

I found that I liked it a great deal, though it was slow and buggy, I had bought into the *idea* of an internet tablet, a mobile computer. And so a year on I bought my n810 which was the latest in their internet tablet line. Still being a high priced item at the time I bought mine second hand.

Mine is the one up there in the banner.

image from mobilelinuxinfo.com

It has been hands down the best device I’ve ever owned. I really do love it. Despite that it does have it’s flaws. It’s not as fast as I’d like, and it only connects over wifi, or phone tethering. So when I started to hear rumours of the next ‘tablet’ the N900 I was hopeful for a device that would just tidy up the downsides of the 810.

Of course since my 770, there has been a revolution in smart phones brought about by the iPhone. Half the people I know have one. They all seem to love it, but it’s never quiet convinced me. Just too locked down, all sorts of little things you can’t do. It’s a fabulous device, it’s perfect for mass market appeal clearly. But it is not for me, instead I have obsessively followed the progress of the next Nokia device.

I started following engadget and sitting on the internet tablet talk forums (since renamed talk.maemo.org) and listening out for news. I quickly discovered the code name for the next level of the Maemo operating system was fremantle. It already had a roadmap published for alpha thought to beta levels. And so we all knew that the next device would come sometime between July and the end of the year.

Much speculation occurred on the forum, wishlists were compiled. It became clear that there a lots of different use cases out there. Some were keen for smaller, others keen for bigger. Some who love their n800 who were never convinced the n810 was worth an upgrade were hoping for something without hardware keyboard. Others like myself would have been devastated at the perceived backwards step if that had been the case.

Some complain that it must fit easily in the pocket, sometimes I feel these people are looking for an accessory to an outfit rather than a tool. Personally I just wear combats with bigger pockets! The gadget dictates the clothes not the other way around.

Overall it really exposed what a tough job making the next ‘must-have’ gadget is, everyone wants something different. Not just different, but conflicting. There would simply be no viable way to please all the opinions, and that was just from the already bought in users. In my own line of work I frequently comment that whilst pleasing our customers is one thing, we also need to understand what those people who have yet to buy our stuff want. The potentially much larger audience who didn’t think the last thing you did was good enough to warrant a purchase. So just pleasing those people who did is only half the picture.

Around mid-spring came the first ‘leak’ in the form of a set of specifications. Which included ‘3.5″ screen’ …disaster! A smaller screen! That’s not what I wanted to hear. I had said on the forums that I would be a sure and certain buying even if all they did was give me something that looked exactly the same as my n810 but with a faster processor and a 3g data connection.

The rumours were given confirmation from apparently reliable sources, and the speculation and debate could kick into a higher gear. The common message for those of us who thought the smaller screen was a terrible idea was ‘wait until you see it, don’t judge it too soon’ People calculated stupid stuff like how much closer to your face you could hold it to perceive the same relative size. And pointed out it would not take much. I remained unconvinced.

Later on the next rumour, a leaked schematic showing a 3 row keyboard and no d-pad. If the screen size issue was contentious, it was nothing compared to the keyboard issue. Those die hard fans of the N800 have never forgiven the n810 for putting the d-pad on the keyboard rather than on the face. Just hiding it away in the sliding mechanism was considered bad. But none at all! What were Nokia thinking?
Personally I could cope without the D-pad, but the smaller keyboard was cause for concern. And those who live with languages more complex than standard English pointed out that it’s already hard enough to enter commonly used characters and symbols for them. Less keys would only compound the issue.

Again the message from those in the know. ‘Don’t judge it until you’ve tried it.’

As the weeks wore on, the impatient bemoaned Nokia not giving us more information, why keep silent. What harm in giving us some dates? What harm in putting our minds at ease, would there be multiple versions. We’ve heard rumours, spotted code names in source code that point to at least one other device. Would that be a ‘proper’ tablet? Of course everyones view of what a ‘proper’ tablet might be is different.

The last week Eldar Murtazin of mobile-review.com leaked the mother load of images. Pictures of the device from all angles, dozens of pictures of the OS. Though he held back, no video demo, just static images. But it included his impressions, and he was impressed. And importantly it confirmed that this wasn’t just going to have a 3g data connection. It was to be a full on smart phone.

YES cried some, NO cried others.
A phone means a phone contract, and a price hike. For those who really were not interested in a device to be a phone the thought of paying for this unwanted ‘feature’ is terrible. For others who dream of a convergence device, their wishlists were being fulfilled.

I found myself coming around. I’d been worrying that this would not be a suitable replacement for my beloved N810 internet tablet. But a replacement for my phone…that’s a different story.

Then Yesterday Nokia finally made a formal launch at maemo.nokia.com

(Image from engadget)

Oh Boy! Suddenly after over a year of speculation and rumour hunting, there it was. In all it’s PR glossy glory. The videos look great, the device looks great. And now I remember…I never set out to get an internet tablet. I just bought a cool piece of tech for a low price. And got sold on having computing power in my hand anywhere I am. So maybe I should just trust that Nokia know what they’re doing. That a convergence device can meet all my needs. One thing is for sure, short of a devastating review telling me that it doesn’t actually work, then I will be buying one the moment they’re available.

Despite the fact that it will likely be a crazily expensive gadget. It has been announced at 500 euros less tax. So I’d guess around 550 quid.

How can I justify this high price for a tiny device? Well I don’t have a laptop, I do all my home computing on my n810 and will transfer to the n900. Nokia are marketing this as a mobile computer. And I know already that I will use it as much of more than my 810, which is every day, a few hours a day. Having not paid full price for either my previous 2 devices. Nokia I feel has earned me being in the horribly over charged group of early adopters. Yes the price will drop if I’m just patient. But I’ve been patient long enough. Roll on October.

Nokia ….just tell me where to send my money.

Riding with the n810

I mentioned previously that I was learning to ride a bike, trying to get to a standard good enough to ride on roads. Well I think I’m there, and yesterday I made the journey to work and back. I still had Kat to ride with, so she could show me the way, and I wasn’t entirely relying on my own ability to signal. The journey is about 7 miles in each direction. So I think I can say I’ve done some serious cycling now.

On the way back I decided to run maemo mapper on my n810. And have it store gps trace of the journey. I don’t normally use maemo mapper for much. Whilst it is a cool application, I think it will only really come into it’s own on the next internet tablet which will have built in 3g. Since it requires a network connection to download map tiles as you go.
That said I do have quite a lot of map tiles cached for my surrounding area, so it was able to show me on the map. But of course I wasn’t looking at the map, I just switched it on, stuck it in my pocket and forgot about it.

After we got home I saved the track as a gpx file, then went in search of a site that would do interesting things with the infomration. I found http://utrack.crempa.net/
This site let me upload my gpx file, and it generates a pretty cool report. What’s even better is that it worked from my n810 (although it was a little slow to load) The report shows a google map with your track ontop. But also the graph of elevation over distance, elevation over time, distance over time, speed over distance, speed over time, various statistics about maximum and minimum speed. Speed whilst climbing in elevation, speed whilst dropping in elevation.

Just a whole load of cool stats.

My track included a bunch of wandering around to begin with before we actually set off on the homeward journey. So it reported the journey as about 8.2 miles. But I believe almost a mile of that was just wandering. So the graphs over distance where slightly better for me, as my wandering didn’t cover much distance but did take up a chunk of time.

So you can see that for a big chunk of the time no real distance was covered. Then it’s clear when we set off in earnest for home.

The elevation chart is interesting, and shows very clearly the point we get to otterbourne hill.

It’s also clear from the speed chart that we walked up most of the hill, then had fun going fast down the other side

It was cool to see that my top speed was 23.7 miles per hour. Not bad on a bike, and it will be interesting over time to see how I improve (or not) on the various stats.

Utrack also lets you export the report as a pdf, so you can keep it in already processed form.

That was yesterday, and today I don’t feel too bad. I can deffinatly feel a couple of specific muscles that I clearly haven’t really worked much before. But I’m seriously considering doing the ride to work on Tuesday. I won’t do Monday, because I need to go do a weeks shop after work. And I won’t do Tuesday is the weather is bad, I will be a fair weather cyclist. But I think it will be a good way to occasionally do the work trip without a car. Saving the environment and my petrol bill, if only by an incredibly small amount. But more imporatntly a good way to get some exersice in a slightly less contrived way than just going to the gym.
The main advantage I think is that it’s a very specific goal, and you can’t just decide to quit early. And I came home feeling like I’d achieved something, been somewhere. I was not bored. Whereas the gym is always an effort to make myself go, even though it is only a 20 second walk from the house.

It is also cool to find yet another awesome way to use my much loved n810. I’ve said it before, and I’ll say it again. It is the best device I’ve ever owned. I will continue to track my trips, and see what the stats have to say about how I change over time. Will my top speed increase? Or just my average?

I guess watch this space to see if I get into this cycling thing, or if I find it just as easy to not bother cycling as I find it to not bother going to the gym.

Navit Update

It’s been a while since I’ve done much with Navit. My regular week doesn’t include much travelling and I’ve just not had that much time to devote to it. When push comes to shove, my wood turning normally wins when competeing for my free time.

However, I had a chance to play again this week with the latest SVN-2173. I also had an idea of something to try. I downloaded a map of a much smaller area. Normally I get most of the united kingdom, which amounts to about 80MB map. But I decided to try capturing just around about the county I live in. This got me a map of just 17MB.

It’s dificult to quantify the differences, as there is no benchmark mode to try. However, my feeling is that the smaller map led to a more responsive UI once I had a route planned. Normally having a route planned causes my n810 to become largely unusable, However with the smaller map it seemed to be better. Not great, just better.

Today I tried a back to back comparison, as I had previously been going on memory of last use, on a different build. And Lots has changed since then. (Look right, there is an rss of the changes going on, and there is normally a lot of activity)
So I setup with a short route planned and tried both my regular size of map and a smaller size of map, one after the other. I also used maps cut on the same day, so no diffference in content for the area I’m in.

The main thing I notice is that tapping to go into the menu system seemed to take much less time, I counted something like 10/11 seconds with the large map, and more like 2/3 with the smaller map. (Still not blistering by any standards, but deffinately better).
My caviat to this is that I really can’t be sure that equivilent provessing was going on each time. GPS signals can be a little wild, and a couple of ‘off’ readings could of had the unit attempting to replot routes in one test and not the other. However my *feeling* is that the size of map does effect it’s performance. Even when showing the same sized area of the map, and plotting the same and similar length routes.

I’d love for other people to try the test and see what they think, am I imagining it? If anyone else tries please let me know what size of maps you compared, and what country etc.
In the meantime I’ll go chat in #navit and see if the guys there have any idea why it should make a difference. And if they have any ideas for a more scientific test.

Work around computers? Or have them work around you?

I’ve been thinking recently about the way my computer use has changed over the years as technology has progressed. And I started thinking about how it’s not uncommon to say that you ‘work around computers’.

Certainly this is how it is with desktop computers. I used to have one sat in the study, all wired in. If I wanted to do anything on line or use the computer I went to it. Sat at the desk and worked around it.

When I got my first laptop I got my first taste of mobile computing, being able to do work from the sofa, or even sat out in the garden if that’s what I wanted. A taste of freedom and flexibility.
When I got my first Internet tablet, my thought was simply that certain things I’d be able to do without having to boot up my laptop, check e-mail, some light browsing etc.
I still assumed that I’d want to do a great deal on the laptop. And obviously if it was already powered up I’d use that for preference.

And then along came my nokia n810 and over time a subtle shift occurred. I have talked before about how much I like this device, but it was only a couple of weeks ago I realised that I now prefer it out right to using a laptop.
During the recent snow in the UK I had to work from home. And so I spent all day with my laptop. And into the evening it was already there and booted up. And yet I found myself wanting to just put it away and use my n810. And I realised that I was still working around my laptop. Yes I can use it where ever, but once you’ve picked a location it’s not actually convenient to move around. You can have it on a lap but it’s not that comfortable. IT gets hot, it forces you to stay in one position. You can have it on a table or desk but then you’re stuck there.

I believe my Internet tablet gives me something close to true freedom, I started writitng this post stood in my kitchen, walking about the house getting ready to come out, I could put it in my pocket whilst doing things, and quickly retrieve it to write a few more sentences on it’s thumb board whenever and wherever was convenient. Now I’m out at my cafe of choice ‘boswells’ and I am using my bluetooth keyboard to give me something close to the laptop experience. And yet I can easily switch back to typing on the thumb board and continue where ever.

Obviously other factors are that it has a really great LCD screen, it is a pleasure to look at and work with.
It’s fast enough to be pretty capable of most of the tasks I want it to do. And those which it can’t I off load to my mythtv server.

The only thing that limits the freedom of this device is that lack of built in 3g support. I’m confined to where I can find wireless, or I have to take the extra step of tethering with a phone.

This slight limitation is due to be removed in Nokia’s 4th generation Internet tablet currently in development. Having gone from buying a nokia 770 because it was cheap, and upgraded to my n810 by buying second hand on ebay. I am now actively watching for latest news of the next tablet codenamed rx-51. Unless nokia does something truly horrible (like make it without a hardware keyboard) then I shall pre-order one as soon as I can. I’m not sure I even care if it’s much faster than the n810, though that will be a nice bonus.

I believe this is the future of computing. More than simply being mobile, it’s about devices which are usable whenever wherever, it;s about devices that work around you not the other way around.