But, it turns out this kind of thing is not good for your health – who knew? Those of you who know me or keep up with my blog know that I’ve been dragged kicking and screaming away from my old ways, because of back issues that I initially ignored, then tried to cope with using token accommodations, and finally succumbed to in a big way. Being self-employed, this was a major problem. Crawling out of the pit I dug for myself took a long time and a lot of frustration – I read quite a few productivity books on the subject to try to find answers on how to keep working, and in the end found that the answers you mould for yourself tend to be the best ones. I’d like to share one of the things I learned along the way.

But I’m ‘In The Zone’!!

So, I want to talk about the biggest problem I encountered: concentration periods. I can’t sit at a desk for longer than about an hour at a time now; if I don’t get up and walk around, do some gentle stretching etc, at least this often, I’ll pay for it badly once I do move, and probably over the next few days too. I also can’t realistically work more than a standard 8 hour day without pain any more. The problem with this was that, as a programmer, the style which I developed over 15+ years involved getting gradually ‘Into The Zone’ and coding for very long periods at a time, uninterrupted. This is a common theme among coders, who like to shut themselves away for hours at a time, wear headphones to avoid distractions, have ‘quiet times’ and so on – and it’s also why we tend to react really badly when interrupted. Programming requires concentration, and concentration seems to run on a valve system – it takes time to warm up, and once it’s going, you don’t want to turn it off because starting it up again is a major hassle.

I thought there was no way around this, and had begun to resign myself to just being less productive because of it. However, over the last 6  months in particular, I’ve discovered that, far from being an intractable problem, this ’slow warm up, long uninterrupted focus time’ approach is to a large degree a learned behaviour, and it’s possible to re-train yourself to cope with things differently. It’s a little like when people learn to adopt polyphasic sleep patterns – it’s not that you can’t do it, it’s just that when you’ve become accustomed to doing things a certain way, changing that is initially very, very hard. But it’s not impossible, given the right amount of motivation and time to adjust.

So, my goal was to acclimatise myself to many shorter work chunks during the day instead of a few very large ones, while still maintaining productivity. The key to this was to learn how to get back ‘In The Zone’ in the shortest time possible – much like the way polyphasic sleepers train themselves to achieve REM sleep more quickly. I’m mostly there now, or at least way better at it than I was, so, what techniques did I use to make this transition?

1. Embrace interruptions
   This is less of a technique and more of a deliberate psychological adjustment which cuts across all the practical approaches I’ll cover next. Instead of being the typical coder who avoids interruptions at all costs, you need to accept them, and learn to manage them better. It’s hard – you have to try to set aside years of resisting interruptions and initially, until you adjust, you’ll feel like you can’t get enough done. Many people will probably want to give up, unless there’s something specific motivating them to push through it – for me, daily pain was a great motivator. My main message here is that the transition is just a phase, and that it is possible to be an interruptable programmer who still gets things done. But you have to learn not to fight against it, hence why this is the first point.
2. Maintain context outside of your head at all times
   Much of the problem with interruptions is that of losing context. When you’re in that Zone, you’re juggling a whole bunch of context in your head, adjusting it on the fly, and maintaining and tweaking connections between issues constantly. Interruptions make you drop all that, and it takes time to pick it all up again. My answer to this was to externalise as much as possible, on as many levels as possible:
   1. Maintain a running commentary on your current task
      I am my very own chronicler. I write notes on what I’m doing all the time, whether it’s adding a comment line to a ticket, committing frequently and writing detailed commit notes (you do use a DVCS to make light commits more practical, right? ) scribbling a drawing on (ordered) pieces of paper. This really isn’t that onerous, and in fact externalising your thoughts can often help you clarify them. Basically the guide is that roughly every 30 minutes, I should have generated some new piece of context which is stored somewhere other than my head. If I haven’t, then that’s context I’d have more trouble re-building mentally if I’m interrupted. It doesn’t take much time to do, and it has other benefits too such as recording your thought & decision process.
   2. Ruthlessly ignore tangental issues
      You might have noticed that in the last bullet, I used the words ‘current task’, singular. Not ‘tasks’. There is no such thing as having more than one ‘current task’ – there is only the one task you’re actually working on, and distractions.
      We probably all use bug trackers / ticket systems to track bugs and feature requests, but when you’re working on a ticket, it’s very common to spot a new bug, or identify an opportunity for improvement, or think of a cool new feature. How many of us go ahead and deal with that right away, because it’s in the area we’re already in, or it’s ‘trivial’, or it’s a cool idea that you want to try right now?  I know I did – but I don’t any more; any tangental issues not related to what I’m currently doing get dumped into the ticket system and immediately forgotten until I’m done with the current task, regardless of their size, relevance or priority. It sounds simple and obvious, and this might even be official procedure in your organisation, but I challenge most coders to say that they actually do this all the time. The benefit is that even the tiniest of distractions add an extra level of context that you have to maintain, which is then harder to pick up again after an interruption.
      For this to work, you need a ticket system which is fast, lightweight, and doesn’t require you to be anal about how much detail you put in initially. You need to be in & out of there in 30 seconds so you can offload that thought without getting distracted – you can flesh it out later.
   3. Always know what you’re doing next
      This is one from GTD (‘Next actions’), but it’s a good one. When you come back from a break or interruption, you should spend no time at all figuring out what you need to be doing next. Your ticket system will help you here, and so will the running commentary that hopefully you’ve been keeping on your active task. If you’ve been forced to switch gears or projects, so long as you’ve maintained this external context universally, you should have no issue knowing what the next actions on each item are. The important thing is to have one next action on each project. If you have several, you’ll have to spend time choosing between them, and that’s wasted time (see the next section on prioritisation). At any one time, you should not only have just one current task, but one unambiguous next action on that task. Half the problem of working effectively is knowing what you’re doing next.
3. Prioritise Negatively
   I mentioned next actions in the previous section, but how do you decide what comes next? A lot of time can be frittered away agonising over priorities, and I used to struggle with it; I would plan on the assumption that I wanted to do everything on the list, and I just needed to figure out which I needed to do first. I discovered that I could cut the amount of time I spent on planning, and also get better, less ambiguous priorities by inverting the decision making process – to assume a baseline that I wouldn’t do any of the tasks, and assessing the negative outcomes of not doing each one. So instead of ‘which of feature A or B is more important to have?’, it became ‘Let’s assume we ship without feature A and B. What are the issues caused by omitting them in each case?’. It might appear to be a subtle difference, but having to justify inclusion entirely, rather than trying to establish a relative ordering assuming they all get done eventually, tends to tease out more frank evaluations in my experience.
4. Recognise the benefits of breaks
   Much of the above is about limiting the negative aspects of taking breaks, but the fact is, that they have many work-related benefits too. I’m willing to bet that all coders have stayed late at work, or late into the night, trying to fix a problem, only to find that they fix it within 15 minutes the next day, or think of the answer in some unlikely place like the shower. The reason for this is very simple – extended periods of concentration seem productive, and can be on operational / sequential thinking, but for anything else such as creative thinking or problem solving, it’s very often exactly the opposite. Not only do tired minds think less clearly, but often the answer to a problem lies not in more extensive thinking down the current path which you’ve been exploring in vain for the last few hours, but in looking at the problem from a completely different perspective. Long periods of concentration tend to ‘lock in’ current trains of thought, making inspiration and strokes of genius all too rare. Creativity always happens when you’re not trying, and it’s an often under-appreciated but vital element of the programming toolbox. Interrupting that train of thought can actually be a very good thing indeed.

There’s more I could talk about, but that’s quite enough for now I think. I hope someone finds this interesting or useful

If you’re an iOS developer, you’ll be wondering why this deserves a blog post – it’s easy to do in Cocoa Touch! Well, yes it is easy on iOS, because Apple have specifically allowed you to design table view cells in Interface Builder. When targetting Mac OS X though, it’s actually pretty awkward, and here’s why: in Cocoa Touch, the class which draws the cells in a table is UITableViewCell, which is a subclass of UIView – meaning you can drag one onto the canvas in Interface Builder and lay stuff out right there. In Cocoa, in contrast, the cell is simply represented by NSCell, which is not an NSView subclass. This means Interface Builder will not let you play with them, you draw them by implementing drawWithFrame:inView: instead. I think Apple realised the problem with this design in time for Cocoa Touch but obviously felt they couldn’t break the existing Cocoa interfaces. There are also many differences between the instantiation of NSCell versus UITableViewCell – there’s only one NSCell for all rows in a table / outline view, compared to a type-indexed pool in Cocoa Touch.

The problem boiled down to this: if the contents of your table / outline cell is non-trivial, or if you just don’t want to write a bunch of layout code, it’s a PITA to implement a custom look in NSOutlineView, such as the one in the picture, especially if you want custom controls embedded in it. For my current Cocoa app, I really wanted to design my cells (and I have 2 different styles for group levels and detail levels) in Interface Builder to save me hassle, including using Cocoa Bindings to hook up some dynamic fields within. Many internet searches later, and mostly the answer I found was that it couldn’t be done. Luckily, I’m too stubborn to take no for an answer, and eventually I figured out a way to do it. Details are after the jump, with an example project to show it in action.

Code Example on BitBucket

Note: The project is written with garbage collection required, that’s because my original project uses that approach (I’m happy to require ObjC 2.0 / Leopard and don’t have a need for low-level memory control in this project) and I didn’t have time to retrofit old-style retain/release patterns to it. If you still use manual memory management in Mac OS X you’ll need to alter the code.

The answer to this problem involved several pieces:

1. We need a tree model to hold our data. I’ve included a pretty standard node implementation in the example (ModelTreeNodeBase), and then subclassed it for the specific example (MyTreeNode)
2. Since we can’t design NSCell in Interface Builder, we need to design an NSView instead – in this case I designed one for the group level, and one for the detail level, but you could do more or less if you wanted. For convenience, I put both in one nib (CustomCells.xib).
3. We need to attach our NSViews as subviews of the outline view, in the appropriate place, at the right time, in order to display them. I do that in our custom NSCell subclass, CustomCell
4. Since there is only one instance of NSCell for all data rows of an outline view, we can’t use that to hold row-specific information, such as binding values to fields. So, I use a controller called CustomCellController which provides the linkage between the cell view and the model node (appropriate MVC practice). I use Cocoa Bindings to pull in data from this controller’s node per row, see the CustomCells.xib setup.
5. Again because there’s only one NSCell instance, we need to associate the specific controller instance for the correct row with the NSCell just before drawing. I do this in the NSOutlineView delegate method outlineView:willDisplayCell: , which you’ll find in the CustomOutlineViewAppDelegate in this case.
6. The association between the model node and the controller is kept in a simple NSDictionary, just to keep the coupling loose. Note that I use the model node itself as a key (which is why we’ve implemented the hash and isEqual methods in the model), in my app this is useful anyway because to identify a node uniquely regardless of content values is required.
7. Because we’re manually attaching our subviews on display, we also need to remove them at the right time. I do this on outlineViewItemDidCollapse: (and in the real app, I also do it when deleting rows and on drag/drop)
8. Outline views allow you to click or press enter to edit the main title text, and I support this here too. I have to do a bit of work though, firstly to make the edit box appear in the right place (see CustomCell’s editWithFrame: and selectWithFrame: methods) based on where we’ve placed the text in our custom view, and also to place the ‘hit box’ in the right place – in my case I’ve allowed the hit box to extend over the entire cell, barring the other controls which take precedence if the mouse hits them. See CustomCell hitTestForEvent: for that code.
9. I also do a little bit of presentation nicety by changing the colour of the text when the row is selected. You get this for free with NSOutlineView normally, but since we’re using custom views, you don’t automatically get inverse video on text, so we have to do that ourselves.
10. To make the cells resize correctly, you use Interface Builder’s sizing options as per usual. However, it’s very important that the size values in the NSOutlineView’s table column, the size of the scroll view containing it, and the initial size of the custom NSViews for the cells are set to the same values in the various nibs. If you get this wrong, resizing won’t work correctly. As you can see from the example, if you set it up right you can get all the usual content resizing options for free while designing your cells in Interface Builder.

Basically, that’s it – hopefully you can see the details from the code with those pointers. You’ll notice that although I used Cocoa Bindings to link the cell values to the model, I used the NSOutlineViewDataSource protocol for the main outline view structure, instead of binding it via a tree controller. The only reason for that was that the example from my project does it this way, because you need to use a custom datasource to handle drag/drop and the pasteboard, so it was simpler this way. There’s no reason why this wouldn’t work with a tree controller providing the data too, since all the key moving parts are in the delegate, custom cell and controllers.

Forgive me for any errors or bad practice here, I’m still relatively new to ObjC / Cocoa. But still, I hadn’t seen this done anywhere before so I wanted to share the technique I used, because when I was trying to do it I really wished someone had posted an example like this before. This code works well for me, but suggestions, patches & forks on BitBucket are of course welcome if you see something I’ve done wrong or sub-optimally.

I hope this is useful to someone!

I literally had no idea this was going on, or that my cousin had been asked to make the delivery that day (I thought we were just meeting for a social). I was completely taken aback and very touched that the people in the community would go to the trouble of doing something like this for me. There’s a thread in the forums going into more detail on how they organised it, including the many, many different designs they mocked up and considered before voting for this one. I’m humbled and flattered.

My sincere thanks to everyone who was involved in organising this, and very well done for creating such an excellent statue and managing so successfully to keep me in the dark about it! You guys are just awesome.

The board game is set, like the RPG and most Lovecraft stories, in the fictitious town of Arkham, Massachusetts, where one randomly-chosen Ancient One is threatening to awake and break through to our world. Each Ancient One has slightly different effects on the game as it progresses and each is easier or more difficult to defeat if they eventually do break through (although if they do, chances of success are minimal). Dimensional gates are randomly opening in Arkham to strange other worlds, and it’s the players’ job to explore and close them, preferably sealing them permanently, in order to avert the final confrontation.

Each player draws or chooses an Investigator, each of which has particular traits and possessions which can help in the game. The board features a number of street regions, each surrounded by places of interest like the Miskatonic University, Arkham Asylum and the Black Cave. There are also a number of ‘other dimensions’, which the players must traverse through gates in order to eventually seal them. The players have to move around Arkham picking up clues, exploring gates that open, and avoiding or confronting monsters that emerge from the gates and wander around the town – all the while maintaining their Stamina (physical health, worn down in combat) and Sanity (mental health, worn down by ’seeing too much’ and using spells). There are two ’status tracks’ which rack up during the game to illustrate the growing threat in Arkham – the ‘doom track’ which is how close the Ancient One is to awaking, which notches up whenever a gate opens or sometimes through other special events, and a ‘terror track’ which represents how afraid the citizens of the town are, and causes some locations to become boarded up when it achieves a certain level (and ultimately, if the terror level reaches 10, the town is considered ‘overrun’ and there is no longer a limit to the number of monsters on the board).

We had our first game yesterday, and we were really impressed by the amount of variety in the game – there are so many variables in play: which of the 8 Ancient Ones is the main enemy, which of the 16 Investigators are being used, what items you have, where the gates open, and so forth. The rules are relatively complicated for a board game, but as pen-and-paper RPG veterans we didn’t really have any trouble following them, since they are much simplified compared to a traditional RPG. We knew it was going to take a while, particularly since it was our first game, and in fact from set up to completion it ran for a little over 4 hours with 4 investigators. By the end of the game we were much faster at it though, and I think we could have shaved an hour off that time, particularly as we were facing the weakest of the Ancient Ones (Yig).

It makes a change to play a co-operative board game too. If you play RPGs then this will not be a new experience, but it is nice to have a tabletop game which follows this model, and in fact it may be a ‘gateway drug’ to friends who perhaps think full RPGs are a little too daunting. Some people might not like the concept of there not being an individual ‘winner’ in the game, but rather that the players either win or lose as a group, but as a social game I think this works extremely well.

The game also accurately re-creates the Call of Cthulhu feeling of exponentially creeping doom, and of a desperate but almost certainly futile struggle against powers beyond human understanding. Things start off looking fairly manageable, but things begin to ratchet up pretty fast, as you realise the time it takes to close gates, and to gather the resources to seal them permanently – the only way to stall the increase of the doom track is to permanently seal gates, but you need to balance gathering the clues you need to do this, with positive action to actually do it. 80% into our first game, we thought we were doing pretty well as we started to make progress on the gates. But in the end, we realised we had left it too late to start tackling them in earnest and eventually Yig emerged and devoured us all. Oh noes!

Even though our first game ended in crushing failure and the doom of the world, we had a huge amount of fun. It’s probably an alien concept to some gamers to enjoy a game in which there is a pretty good chance that you’ll fail at the end – Call of Cthulhu the pen-and-paper RPG was ever thus, and yet it has a huge cult (no pun intended) following. In my opinion though, extracting fun from a doomed scenario is one of the greatest examples of gaming refinement – because it’s the playing that is important, not the winning. Modern gaming far too often concentrates on simply completion – finish the game, get this achievement, succeed!!! In reality, all that matters in a game is that you had fun while playing it. Arkham Horror, like CoC, achieves that in spades in spite of – or perhaps because – the end confrontation is not what you’re rushing towards, but what you’re trying to avoid, all the while running madly about with your fellow players just trying not to get eaten or go insane. It’s unique, and I love it.

Summary: highly recommended if you want to play a really interesting, very different social game with well-balanced friends. Just don’t invite the guy obsessed with winning, he’ll hate it

The Golden Rule: Support > Everything

When it comes to hosting, the most important thing to look for, beyond what all the statistics of how much space and bandwidth you get, beyond even quoted up-times, is the quality of the support service. The big question is: when things go wrong – and if you host long enough, eventually they will even in the best possible hosting environment – how quickly are problems resolved, and how responsive are the support engineers during the process. Literally nothing is more important than this, and unfortunately it’s the one thing that you’ll only really learn with experience, unless you’re hosting a site big enough that you can get a formal SLA. Assuming you’re not going big enough for that, the only way to judge this is by being with a provider for a while, or knowing someone who has been with them, or possibly looking at online review sites – although frankly these are often highly unreliable, polluted as they are with inaccuracies and omissions either because of ignorance (people who post glowing reviews after being with the site 2 weeks) and unfortunately by frequent shill reviews.

I’ll post a couple of hosts I’ve had good experience with over many years later in the post, through good times and bad.

Know Your Bandwidth

Personally, I instantly rule out any host that claims ‘unlimited bandwith’. This is a crock – there is no such thing, and to claim there is just means the host is already lying to you before you even start – they have to pay for their bandwidth, so they can’t possibly allow everyone truly unlimited bandwidth and stay in business. If you really need unlimited bandwidth, i.e. you have a high-traffic site with lots of media files, then you will quickly bump into the way that these sites offer this ‘unlimited’ deal – via throttling. You may not have an absolute physical cap on your bandwidth, but if the tap is locked off to a slow dribble beyond a certain usage, it’s really worthless. In practice, ‘unlimited bandwidth’ is just a marketing point that they hope will draw in people who will only actually use a tiny amount of bandwidth, but will somehow favour them because the offer looks good. Don’t be one of those dumb guys.

Really you need to establish your bandwidth requirements and head for a host that can fulfil them for a reasonable price. For example, ogre3d.org uses between 125GB and 250GB per month, which is a reasonable amount, compared to my personal site here which only needs 5-10GB per month.

If you have ’spiky’ bandwidth, i.e. occasionally you need to be able to distribute large amounts of data, but it’s not a constant stream, it would be best to go for a lower monthly limit and host high-bandwidth items elsewhere. I often use Amazon S3 for this purpose which can be made to look like a sub-domain of your own site, and which charges for bandwidth at a very fine granularity so matches your demand closely – it’s more expensive than buying a monthly allowance if you use it a lot, but for on-demand spikes it works very well.

Shared, Dedicated or Virtual/Cloud?

I currently use two shared hosts and one dedicated host, to match the demands of each site. Personally, I’m still very skeptical about virtual private servers and cloud hosting, due to a bad experience I had a few years back when we tried running ogre3d.org on a VPS. We lasted not much more than a month before we moved the server to a dedicated machine because the VPS simply didn’t deliver on its promises – performance was unpredictable and to be honest you had the worst of both worlds – you had to admin your own server but you still didn’t have a 100% guarantee that no-one else would be screwing with something on the machine, or that the disk arrays wouldn’t be hammered by someone else (regardless of CPU assignment), or some other balancing issue. Virtualisation has evolved in the last few years so this may not be an accurate representation anymore, but personally I wouldn’t go for a VPS again any time soon, unless it was a machine I controlled entirely and partitioned myself into virtuals – at least with shared and dedicated servers you know exactly what you’re getting – either a low-maintenance but shared resource environment, or total control & power. VPS claims to offer a middle ground but in my experience it didn’t deliver.

So, who do I use?

For my shared hosting, I’ve been using Hosting Matters for about 10 years now. I went through a couple of other hosts before them and had terrible experiences, but since I switched to them I’ve been very happy. I can count the number of hours downtime (that I’ve been aware of) over those years on one hand, and whenever there’s an issue they’re incredibly fast to respond – they have both community forums and support tickets depending on the urgency. It’s also very reassuring to see the same names cropping up in the support responses over the years.

Their offerings are pretty standard, nothing that would make them jump off the page for anyone looking for a stellar feature list or super-cheap pricing. But they’re very reasonable, they’re honest about what they’re offering (like bandwidth), and as I said before, support > everything.

For dedicated hosting, since 2007 I’ve used Dedipower. They’re based in Reading, their support staff are all local and are on the end of a phone if you need them (no call centres). Having been through a UK dedicated server comparison twice in the last 3 years (once again just recently), Dedipower came out as the most competitive for the service they were willing to offer, and I’ve been happy with the support service. In once instance in fact, when I moved a sub-site off the server, they were quickly on the phone to me within 10 minutes to tell me it was ‘down’ – at which point I had to explain it was expected & apologise for not notifying them in advance. You really can’t complain about that.

I hope that’s useful to someone. In case I need to point this out, I’m not getting paid or receiving discounts to promote either of these hosts, they’re just the two I’ve been most happy with over the ~10 years I’ve been hosting sites. YMMV but they’ve worked well for me

What’s happened in the last couple of years is that Twitter has risen inexorably in my daily usage due to being genuinely useful as a networking aid, while Facebook has not fared that well at all. I tried posting updates to it from Twitter for a while via Selective Tweets, which led to a considerable blip in my Facebook usage (even though I wasn’t using the site) but honestly I can’t be bothered with it anymore. And not just because of the rubbish that sloshes around Facebook.

Facebook is ’sold’ on the idea that you can realistically make / be friends with people, or even keep in meaningful personal touch with people you do genuinely know, via short messages and photos on an online service. My personal opinion after trying to use it as such for a while, is that this is a massive crock of elephant dung. Relationships are built on meaningful contact, and Facebook provides – is only capable of providing – only meaningless, trivial contact. Of all the ways you can keep in touch with people, it’s about the very worst you could possibly use, IMHO. It’s convenient, sure, but convenience doesn’t make for good personal contact. Honestly, if you can’t be bothered to make the effort to meet someone in person or talk on the phone (and home video calls aren’t that hard in the 21st century), then really you’re not that bothered about keeping in genuine contact with them. It’s better just to be honest – you’re kinda interested in knowing what’s up in their life, but not interested enough to have coffee with them, or otherwise make any genuine time for them.

In this context, Facebook is a fallacy. The whole point of Facebook versus Twitter or any other public internet medium is that Facebook is ‘private’ (barring any changes in rules they might feel like making to make a buck on your data of course). But if you don’t care enough to speak to someone other than in Facebook, and vis-a-vis you’re not really that much of a friend, then why would you want them to know things you wouldn’t post publicly? This is behind many the Facebook fo-pahs that seem to crop up with increasing regularity. Twitter is honest about the level of interaction  you’re having with people. Facebook tries to make you think it’s more significant than it is.

Maybe you’re a highly gregarious person who genuinely has over 100 real friends that you’d share your private information with. Maybe you feel that personal relationships are upheld and maintained by Facebook messages. I don’t, and I’m going to stop pretending that it’s serving a useful purpose in my life. I have a small collection of friends and family with whom I exchange information by meeting and speaking to them – these are the only people I’d consider exchanging genuinely personal information with. There’s a second much larger collection of people whom I don’t meet personally but who I’m interested in keeping in contact with, and by and large they’re all on Twitter – which also does a far better job of delivering that information without bombarding me with all kinds of other nonsense. There’s really no useful middle ground for Facebook to fill, for me. And using Facebook as a supplement with people I already know? Frankly it’s far more entertaining to talk to them about their week’s exploits than read about them on Facebook – in fact Facebook can take the wind out of a good anecdote

Really, you should never post anything on the Internet that you wouldn’t mind being public, since Facebook hardly has an unblemished record for actual privacy (whether that’s via Facebook themselves, or friends or friends-of-friends). I think that a lot of people use Facebook like I use Twitter, except there’s far more scope for dangerous misunderstandings about what is appropriate to post. I think non-digital social protocols dealt with sensitive & private information much better, and that online services are best used only for non-private things. From now on, that’s what I’m going to do, and I’m not the only one.

First, some context

It would be illustrative first of all to set out my reasons for wanting to lay down some cash on a product such as this, in order to frame the context in which I’m evaluating it. Some potentially relevant facts:

1. I don’t have an iPhone. I work from home, and I consider it extremely impolite to be constantly stabbing away at a phone while in a social gathering (you know who you are), therefore I can’t justify owning one. I have a far cheaper Nokia smartphone which does what I need just fine for the rare occasions when I need to check the internet on the go.
2. I like Macs. This is an opinion which I’ve come to only in the last few years – despite studying user interface design as a module of my compsci degree, my interest in practical applications of the subject has only recently been piqued, and I’ve learned that Apple definitely groks these things better than most. I’ve also changed – I used to love taking apart my PCs, customising them to the nth degree, knowing every tweaked and tricked out element of it. Now, after 20 years, I find that kind of a bore and generally just want something that works, gets out of the way and lets me get on with what else I want to do, and I find Macs are good at that.
3. I find touch interfaces very interesting. As an RSI sufferer for the last 7 or so years, I’ve become acutely aware of how terrible mice are as an ergonomic interface. Really, they’re awful – the wrist rotation, the fact your arm has to be right out to the side with most setups, these things are ergonomic suicide. At some point, unless you want chronic carpal tunnel syndrome, you’re going to have to switch to a track ball, a track pad, or one of those vastly overpriced vertically oriented mice. Personally, I try to use the keyboard for most things, which isn’t great but it’s better than the mouse, and a track pad on laptops as much as I can, which are much more natural. The prospect of a renaissance of user interfaces designed not to need a mouse, but to be entirely driven by touch, is something very appealing to me. It doesn’t work at all for sustained use when there are large, immovable vertical screens involved, and it doesn’t work that well when the device is too small – to me the pad form factor is the ideal for this approach.
4. I watched Star Trek:TNG and lusted after their pads for years (even though they were just fake plastic slabs). Now it’s a reality! Who wouldn’t want that?

Perhaps importantly, going into this I wasn’t one of those people looking to replace another device with the iPad, but I did see it as an opportunity to use an iPad in use cases where I considered the other devices I could already use to be sub-optimal. I’ll cover those use cases later on when I discuss how things turned out in practice. So now, on to my evalution…

Physical characteristics

I’ll try not to cover too much ground that’s already been adequately covered elsewhere. You already know the iPad is fantastically well constructed, beautiful to look at, has a wonderfully bright and sharp screen (which is prone to finger prints) – we’ll take all that as read. In my opinion, it’s not that heavy, but if you had planned to hold it up in front of your face with one hand for a long time, yeah that’s going to get uncomfortable. Personally, I don’t do that – like when I’m reading a book of any size, I rest the iPad on my lap, either flat or just propping it up on edge with one hand, and that’s fine for several hours in my experience. Having said that, the sleek and smooth exterior means you can be afraid of dropping it – however I’m using it in a leather flip-case (I’ll cover that in a future post, it’s a good one), and in this configuration gripping it becomes a total non-issue.

The screen was sharper than I expected, it seems to have approximately the same pixel size as my MacBook Pro, since even though the resolution is lower, the screen is only 9 inches. The default brightness setting was a little dark for me so I tweaked it up to about 75%, which was perfect. It’s a glossy screen which you may have problems with outside, but inside in full daylight (we have many windows in our house) and using regular lighting at night, reflection has not been an issue.

As has been pointed out, there are no cameras. Personally, that’s not something I care about – I don’t use my mobile phone camera either and I have a far superior camera within 10 feet of me in my lounge if I need one. I can imagine a camera for video conferencing might be useful to some people, but I’ve had one in my MacBooks for 3 years and I’ve never used them, so really, this is not important to me.

Connectivity wise, we’re talking minimal – just a dock connector and Wifi. It would have been nice to have a USB slot or two and especially a SD card slot (although you can get an adapter for that), but anyone who’s bought an iPod before knows the Apple way – don’t try to do everything, just try to do the core things better than anyone else. So, did they manage that?

General User Experience

I’d sum it up on one word – ‘butter’. The fact is that the iPad comes with only a small piece of card of instructions (and bizarrely, a 300 page downloadable manual which I don’t think they expect anyone to read), and you don’t even need to read that. Seriously, a monkey could work this thing, and it wouldn’t even need any training. I consider myself a geek still, and some geeks seem to find user friendly experiences offensive, as if it undermines the skills they’ve acquired, but I’m not one of them, and I admire what’s going on here. It’s a very direct, tactile experience that rewards experimentation and exploration, and just says “hey, come play with me, I won’t bite”. This, frankly, is how systems should be designed.

The lack of multitasking (due to be added in OS4 later in the year) is much less of an issue than I expected. Apps remember where you were, and tend to launch fast so switching between, say, Safari and an email that you’re in the middle of writing, works just fine and feels no different to true multitasking. The only thing missing is if you have apps which need to actively do things when you switch – such as IM or voice messaging, or music players other than the built-in iPod features. But honestly, so far I’m not missing it, even though I can imagine it being useful in some cases.

Many have said this is a bigger iPod Touch. They’re right, but in the same way that a bay window is just a bigger porthole. If you think that doesn’t matter, maybe you wouldn’t mind replacing all the windows in your house with portholes. In my opinion, the size of this device is absolutely perfect – for the purposes use it for (see below).

So What’s It Good For?

These are the primary things the iPad is being used for in our house:

1. Checking mail, web, news, social networks at home in a casual setting. When we’re doing things at home, watching TV, playing non-PC games, having guests around, or just between other things, it’s often useful to quickly check email or look something up on the web. Getting the laptop out takes too much time and it’s too bulky if you have friends around, and a phone is often too cramped, particularly if you want to show the contents to others or you want to type more comfortably. The iPad has instantly become the way my wife and I do all these things when we’re not at the PC anyway, and it works really well. Websites display legibly with no scrolling around, typing is fast (slower than a real keyboard but much faster than a phone). Most importantly, it doesn’t feel like a ‘work’ device and fits into a casual / social setting perfectly. My preferred way to check the detail of the day’s news after breakfast is now on the iPad via the Reuter’s app. YouTube works great on it too, I can catch up with my subscriptions very comfortably this way. As for the lack of Flash – in almost 3 days, I haven’t noticed, and I don’t think my wife even knows that Flash is not available. Maybe it’ll be an issue some time, but not so far.
2. Touch gaming. I’ve specifically added ‘touch’ there because people trying to play normal games with traditional controls (using virtual joysticks etc) are completely barking up the wrong tree. Games on the iPad, like the iPhone, work best when they’re designed with a touch interface in mind, or at least adapt well to it (e.g. Plants vs Zombies). Flight Control and Harbormaster are good examples of this, where there’s just no way you could implement a game like this efficiently with anything other than touch controls, and they click in 2 seconds flat. To be honest, my wife has the most experience of the games so far, but the fact that it’s hard to get her off them is a fairly solid endorsement of the gaming capabilities of the device
3. Documentation. I don’t think I’d use a device like this for casual reading. A paperback is more rugged, cheap, and appropriate in the majority of cases than even dedicated devices like the Kindle, IMO. However, I do think e-readers are perfect for reference documentation, the kind of stuff you need to access randomly, search and dip into at a moment’s notice, often over several volumes, and for that I’m using GoodReader. Of course, if you’d be using that documentation at a PC anyway, you don’t need an e-reader. However, if you’re not at a PC, and you need access to this kind of information, then e-readers suddenly become useful. Because I have a minority usage for this, a dedicated e-reader has never been a worthwhile purchase for me, but as one feature in a multi-function device – that’s useful. In particular, I run a D&D campaign one night a week, and thus far have always needed a big stack of books next to me, which is a pain for space when we have a full crowd in. I’ve tried using laptops before, but they suck – they take up too much room and if you have them in a comfortable position in front of you they’re just too distracting. The iPad is the perfect size, and replaces several physical tomes with fully bookmarked, searchable texts, and it can sit to the side of me, available but not obtrusive, large enough to read but not too large to dominate the space. It’s by far the most practical device I’ve ever come across for this purpose, and I can’t help but think others will find places where it’s useful too.
4. Photos. This might seem odd to call out as its own bullet point, but actually I think this is significant. Since we transitioned to digital photos, it’s made sharing them with family more awkward. Sure, you can use Facebook, but firstly – shockingly – many friends / family members don’t use Facebook (and no, I’m not going to pressure them to use it), and secondly it’s actually nice to show photos to people in person, and, you know, talk about them. Interact. Face to face. Radical stuff I know, but Facebook doesn’t solve that problem. In the past we’ve taken a laptop to other people’s houses, but that just feels clunky and geeky. And we don’t want to get them all printed, because that’s just a massive waste. And digital photo frames of any decent size are too expensive to justify. Enter the iPad – which can double as a photo frame and is very good at being a medium to share photos in person, just because its form factor works well – it’s easy to pass around or look at from multiple directions (rather than everyone crowding around a laptop screen). It’s a digital photo viewer that works in a multi-person environment, and the display is still large enough to do them justice.
5. Sketching. It may not be a match for my wife’s Wacom tablet, but as a casual sketching tool (via SketchBook Pro) it works quite well. Obviously the touch interface is a no-brainer for this – it’s missing things like pressure sensitivity and angle detection like the Wacom kit does, but even so it’s far more natural than drawing with a mouse, and considerably cheaper to try out than buying a full featured tablet.

The important thing is that none of these things could be done as well with devices of another form factor, IMO. You could do them, but you’d be compromising something – such as screen space, comfort, instant accessibility. I think a pad form factor hits a sweet spot for these things, and that Apple’s implementation is confident and slick. In the end, that’s all I really wanted.

Conclusion

My personal opinion is that there definitely is room for a device of this form factor in the lives of many people. You can argue that iPad version 2 will have more features, or that an Android tablet (whenever they arrive in a product form) will do better later on and will have more apps because of the open architecture, but  I think the phrase ‘a bird in the hand is worth 2 in the bush’ is relevant here. In technology, there’s always going to be something better in the future, that’s a universal constant at any point in time, for any product. Right now, the iPad pushes exactly the buttons I wanted it to push – that doesn’t mean there isn’t potential for more, but what it does do, it does extremely well. And more importantly, it does it right now, not at some theoretical point in the future. That has value to me.

Perhaps the best illustration is that the iPad has been in pretty much constant use since purchase, barring when it’s on charge, and so far the split has been 70/30 in favour of my wife, whose review comments are simple: “It’s cool”. I concur.

The basic principle for text localisation on OS X is that, like most systems, you externalise your user-visible strings in string tables and reference them by keyed aliases in code – in this case using NSLocalizedString. Apple provide a tool called ‘genstrings’ which extracts all these into a template strings file called Localizable.strings which you can then populate per language – localised files are kept in folders called en.lproj, fr.lproj etc and helpfully they’re picked up by default like this.  So far, so good.

There are a couple of practical issues though. Firstly, genstrings always overwrites its output file, which means that using it incrementally to add new strings when you’ve already populated the previous set – which is bound to be the normal case for most developers – isn’t possible out of the box. Luckily I found a nice little Python script which solves this problem for you by merging the results in to your existing files. I’ve added a custom target with a Run Script step to my XCode project which uses a modified version of this script (see below) to update my strings files whenever I need to.

The second problem is that genstrings creates UTF-16 encoded files, and there’s no way to alter this. The problem with UTF-16 is that both Mercurial and Git don’t like them very much; both system’s text/binary detection will classify them as binary, meaning you lose the ability to diff and merge these files in any useful way. It’s not a deal-breaker, but it’s inconvenient. Couple that with the fact that OS X will quite happily use UTF-8 encoded .strings files directly at run-time (although iPhone will not), and it seemed something that I should resolve. For the convenience of development, I modified the Python script (as shown below) to convert the result of genstrings to UTF-8 via iconv, meaning they always get picked up as text in source control. If you’re deploying on iPhone, it’s trivial to write a small build script calling iconv again to convert back to UTF-16 for deployment.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Localize.py - Incremental localization on XCode projects
# João Moreno 2009
# http://joaomoreno.com/

# Modified by Steve Streeting 2010 http://www.stevestreeting.com
# Changes
# - Use .strings files encoded as UTF-8
#   This is useful because Mercurial and Git treat UTF-16 as binary and can't
#   diff/merge them. For use on iPhone you can run an iconv script during build to
#   convert back to UTF-16 (Mac OS X will happily use UTF-8 .strings files).
# - Clean up .old and .new files once we're done

from sys import argv
from codecs import open
from re import compile
from copy import copy
import os

re_translation = compile(r'^"(.+)" = "(.+)";$')
re_comment_single = compile(r'^/\*.*\*/$')
re_comment_start = compile(r'^/\*.*$')
re_comment_end = compile(r'^.*\*/$')

class LocalizedString():
    def __init__(self, comments, translation):
        self.comments, self.translation = comments, translation
        self.key, self.value = re_translation.match(self.translation).groups()

    def __unicode__(self):
        return u'%s%s\n' % (u''.join(self.comments), self.translation)

class LocalizedFile():
    def __init__(self, fname=None, auto_read=False):
        self.fname = fname
        self.strings = []
        self.strings_d = {}

        if auto_read:
            self.read_from_file(fname)

    def read_from_file(self, fname=None):
        fname = self.fname if fname == None else fname
        try:
            f = open(fname, encoding='utf_8', mode='r')
        except:
            print 'File %s does not exist.' % fname
            exit(-1)

        line = f.readline()
        while line:
            comments = [line]

            if not re_comment_single.match(line):
                while line and not re_comment_end.match(line):
                    line = f.readline()
                    comments.append(line)

            line = f.readline()
            if line and re_translation.match(line):
                translation = line
            else:
                raise Exception('invalid file')

            line = f.readline()
            while line and line == u'\n':
                line = f.readline()

            string = LocalizedString(comments, translation)
            self.strings.append(string)
            self.strings_d[string.key] = string

        f.close()

    def save_to_file(self, fname=None):
        fname = self.fname if fname == None else fname
        try:
            f = open(fname, encoding='utf_8', mode='w')
        except:
            print 'Couldn\'t open file %s.' % fname
            exit(-1)

        for string in self.strings:
            f.write(string.__unicode__())

        f.close()

    def merge_with(self, new):
        merged = LocalizedFile()

        for string in new.strings:
            if self.strings_d.has_key(string.key):
                new_string = copy(self.strings_d[string.key])
                new_string.comments = string.comments
                string = new_string

            merged.strings.append(string)
            merged.strings_d[string.key] = string

        return merged

def merge(merged_fname, old_fname, new_fname):
    try:
        old = LocalizedFile(old_fname, auto_read=True)
        new = LocalizedFile(new_fname, auto_read=True)
        merged = old.merge_with(new)
        merged.save_to_file(merged_fname)
    except:
        print 'Error: input files have invalid format.'

STRINGS_FILE = 'Localizable.strings'

def localize(path):
    languages = [name for name in os.listdir(path) if name.endswith('.lproj') and os.path.isdir(name)]

    for language in languages:
        original = merged = language + os.path.sep + STRINGS_FILE
        old = original + '.old'
        new = original + '.new'

        if os.path.isfile(original):
            os.rename(original, old)
            os.system('genstrings -q -o "%s" `find . -name "*.m"`' % language)
            os.system('iconv -f UTF-16 -t UTF-8 "%s" > "%s"' % (original, new))
            merge(merged, old, new)
        else:
            os.system('genstrings -q -o "%s" `find . -name "*.m"`' % language)
            os.rename(original, old)
            os.system('iconv -f UTF-16 -t UTF-8 "%s" > "%s"' % (old, original))

        if os.path.isfile(old):
        	os.remove(old)
        if os.path.isfile(new):
        	os.remove(new)

if __name__ == '__main__':
    localize(os.getcwd())

Hopefully this is useful to someone else! I’m still very much learning on the Mac development side, so if there’s something I haven’t considered, please let me know.

Over the years I’ve learned a couple of things about choosing what projects to work on – follow your gut, and work on things you’d do even if there was no money in it. Yes, you need to do a business case and convince yourself that there’s a viable market for what you have in mind, but all that’s irrelevant if you don’t feel strongly about what you’re doing, because it’s passion and enthusiasm that will get you through the difficult times. So I sat down and gave some thought to what really excited me these days, what I liked using and what technical directions piqued my interest. I still find 3D and games fascinating, but they’re far from my only interests.

So, I realised that one area that I’ve been dying to get my teeth into properly for ages but had never found the time before, was coding specifically for Mac OS X. In 3 years I’ve gone from a total newcomer to the platform, to a staunch advocate of it. However until now I’d never really had time to play with developing on it, beyond porting cross-platform C++ code and providing / using intermediate libraries. One thing I learned in those 3 years as a user was how much better applications designed for OS X felt to use compared to those that were just ported via a common UI layer (like wxWidgets / Qt), and I’m convinced now that while cross-platform infrastructural code is great, user experiences are far better when designed with the specific platform in mind – increasingly that means OS and physical device now of course. Sure, cross-platform UIs save the developer time, but the result is often a watered-down experience – early on I liked OS X applications that felt like Windows, or ran the same on both platforms – now I  do not. Such carbon-copying applications were helpful while I was unfamiliar with the platform, but now it’s just glaring to me how basic their compatibility with the OS typically is, and how the UI styles clash with the expected standards.

So, I decided I wanted to learn how to target OS X specifically, and had a couple of ideas for projects I could do with it, which meant learning Objective-C. At first, I hated it and tried to escape via more familiar technologies like Objective-C++ and PyObjC. Ultimately I found shortcomings and limitations of those routes and returned to Objective-C, and the more I used it, the more my animosity toward it diminished. In the end I realised the problem was that I needed to adapt to the environment, rather than try to adapt it to my previously learned styles and behaviours. Sure, missing elements like namespaces might still nag me, but on balance the blend of static and dynamic language elements works very well for the intended use. And besides, I really didn’t want to be ‘that guy’ – the programmer that having decided one language / tech is ‘the best’, then tries to apply it everywhere, regardless of suitability; I like to think I’m a bit more flexible & multicultural than that.

I’ve also learned that Cocoa is a very, very smart system. Mad as a bison if you’re used to other systems beforehand, but persevere with it and resist the urge to hide it under some vanilla layer that you’re already familiar with, and you discover it’s really very powerful. Not to mention the Core Animation and Core Graphics frameworks are a lot of fun.

It’s funny, I’ve spent so many years concerning myself with providing compatibility across multiple OS’s, multiple GPUs, multiple render APIs, and multiple drivers, it’s a genuine joy to actually forget all that for a while, and concentrate on an end goal with a finite number of permutations for a change – and not to shy away from using platform-specific features.

While I’m still very much an advocate of open systems, I look at things slightly differently now – that data & protocols should be open, and that we should all re-use & collaborate on common, preferably open source infrastructure (like OGRE), but that the ‘last mile’ to the user is the least suitable for generalisation, because the more specific you can make that interface to what the user expects on their OS & device, the better that experience will be. And at the end of the day to the user, that experience is the application, and thus all that really matters – and I feel that Apple gets that, in a way that very few others do.

So, I’m having a great time learning to be an Apple developer so far, I’m going to see where this takes me for a while. My gut says it feels right, and I’ve learned to listen to my gut I love the platform, it’s a total change of pace and technology, it’s something I’ve had an interest in for a while, and the Mac has quite a thriving community of quality independent app developers that I can try to join – what’s not to like?

So, as someone who hated Vista, what are my impressions? It’s actually pretty good. It’s not perfect, but it’s definitely better than what came before, which is exactly what I expect from an upgrade (and exactly what Vista didn’t deliver). Things I like:

• Taskbar – clearly inspired by the OS X Dock, but adds some features of its own too like the jump lists and window previews. I’d prefer if clicking the button when there are multiple windows open switched to the last one you had been using, instead of forcing you to pick one, but on the whole it works well.
• Windows Update gets out of my face – Vista’s Windows Update was a dog, while it was kicking in it sucked resources like a bastard and threw off any performance testing I was doing, sometimes for long periods (made worse perhaps by the fact that I didn’t use Vista that much). The new one seems much lighter.
• Responsive – they say they’ve improved the parallelism in many systems, and it certainly feels like it. The same machine feels faster on Windows 7, compared to feeling slower in Vista.
• Libraries – these are like customising your sidebar in OS X’s finder, but add more features like grouping and collection searching. Nice.
• Devices & Printers – when I looked at this view and saw that it came up with photos of my exact mouse, printer etc, without any specific drivers etc installed apart from the base system, I thought that was pretty cool. It’s actually a useful view in practice too, but the pictures made me grin, because I’m shallow. But then, if you don’t smile at least once when you use an OS for the first time, something is wrong on the usability side.

There are some stupid things though:

• UAC remains dumb – it still text-matches filenames like ‘patch.exe’ and arbitrarily decides that they need to be admin-level. Sure you can tack a manifest onto it to tell it not to, but for Christ sakes, talk about a blunt instrument.
• Startup items – Why is changing what apps load at login still so esoteric? It hasn’t changed since Windows 95, and they’ve hidden the Startup menu by default now (and services are even harder to find). Just not user-friendly at all – compare to OS X where Login Items is very simple for anyone to use.
• Network Drive Login Scope is obscure - This is new in Windows 7 – if you connect to a NAS or other network drive, enter your login and click the ‘Remember’ checkbox, it only actually remembers until you log out, not permanently as in previous versions. To change this is very obtuse and user-unfriendly – you have to open Credentials Manager, delete the existing credential (because editing the scope is not possible for no particular reason), and re-create it with the same details (again, scope is not an explicit option so you just have to go on faith here). By doing this the scope becomes ‘Enterprise’ rather than ‘Session’ (which is obscure in itself) and the result is that your credentials will be remembered across logout / reboots like in XP / Vista. It took me some forum browsing to figure this out, and it’s just not an intuitive design. Adding a ’scope’ combo to the remember option that says ‘Until logout’ or ‘Forever’ would solve it, but no, that would just be too simple & intuitive.
• Aero Shake is just silly

But, the bottom line is that on balance it’s pleasant to use despite a few oddities, and I’m happy with Windows 7 as my main Windows OS now in a way I never was with Vista. I still find OS X more pleasant to use, but this is the closest Windows has ever come to it, and it adds a few ideas of its own too, that importantly actually work & add value – compared to Vista that mostly imitated and whose additions just fell flat (Flip3D, I’m looking at you). So, a good OS, and the first one from MS since 2001 that I don’t regret spending money on.