The Logitech Trackman Wheel Trackball Mouse (to give it its full, silly title) is an entry level trackball input device. I recently picked one up in an attempt to combat some soreness I’d been experiencing in the wrist area after a long day’s work!

I chose this device because it was competitively priced (just £24.99 from play.com) and I didn’t want to spend any more than that without knowing how I would react to a different type of input device.The mouse plugged straight into a USB port and ‘just worked’ out of the box. I use it at work on an  Ubuntu machine, and there was no faffing around with drivers or anything like that – just plug and play.

The mouse is nice and big, and to me, it’s comfortable to use. I have pretty big hands (stop sniggering at the back!) and I feel like my hand is just resting on it while I use it. I’ve noticed a significant lessening of wrist pain and fatigue after using this mouse.

I’ve been using a standard mouse for around twenty years now – about two-thirds of my life – so I was initially a little concerned about how long it would take to get used a trackball mouse.

My first instinct when using the Trackman was to turn up the mouse speed. In particular, you might feel there’s a little more effort required in moving the mouse around if you’re using two or more monitors.

I also found that for the first week or so, my pointing and clicking accuracy was lower than usual, so allow yourself some time to acclimatise. However, it became second nature to me pretty quickly after that. In fact, it feels weird going home to use a ‘normal’ mouse now!

If you’re looking for something a little bit different, or you’re concerned about aching arms, you could do a lot worse than this mouse.

Nominations are available in the following categories:

• Open Source CMS Award
• Hall of Fame CMS
• Most Promising Open Source Project
• Open Source E-commerce Applications
• Open Source JavaScript Libraries
• Open Source Graphics Software

You don’t have to vote in all categories; this year, I’ll be voting in three:

Open Source CMS Award

For this award, I’ll be voting for CMS Made Simple.

At work we use a variety of CMS depending on the client’s needs, amongst them Joomla!, Drupal and CMS Made Simple. CMSMS has an extremely smooth learning curve; we’ve seen time and time again that even the least technical people can use it with ease. We have never needed to give anyone a second training session on CMSMS! (If only we could say the same about Joomla! )

Most Promising Open Source Project

I’ll be voting for node.js for this one. We’re starting to see some really exciting and interesting demonstrations of the power of this framework, and I’ll be keenly watching its development.

Open Source JavaScript Libraries

I have to vote for jQuery for this one. It’s no exaggeration to say that jQuery has transformed the web; it has certainly transformed the way I write JavaScript, and it makes my life easier on a day to day basis.

These days I’m enjoying MooTools more and more, and I intend to use it for as many projects as I can, but I’m not quite there with it yet.

Feel free to share your votes in the comments!

I recently wrote an entry for 10k Apart, the competition to create a web app in 10k or less. You can see my entry here.

The code comes in at about 8k all in, and I have to thank my colleague Allan for the graphics!

There are big changes afoot!

I have a new domain (loving the new URLs!), new hosting, and a bit of a change of colours on the blog.

Hosting has been moved from 2mhost to Linode. 2mhost has always worked well for me. I initially joined them because they provided cheap PHP5 hosting at a time when this was far from commonplace, but for me, their uptime and support has been excellent – far better than I would have expected from their price point.

I made the change to a VPS solely because I wanted more flexibility, and Linode have so far been excellent for me. They offer a wide choice of Linux distros (I went for Ubuntu 10.4), full shell access, and a managed backup solution for very, very reasonable rates. There’s even an android app to help you manage your account!

I would happily recommend both hosts at this time.

Please let me know if you come across any 404s or gremlins lurking here after the site move!

(Disclosure: link to Linode contains my referral number. But rest assured, if I fall out with them, I’ll be posting that here too!)

One of the major changes to Django 1.2 was the automatic switching-on of CSRF protection. I ran into some problems today, hitting the following error.

Forbidden (403)
CSRF verification failed. Request aborted.

Thirdly, the Django site in question was a relatively small, internal, non-client facing site.

With all that in mind, I took the decision to turn off Django’s CSRF protection.  I had to dig a bit to find this information, so hopefully it helps someone else.

You probably shouldn’t do this: CSRF protection is a good thing!

Implementing the following as middleware will do the trick.

class disableCSRF:
    def process_request(self, request):
        setattr(request, '_dont_enforce_csrf_checks', True)
        return None

A wealth of tools are available to debug and test Django applications, but knowing when and how to use these resources can intimidate the new user. Django 1.1 Testing and Debugging, by Karen M. Tracey, aims to walk the user through the process of creating a web application from scratch, ensuring that the resulting code is bug-free and ready for production.In a way, Django makes it deceptively easy to write a dynamic web application. With a few lines of code, you can have an fully functional application up and running in a short space of time, and complex applications take less time than ever to develop. Inevitably, though, bugs will creep in to the development process, and the professional developer will want to make sure that their application is as bug-free as possible before launching.

The book opens with a simple question: “How do you know when code you have written is working as intended?” The answer, of course, is that you test it. But if you’re not a cowboy coder, you’ll want to leverage the full power of Django’s automated testing framework for best results. In the course of this book, the author develops a full web application, from start to finish, and describes how each section would be tested and debugged.The author’s intended audience for this book is perhaps one that is relatively new to Django. Ideally, the reader will have a functioning installation of Django, will have worked through at least the tutorial, and may well have written a couple of applications. This book would also be excellent for someone migrating to Python from another language, or moving into MVC frameworks for the first time. Crucially, the book doesn’t just explain how to test, it also explains when and what to test too, so it serves as an ideal introduction into testing in general. There are many code examples and screenshots, and each line of code is fully explained.

The book kicks off with an examination of doctests and unit tests. Their relative pros and cons are explained in some depth, and the author does a great job in this section of discussing exactly what you should be testing, initially beginning with data models. She then moves on to more advanced unit testing strategies and applications, such as testing views and customizations of the admin area.

One of Python’s greatest strengths is its ecosystem, and the following chapters cover some of the other tools you might want to integrate into your project. Django-coverage provides reporting on how much of your code is covered by tests, and Twill is a package that essentially replaces Django’s test client to provide enhanced functionality — particularly for working with forms. Both packages have fully explained and in-depth examples to work through. (Code downloads are available at Packt Publishing‘s web site for the terminally lazy!)

With the testing section of the book complete, the author moves on to the debugging section of the book. Starting with the very basics (setting up Django in debug mode), the book then takes a detailed look at the Django debug page. This is something that I could see being useful for many new users — the debug page contains a wealth of information (and not all of it is always entirely relevant, if not outright misleading), so learning to understand this page is crucial to your success as a Djangonaut.

The book then takes a tour of the excellent django-debug-toolbar, before moving on to what was, for me, the most valuable chapter of the book: “When you don’t know even know what to log: Using Debuggers.” This chapter introduces the PDB (Python Debugger) library.

Like many others, I suppose, Django was my first introduction to Python. For that reason, my knowledge of the standard library is perhaps not as strong as it could be. For me, learning about the different ways of using the debugger was the highlight of the book, and something that will probably change the way I develop with Django.

The book concludes, of course, by taking the application into a production environment. And in line with the latest advice, that means setting up the site using Apache and mod_wsgi. In keeping with the theme of the book, the most common issues in deployment are identified and resolved.

This book weighs in at over four hundred pages, and its greatest strength is its wide scope. Although the basics of testing in Django are easy to understand, it’s another thing entirely to see an entire application built from the ground up with testing at the forefront. As I mentioned before, the focus is as much on developing a testing and debugging strategy as it is on the technical aspects.

From a more technical point of view, the subject matter ranges from beginner to advanced. From writing the most basic doctests to debugging multi-process race conditions, the difficulty level increases incrementally, and no important details are skirted over. The prose is well-written and easy to read throughout.

If I had one gripe about the book, it would be that in places, it goes into a little too much detail. There’s a section on using the Django web site (the bug tracker, the mailing list etc.) that I could have done without entirely. Although it might be useful for some users, the site is pretty self-explanatory and doesn’t really warrant the attention it gets, in my opinion.

You shouldn’t let that put you off though — this really is an excellent exploration of the topic. In addition, Packt Publishing will make a donation to the Django project for every book sold, so in purchasing this book, you’ll be indirectly helping the project financially too.

This book is worth a place on any Django developer’s bookshelf.

I’ve always meant to take a closer look at Plone. It has an excellent reputation for being a robust, scalable, secure CMS used by all sorts of organisations, large and small. The lack of cheap, shared hosting had put me off in the past, but that’s really no excuse for not checking out a great CMS (particularly with the rise of cheap virtual private servers.)My favourite publisher, Packt, have a couple of new books out for Plone (Plone 3 Products Development Cookbook and Plone 3 Multimedia.) Their books are always really well written and there’s the added incentive of 20-30% off at the moment! On top of that, they’re doing a running a prize draw, with Amazon and iTunes vouchers as prizes, to anyone buying these books in the first two weeks of release!

You can check out the promotion here.

If you want to iterate over an object in Python, the simplest (and most Pythonic?) way is to use a generator. A nice simple example to demonstrate the utility and power of this technique:

class Foo(object):
    def __init__(self):
        self.mylist = [1,2,3,4,5]
    
    def __iter__(self):
        for i in self.mylist:
            yield i

You can then do:

>>> f = Foo()
>>> for i in f:
       print i
1
2
3
4
5

Concise, clear, and functional.

I recently treated myself to a shiny new HTC Desire – partly to learn more about Android development, and partly because, well, I wanted one.  :) It’s a great piece of kit, and I would wholeheartedly recommend it.

I wanted to debug apps on the handset rather than the simulator, but like many others, I had big problems installing drivers under Vista (32 bit). The solution, for me, was to install HTC Sync.

After a good hour of struggling, this installed in minutes and solved all of my problems. Hopefully this saves someone else some time!

Lately I’ve been getting an awful lot of requests for ‘Web 2.0′ features. I’ve always hated the term for a number of reasons.

Web 2.0 was supposed to mark a paradigm shift in the way web sites operated. It promised interactivity and community in an age where sites were static. While we certainly see more of that these days, you also have to remember that these philosophies have been central to the web for many, many years. Amazon was founded in 1994 and Ebay in 1995, and both sites heavily featured user-generated content, even in the early days. In fact Tim Berners Lee described Web 2.0 as:

…people to people. But that was what the Web was supposed to be all along.

Certainly, there’s a look and feel associated with Web 2.0, largely dictated by emerging technologies and limitations of the day. Some of the most representative Web 2.0 technologies, Javascript (created in 1995) and AJAX (1999) have been around for over a decade now. In Interweb years, that’s an age! In fact, a lot of what was erroneously described as AJAX was simply good ol’ fashioned DHTML, re-packaged and re-branded for a new audience.

My biggest beef with Web 2.0 is that it’s frequently used as just another point on the checklist of requests, without any thought as to what such features actually are, or whether they’re appropriate for the site and audience. As in, “we need the site to be usable, accessible and Web 2.0″. As such, the term is completely meaningless! Much better to find out from your users what features they actually need, and go from there.

I’ve even been asked if I can “do” Web 2.0. I usually answer that any features are possible given the right budget. Whether or not you want to give them a label of Web 2.0 is up to you!

I guess the take home message for this article is exactly as the title of this article says: stop paying lip service to a marketing term, find out what your users really need, and implement it.