Alas, my childhood OM-1 has seen better days.

When I hit 19 or so, I got a part-time job at the now-defunct Jessops camera store, and enjoyed my first income stream and a staff discount, which accelerated my photography interest quite a bit. My next camera was the EOS 3000N, a more modern film SLR. After that, I went digital with the EOS 300D, then an original 5D, then a 7D and after a brief stint with a 60D, I’ve landed with the wonderful EOS 6D.

Now, I’m not actually going to review the camera per se — there are lots of photography review websites far more qualified to do that than me. However, I do absolutely adore this thing — its image quality is superb and it’s beautifully light and easy to carry around. The incredible silent drive mode combined with the amazingly tiny 40mm f/2.8 STM pancake lens allows me to wander around the city and take photos without a bunch of people staring at me — I feel discreet with this setup, which is something I haven’t felt in years.

“I’m not fat, I’m just full-frame!”

However, this camera is the first SLR I’ve purchased that has a built-in shelf life on some of its features, which makes me slightly uncomfortable.

The March of Technology

I have a sort of love-hate relationship with technology, specifically computing technology. I’m a programmer, so obviously computing technology and I are intertwined, but I’m a firm believer that if the user is conscious that their machine has computers in it, the designers failed unless the product is specifically advertised as THIS IS A COMPUTER.

Let me give you an example. I’ve been fortunate enough to own several different cars so far in my life, and by far my favourite is the Mazda RX-8. The RX-8 is designed to be a mechanically brilliant car, and excels in this area — you can hurl it around the track like a madman and it’ll just lap it up and egg you on. When you’re driving, it’s all mechanical — a stubby gearstick sticks up directly from the gearbox, the steering has a very direct connection to the road, and on the dashboard you have a thing that tells you how fast the engine is going, another thing that tells you how fast the car is going, and not much else.

The RX-8’s dashboard.

Underneath this is an incredible amount of computing power trying to make sure I don’t slam face-first into the nearest wall — computers making sure the engine is mixing fuel correctly, computers to make sure the car goes in the direction I tell it to, and so on. However, back in the cockpit all you’re doing is giggling wildly as this glorious heap of metal seems to defy the laws of physics as it propels you around the twisty piece of Tarmac that is whatever racetrack you’re on, and there’s absolutely no indication in the car that there’s all this computing going on behind the scenes unless something goes wrong.

And that’s the way it should be.

Isn’t this supposed to be about a camera?

So, how is this relevant to the EOS 6D? Well, to me, cameras are like cars (and washing machines, toasters, fridges, etc) — they’re appliances designed to do a certain job. Your relationship with them is physical, and all of the control is done through the manipulation of buttons, switches and levers, not touch-screens or keyboards and mice. Sure, they’re computers on the inside, but if I’m conscious of that then something has gone wrong somewhere.

The 6D’s chassis (photo credit: Canon).

This is a physical device which I use to make photographs. Sure, it has a computer inside it, but that’s a detail you don’t care about — the specifications talk about the image quality and how well the camera stands up to rain, not gigahertz and RAM. In ten years, I should still be able to use it to take pictures and as long as I can get them out of the camera and into my computer, I’m set. The computing technology in this thing has one job — to help the user create the best photos they can.

It makes me slightly uncomfortable to switch on my camera to see this:

I’m not actually 100% sure why this feature irks me so much. The WiFi feature of the camera is incredibly useful — I can connect it to my computer or phone and shoot and preview shots wirelessly. However, seeing Facebook and Twitter icons on this thing crosses the line from an appliance to a computer. Before, my camera longevity concerns were all physical — how long will the shutter last? What happens if I get it wet? What if I drop it?

Now, I get to think about stuff other than my camera when thinking about my camera. Twitter are notorious about being strict with their API — what if it changes or goes away? What if Facebook goes the way of every other social network before it? That’s fine on a “big” computer — I’m already conditioned to have to update and change the software set on it, but my camera? It’s a metal box with buttons and switches on it, and I shouldn’t have to deal with “computer crap” like this.

Conclusion

Well, the EOS 6D is a great camera and you should all go buy one. However, seeing features like Facebook and Twitter integration in it make me worry about a future filled with appliances whose feature sets have shelf lives. It’s not just this camera, though — the whole industry is going this way, even cars. The Tesla Model S has Google Maps built right into the dashboard, for example.

My Olympus OM-1 is still exactly as functional as it was when it came out forty years ago. Will I be able to say that about my 6D forty years from now? How about if I bought a Model S? It seems that as technology advances, previously immutable appliances like cameras and cars are getting caught in the net of rapidly obsoleting technology.

Then again, maybe I’m just getting old. My first camera didn’t even require a battery, so obviously my idea of what a camera should be is biased towards a mechanical interface, and memories of mechanical cameras are going the way those of the floppy disk are.

Well, that project is finally underway.

Hardware

It very quickly became apparent that an Arduino wouldn’t cut it for the kind of computational work I want to do, mainly because of the tiny amount of RAM it has. I ended up with a pairing of a Raspberry Pi and an Arduino Uno. The Arduino’s job is to interface with the various sensors on the car and pass that information back to the Pi, which has a lot more resources for doing computation.

Note: This chapter is a fairly quick overview of how the car is put together. You can find a shopping list with exact components at the end of this post.

Arduino

The Arduino has a prototype board attached to it, which on the underside has two three-pin connectors for connecting the car’s servos (one for speed, one for steering). The car’s speed controller is connected to the battery and provides the Arduino with power.

The top of the board (which is very messy — I intend to build a much neater one) hosts an accelerometer as well as a few cables for powering the Raspberry Pi, powering the Ultrasonic Sensors and reading data from the Ultrasonic sensors.

Black: Raspberry Pi power, Yellow and white: Ultrasonic sensor power, White four-lane: Ultrasonic sensor data, Raised red board: Accelerometer.

There are four Ultrasonic sensors mounted on the car’s body — three at the front and one at the rear. All the cabling for these sensors end up at a pair of connectors on the inside of the roof, which allows the body to easily be separated from the chassis when needed.

Leaving the body clear so you could see the electronics seemed like a good idea at the time, but instead it all looks messy and is really hard to photograph. Lesson learned!

The Arduino and prototype board are mounted inside an Arduino case that’s attached to the car’s chassis with zip ties. The case has a lid, but I’ve left it out of the photos to illustrate what goes there.

The vertical posts support the body, which rests on the clips. They can be raised to give more room.

Raspberry Pi

The Raspberry Pi is mated with a UI module from BitWizard, which hosts a 2x16 character LCD display, six buttons and a few breakout connectors for various serial busses.

Raspberry Pi with attached UI module. The garbled character to the right of the up arrow should be a down arrow, but there seems to be a bug in my custom character code!

The Raspberry Pi connects to the Arduino twice — once for power from the Arduino and once via USB to communicate with it. When it’s all assembled, it gets rather messy!

Thankfully, with the body on, it’s a lot cleaner. The final part is to find a housing for the Raspberry Pi and a place to mount it on the car itself.

Here’s a diagram of how everything fits together. Clear as mud!

Software

Arduino

The Arduino is running a very simple loop that polls the attached sensors and writes their values out to the serial port. ACCEL: lines are accelerometer readings in G, and DISTANCE: lines are ultrasonic sensor readings in cm.

1
2
3
4
5
6
7
8
9
10
11
12

ACCEL: 0.06,0.05,0.89
ACCEL: 0.07,0.05,0.90
ACCEL: 0.07,0.05,0.90
ACCEL: 0.06,0.05,0.90
ACCEL: 0.06,0.05,0.88
DISTANCE: 89,111,32,15
ACCEL: 0.07,0.05,0.89
ACCEL: 0.07,0.05,0.90
ACCEL: 0.07,0.04,0.90
ACCEL: 0.07,0.05,0.90
ACCEL: 0.07,0.06,0.90
DISTANCE: 89,111,32,15

Sample Arduino output.

In addition, the Arduino listens for input on the serial port for setting speed and steering values for the servos. This is not unlike the protocol used in my Arduino LED project, with two header bytes, a byte for the steering angle (0 - 180), a byte for the throttle angle (0 - 180) and a checksum byte.

Main Software Stack - Raspberry Pi

Everything so far is just enabling the main software stack of the car to observe and interact with the hardware in the car.

The main software stack is written in C# against the Mono Framework. I chose this setup because it’s pretty much the only nice Object-Oriented language available with a fully featured runtime available on multiple platforms (of course, there’s also Python and Java, but I prefer C# over those two). This setup allows me to write and debug the code on Mac OS X, then copy it over the the Raspberry Pi running Debian Linux for real-life use.

At the moment, the software stack is at the point where it’s a fully functional object model wrapping all of the implementation details of the car:

• The Sensor class tree provides objects representing the various sensors on the car, providing events for when their readouts change.

• The Servo class provides getters and setters for adjusting the servos on the car.

• The SerialCarHardwareInterface class implements the ICarHardwareInterface, which defines various methods for getting the sensors and servos on the car. This is split out into an interface for when I need to implement a mock car for testing AI routines without risking damage to my car or other property (it goes quite fast!).

• The CarHTTPServer class provides a simple REST API over HTTP to allow other computers on the network to observe the car’s sensors. This is great for writing tools to visualise the car’s status graphically.

RCSensorVisualizer showing the car’s accelerometer (top) and distance (bottom) sensor readouts graphically.

• The CarEventLoop class runs a dual loop for running AI code. The first loop is a low-latency loop that monitors the car’s sensors, which can have interrupt handlers attached to it — simple classes that decide if execution should be halted, for example if the car turns upside-down. The second loop runs on a different thread and is where the main AI processes will take place. This dual setup allows the car to detect if it’s upside-down and halt operation even an AI process is taking a long time.

• The I2CUIDevice class provides an interface to the screen mounted to the Raspberry Pi, allowing text to be written to the screen and firing events when buttons are pushed.

• The MenuController class as friends provide logic for presenting a menu system on the display, allowing menu item selection and navigation, as well as “screens” for presenting information or prompting the user to confirm a chosen action.

Bringing It All Together

Below is a video showing the whole lot working together. I scroll through the menus on the Raspberry Pi and observe sensor readouts as well as adjusting the steering and throttle.

The project is now ready for its next steps, which will be writing AI code to have the car navigate its surroundings. It doesn’t have GPS at the moment so it’ll be limited to “drive forwards and don’t crash into stuff” for now, but it’s a start!

You can find the code for this project over on my GitHub. It includes the Arduino Sketch, the C# software stack for the Raspberry Pi and and Objective-C Mac application for observing the sensors.

Shopping List

The project at the moment uses the following hardware:

• 1x Dual Hunter Monster Truck (Tamiya.com).
• 1x Raspberry Pi (RaspberryPi.org).
• 1x Raspberry Pi UI Module with 16x2 LCD (BitWizard.nl).
• 1x Arduino Uno (Arduino.cc).
• 1x Arduino Proto-shield (Arduino.cc).
• 1x ADXL345 Accelerometer (SparkFun.com).
• 4x SRF05 Ultrasonic Sensor (Robot-Electronics.co.uk).
• A ton of wires and stuff to link them all together.

For a little while I couldn’t place it, but today it came to me — these posts, to me at least, seem to be looking at the problem (or lack thereof) too closely, citing small code snippets and “rules” on how to fix them with the correct choice of language.

* Specifically, point 6 of that post.

Clarifying the Problem

Now, the discussion has become slightly muddled between two issues - one is that Objective-C’s runtime is slower than some other runtimes (like, say, C), and the other is of code efficiency. Since a method call has more overhead in Objective-C, inefficient code is affected more than that same code in C, so people jump to the conclusion that Objective-C is slow and the followup fix is to move to C.

Inefficient code will always be slow. However, since a method invocation has more overhead in Objective-C than C, C++ or most other static runtimes, people who’ve just learned about the Objective-C runtime will often blame the runtime and switch to C.

Unfortunately, I need to be blunt here: If you think your code is slow because Objective-C is slow, you’re wrong. Your code is slow because you wrote slow code.

The Bigger Picture

In day-to-day programming, you may end up in a situation in which you’re looking at objc_msgSend and thinking that Objective-C is too slow. If this is the case, there are only two outcomes.

1. You wrote inefficient code and need to go fix it. It sucks, but this will be 99.9% of cases.

2. You screwed up big-style and Objective-C genuinely isn’t the correct tool for the job at hand. This sucks even more, because you misunderstood your problem and now have to scrap all of the Objective-C code you wrote and write it again in something else. This will be very rare.

Thinking about one implementation detail in your runtime (and with Objective-C, that invariably becomes objc_msgSend) is not thinking about the bigger picture and you’ll go down a horrible road of writing little sections of code in C, copying data back and forth between the two runtimes and creating a big horrible mess. You’ll start thinking things like “Accessing this instance variable directly is way faster than using Objective-C properties. This’ll make my app fast!”, and will fall down that horrible trap of pre-optimising stuff that doesn’t actually make a difference.

Instead, you need to be thinking about the behaviour of your runtime and how it affects your problem. Ideally, you should do this before starting to implement your solution to that problem.

Problem 1: I looked at Instruments and objc_msgSend is 10% of my application’s usage!

Is your application actually slow? If not, who cares? If you’re making a lot of method calls, this is to be expected.

This problem has nothing to do with the Objective-C runtime.

Problem 2: I profiled my application when it’s acting slow, and it’s some Objective-C code slowing it down!

Make your code more efficient. Depending on the nature of the problem, one or more of these might help:

• Stop doing obviously silly things. Loading huge images lazily on the main thread, for instance.

• Learn about complexity and how to write more efficient code.

• Learn about perceptive performance. For example, if you do your work on a background thread and keep your UI fluid in the meantime, your application won’t feel slow. It’s better that your application remains fluid and takes ten seconds to do its work than it locking up for five seconds. Five seconds is indeed faster, but it feels a lot slower when an application’s UI is blocked.

This problem also has nothing to do with the Objective-C runtime.

Problem 3: I’ll be working in a realtime thread and I’m worried about the fact that Objective-C is a dynamic runtime!

Aha! Now we’re getting somewhere.

Objective-C isn’t slow. It simply isn’t. However, one thing that it is is dynamic. Objective-C’s dynamic runtime gives it all the wonderful features we adore, but it isn’t appropriate for some uses.

Real-time threads can be one of those uses.

But not because Objective-C is slow.

Because it’s dynamic.

A good example of a realtime thread is a Core Audio render thread. When I get that callback from Core Audio asking me for more audio data to play, I have x milliseconds to return that data before the audio pipelines run out of buffer and an under-run occurs, causing playback stuttering.

Because that number is measured in milliseconds rather than nanoseconds, Objective-C would be perfectly fast enough to perform it. In fact, if I wrote my audio code in Objective-C it’d likely work just fine. However, because I’m under contract to return data in a certain time, I can’t safely use a dynamic runtime like Objective-C to implement it.

C, for instance, has a static runtime and a fixed overhead for method calls. Copy some stuff to the stack, jump to the function’s memory offset, and away you go.

Objective-C, though, is dynamic and you can’t guarantee a thing. Anyone can load a class into the runtime that overrides -methodSignatureForSelector: and redirects your method calls elsewhere, or can use something like method_exchangeImplementations() to swap out method implementations entirely. This means that at runtime, you can’t count on anything being what you thought it was.

So, because I’m under contract to return within a certain time and I personally believe it’s bad form to use a dynamic runtime in such a situation, I choose to implement that problem entirely in C.

Conclusion

The decision to use the C language for problem 3 was entirely a high-level decision based on the behaviour of the Objective-C runtime compared with the problem at hand.

This is really how you should be thinking about your runtime. If you get to the point where you’ve got some slow code and are noticing an implementation detail of the runtime pop up, you need to go back and code better. If you’ve coded the best you possibly can, you need to learn to code better. If you’ve learned to code better and the runtime is still getting in the way, you chose the wrong runtime for the entire problem.

Notice that this entire post is devoid of any code samples. This is intentional — the point of this post is that you choose your language and runtime first based on your problem, not second because of a problem in your code. If you’re switching languages and runtimes halfway through a problem, the issue is your approach to solving the problem, not the language or runtime you’re using to solve it.

In 2005, two things happened: I bought a kickass car, and Aperture 1.0 was released at the rather eye-watering price of £349. At the end of the year, I was playing with Aperture’s photo book tool by putting some pictures of my car in a book and inadvertently started a tradition I simultaneously despise and adore: My Life In Pictures.

Every year, I make a photo book of the interesting stuff that year brought — an interesting outcome is that a book’s thickness is a great way to see how interesting a year was for me. 2009 is an embarrassing 35 pages, whereas 2008 and 2006 are both pushing 100.

I despise them during the construction phase because they take an age to make — over a week of evenings for a long one. By the end I’m so sick and tired of looking at those damn photos I hesitate to buy the book I put together. Thankfully I’ve learned to push through that feeling and order, because every single time a book arrives I adore the result and happily add it to the slowly expanding collection.

Inside 2012 In Pictures.

These things are expensive — 2012 In Pictures is 63 pages and ordered through Blurb, which came to around €55 plus tax and shipping. However, they’re well worth it and I’m already enjoying going back a few years ago and flicking through what I did in the past. They also make great gifts for family members who are into that sort of thing.

My Aperture library is organised by Category, then by year (maybe), then by “event”. For example…

• Events
  • 2010
  • 2011
  • 2012
• Holidays and Trips
  • 2012
    • WWDC 2012
• People and Things
  • House

This seemed like a good idea to start with, but it’s actually fairly terrible. For example, I want a photo from WWDC 2012. Is that in Events or Holidays and Trips? I mean, it’s a “trip” for me, but WWDC is actually an event! This wishy-washy organisation isn’t so helpful when you’re trying to find photos from years ago. This, coupled with a complete lack of manual tagging, is a pain to work with.

A Fresh Start

After my previous post discussing Adobe Lightroom, not three weeks ago, basically concluded that I prefer Aperture, well, I’ve decided to slug it out a bit longer with Lightroom and do a long-term test.

On January 1st 2013, after waking up in the afternoon and noting that 2013 was in no was different to 2012, I launched Lightroom and pressed the “New Catalog” button. Starting then, I’d be using Lightroom for all of my photography work instead of Aperture, something I wasn’t sure would be a smart idea considering I didn’t actually like the program all that much. (I’ve since come to like Lightroom much more, but that’s for another post).

New year, New photo library!

With this fresh new start, I’m determined to start and keep up with a photo library that allows me to find my photos reasonably quickly and with as little frustration as possible. My library should meet the following criteria:

1. I shouldn’t be spending more than a few seconds per photo on import to get the metadata to a state of meeting the rest of these criteria.

2. A good portion of it should be automatable, if possible.

3. The metadata should allow me to, in the future, filter down my library to a reasonable number of candidates for the photo I’m actually looking for.

4. The data input for each photo must conform to a defined schema to keep metadata consistent.

My rationale behind the first entry is that if metadata input takes too long, I won’t bother doing it. The second entry helps the first become more of a reality. The third is a realisation of the first two — if my metadata entry isn’t taking very long, it won’t be that comprehensive, but if I can filter my 15,000 photos down to 150 candidates I’ll be able to find the photo I’m looking for manually in not too much time.

The last entry is to try and combat “tag creep”. I’ve seen this a lot, especially on blogs, where people just type in tags as they pop into their head. For example, in the photo above, well, it’s night. And there are fireworks. Oh, and trees. And clouds! night, fireworks, trees, clouds actually seems like a reasonable set of tags. However, my next fireworks shot is on the next night and there’s only one firework and it’s a starry night. night, firework, trees, starry. The only two tags those photos have in common are night and trees, neither of which are material to the photos! Clearly, we need a well-defined way of tagging photos.

It’s all about the questions!

Earlier this evening, I tweeted asking others how they organised their libraries, and quickly learned that everyone is different, and nobody seems to have a catch-all solution.

So, I started thinking about what I should tag my photos with and didn’t get far. Then, I started thinking about how I try to find photos once they’re in the library. That’s when I started getting somewhere — and I started listing all the questions I ask myself (and my photo library software) when trying to find my photos. Then I remembered that damnit, if I’m putting this effort into cataloging my library, the computer should be asking me the questions!

This brainwave has completely flipped how I think about metadata — it isn’t for finding the photo you want, but for dismissing the photos you don’t want.

The list below isn’t the questions I ask my computer to find photos — it’s the questions I want the computer to be able to ask me to get rid of the photos I’m not interested in:

Where did you put the photo on disk?

I’ll get this out of the way quickly — when trying to find photos, I never think about my computer or any detail of it. Therefore, I don’t care where my photos are on my computer. I let Aperture/Lightroom deal with them as they’d like to, and make sure I have backups. Hard drives, folders and filesystems are things for computers to deal with, not me. Therefore, I don’t use custom folder names or anything crazy like that.

What did you name the photo’s file?

Similar to my previous point, filenames have no hope of being helpful and I never think about them. There’s no way they can contain enough information to be useful, and one day you’ll encounter a USB stick formatted as FAT16 and you won’t be able to put your crazily-named files on it. I’ll let my computer deal with that and not care myself.

When did you take the photo?

Thankfully, assuming you have your camera’s clock set correctly, this is a non-issue. Time and date metadata is already present in my photos. Hooray!

Where did you take the photo?

Location, in my opinion, is one of the most important pieces of metadata a photo can have, even if it’s not that accurate. Hell, especially if it’s not that accurate! For example, I remember seeing an awesome car when I was a kid somewhere in France. That’s enough information (France, 1985 - 1995, Car) to filter out 99% of my library!

I already geolocate my photos in two ways — if I was out and about snapping away I’ll manually geolocate as best as I can when I return. Even if I find a year-old picture on some motorway in Germany, I’ll geolocate it to Germany and be done with it.

If I’m going on a photo walk — that is, a walk or similar with an express intent to take photos along the way - I’ll bring my bike’s GPS with me. It’s a Garmin Montana, and I specifically chose that rather expensive model because the battery lasts up to 16 hours. I can switch it on, throw it in my backpack and when I get home I have a trace of where I’ve been all day. Both Aperture and Lightroom contain tools to link this trace to your photos, automatically and accurately geotagging the day’s photos in an instant.

What is in the photo?

This one is a bit more difficult. Photos always contain lots of things. The photo above contains fireworks, the sky, clouds, trees, people, street lamps, buildings, snow, gravel, probably a mouse hibernating under a bush somewhere (Note: mice probably don’t hibernate in bushes), a bench, etc etc etc.

However, I never care what’s in the photo when looking for it. I care what the photo is of, and that photo is of fireworks. However, as discussed above, telling the computer what the photo is of can quickly get messy.

Instead, I’ve decided to distill this question down further, to a simple yes/no question:

Is the photo of a ______ ?

This way, tags can always be singular. Is the photo of a firework? Is it of a tree?

What environment was the photo taken in?

Sometimes, I want to find some pictures I know were taken at night, or in the snow, or both. Adding a tag for this would be useful!

Browsing

Sometimes, rather than searching for specific photos, I want to browse through all of the photos I took at, for example, WWDC 2012. In addition, I often keep a photo reference of progress on various projects such as my railway or robotic monster truck.

To allow this, I’ll continue to organise my photos by year, but rather than vague top-level folders I’ll stick with three: Projects, Events & Trips and Photography, the latter reserved for photos where the sole point of taking the photo was to make a beautiful photo.

Additionally, sometimes I want to browse (or share) my favourite photos, either because they’re photos I’m proud of technically or they just remind me of something amazing. For this, I’ll use the star rating system — typically photos in my library are ★★★★★ or nothing.

“Port of San Francisco”, a photo I consider ★★★★★.

The Metadata Schema

Based on these questions and the above criteria, I’ve settled on the following metadata schema on top of the metadata already added to the photo by the camera:

• Location, as accurately as possible.
• One tag for the environment (examples: Indoors, Snow, Rain).
• One tag for the subject matter unless it’s a photo of people, which must be singular (examples: Plane, Car, Landscape).
• One tag per primary person in the shot (examples: Tim, Chester, Me).
• If the photo was taken at night, the tag Night.

This metadata schema is quick to enter and will allow me to filter down my library fairly accurately based on the questions I typically ask when searching for photos. It’s also intentionally very restrictive to avoid tag creep — I don’t want to be entering twenty tags per photo in a year’s time as I slowly start adding more things in.

As for whether this will work, well, only time will tell. It can’t be worse than it was before, right?

If you haven’t decided it’s time to do proper backups, you’re an idiot wrong. All drives, spinning, SSD or otherwise, have a spec called Mean Time Between Failures or MTBF. This is the average time a drive can be expected to work before it fails. Like brake discs on a car, they’re expected to wear out over time. Not fast, but they’re certainly expected to stop working.

Fortunately for you, my dear readers, I have the experience to help! Quoth my friend Tim:

You have, by far, the highest drive failure rate of anyone I know, and I work in a data centre with 1000s of them.

He’s quite right — over the past couple of years I’ve had two spinning disks and one SSD completely die on me. The spinning disks were in an always-on Mac mini and I finally cottoned-on to the fact that laptop drives aren’t designed for continuous running and the head generated therein, and the SSD succumbed to the dreaded 8MB bug that affects cheaper Intel SSDs, which isn’t as “fixed” as they claim.

Still, as a result I’ve gotten my backup regime to the point where the worst part of a drive failure is the effort of buying and replacing the broken drive, and the boredom of watching the progress bar slowly inch forwards as the restoration is done.

If my apartment building catches fire and all of my drives are lost, then the restoration process isn’t so smooth and I don’t have 100% data coverage, but I’ve got the important stuff covered.

I’ve also found a few tricks to ease the pain of restoring, which can be found below. A backup is useless unless it restores properly!

Local Backup

My local backup uses Time Machine to a Drobo connected to a Mac mini that’s at the other end of my apartment. The Drobo can survive a drive failure without breaking a sweat, and there’s a couple of fire walls between the two machines, so if a small fire breaks out with luck one of them will survive.

The Time Machine backup isn’t bootable, so if you’re in a situation where you’d need to carry on using your computer in as little time as possible, consider something like SuperDuper! or Carbon Copy Cloner to keep a live, bootable backup.

Offsite Backup: Online

For offsite backup, I backup my most important stuff (my Documents and Photos folders) online, which totals around 230Gb at the moment. Backing up everything isn’t very economical since it’d take too long, and I could live without most of my other stuff anyway, or get it from somewhere else.

My online backup uses Arq to backup to Amazon Glacier, which I just moved to using instead of Amazon S3. Amazon Glacier is cheaper than S3, but doesn’t have instant access to your data — you may have to wait a few hours between requesting your data and being able to download it. My logic is that if I’m in a situation where I need to recover using my online backup, having to wait a bit will be the least of my worries. Arq supports both S3 and Glacier just fine, so you can use whichever service you prefer.

There are also services that provide online backup solutions, such as CrashPlan, Mozy and many more. However, you have to trust them not to screw up (and going by a friend’s recent experiences, that’s not something you should do lightly). If they go out of business, bye-bye data. However, I trust Amazon not to go out of business any time soon, and Arq backs up using a documented format and there’s even an open-source command-line restoration tool on GitHub, so even if Arq stops being made, I can still get at my data.

Then again, these services do offer some great features such as mailing you a restoration DVD or hard drive if you have a slow internet connection — it’s up to you to weigh up the pros and cons of each method.

Offsite Backup: Offline

If you want everything safely offsite, or online backup isn’t feasible due to a slow internet connection (or both), you’ll want to start physically moving disks around. I don’t do this, but a good solution would be to have two separate backup disks and rotate them. For example:

• Have Time Machine (or whatever) backup to disk 1. Put disk 2 offsite somewhere, like in a locker at work.
• One week later, take disk 1 to work and bring disk 2 home with you.
• Have Time Machine backup to disk 2.
• One week later, take disk 2 to work and bring disk 1 home with you.
• Repeat forever!

As of Mountain Lion, Time Machine supports backing up to multiple disks properly, so swapping them out once a week will be seamless. With this setup, if your house catches fire and you lose everything, the worst case scenario is that your backup is a week behind.

Easing Restoration

For local restoration, there’s a few things you can do to make the restoration process a bit easier:

Getting the Operating System Running

If you have a modern Mac, it has a feature called Internet Recovery that allows the machine to download and install Mac OS X onto a completely blank drive.

However, if you don’t have a fast internet connection or if your Mac doesn’t have Internet Recovery (like my iMac), you can do what I did — I set up my Mac mini running Mac OS X Server (which is now a cheap add-on to Mac OS X from the App Store) to act as a NetInstall agent. It’s a really simple process — an assistant will ask you for a Mac OS X installer either from the App Store or an install DVD and convert it to a NetInstall image.

NetInstall images appear as any other startup disk would.

Once this is done, any Mac capable of running the Mac OS X version you’ve made an image of can boot up and install Mac OS X without having to hunt around for installation media. Simply connect your Mac to the same network as the server and hold Command+N as you switch it on.

Note: When installing over NetInstall, don’t be tempted to do it over WiFi. It’ll be slow and painful!

Double Note: NetInstall isn’t the same as NetBoot. NetBoot allows you to boot up a computer normally over the network, which isn’t the same.

Getting Yourself Up And Running

If you’re happy to leave your computer churning away for hours while your backup is being restored, simply have it restore “normally” through Time Machine or your backup software of choice. Your computer will be out of action for the duration of the restore, but it’s simple and your computer will be just like it was before this whole mess started.

However, if you’re like me, you’ll be impatient and will want to start doing stuff with your computer as soon as possible. Please note that this is a very advanced technique, and I’ve purposefully left the instructions vague to dissuade people from doing it. If you don’t know how to do any of the steps I detailed, you should just let your Mac restore fully through your backup software.

• Using your backup solution, restore as little as possible to get a functioning computer that includes your user account but not the contents of your Documents, Photos, etc folders.
• Log into your empty user.
• Start manually copying things from your backup into your home folder.

Using this technique, you can get up and running really quickly while your massive photo library restores in the background. However, it’s critically important that you restore your user from backup, as both the UID and UUID of the user on your computer must match the one in the backup otherwise you’ll get permissions problems.

The last thing to do is to copy the Library folder. This is invisible by default, and replacing your Library folder of the current user is a bad idea. Therefore, you need to:

• Copy the backed-up Library into your home folder with a new name, like “Library-New”.
• Reboot your Mac into Recovery Mode by holding Command+R as you reboot.
• In the Terminal in Recovery Mode, delete your user’s Library folder and move the “Library-New” into its place.

When you reboot normally, your user will be a mirror of what it was in the backup.

Last Words

The problem with backup is that it’s boring and a pain in the ass. What makes it worse is that computers are very good at hiding the fact that drives are, basically, starting to fail the day you buy them — they’re black boxes of electronics that people assume will keep working.

I’ve gone through enough drive failures to feel incredibly uneasy if my important data is in less than three places — my computer, my local backup and my online backup. Unfortunately, I only got this way by suffering data loss when a drive failed years ago and I had no backup.

If you’re reading this and haven’t already started backing up, I’m sure this advice and all other advice about backups will fall on deaf ears. However, once you do suffer data loss, I hope you come back to this article and that it’s useful for next time.

I’ll leave you with this final thought:

Close your eyes and imagine what you’d do if you went to switch on your computer and you found that it’s drives were completely blank. All of those thousands of hours poured into documents, all those photos of your friends and family, all gone. Forever.

If your answer is anything but “I’d buy a new drive and restore from my backup”, you’d better read this post again while buying external hard drives on Amazon.

The Educated Fanboy is someone who, like a normal fanboy, is completely fanatical about the things they choose to use. They research their product(s) to an insane degree, and end up knowing more than is useful (or even healthy) about the companies and products involved. However, unlike a normal fanboy, an educated fanboy is able to answer the question “So, why don’t you use competitor X instead?”

Fanboy answer: BECAUSE MACS ARE SHIT.

Educated Fanboy answer: I like iOS, but the UI is starting to stagnate a little so I thought I’d hop over and try Android. It’s more interesting, but I miss the seamless integration that iCloud gives you.

Being an Educated Fanboy is why I’m currently using an Android phone after using an iPhone for years, is why I nearly replaced my Canon SLR with a Nikon one despite having a rather large pile of Canon lenses, and is why I have both an iMac and a Windows PC sitting at my desk.

To The Point, Already!

Right! So, I’ve been using Apple’s Aperture as my photography tool since it was at version 1.0 and cost £300. Many years later, I’ve finally decided to sit down and give Adobe’s Lightroom (or, more accurately, Adobe® Photoshop® Lightroom® 4) a go.

Like most fanboy things — Canon vs. Nikon, Xbox vs. Playstation, Corvette vs. Viper, Chrome vs. Safari, Aperture vs. Lightroom, etc — the thing that’ll swing it one way or another for a particular person will be fairly small in the grand scheme of the overall product. All of them are fine products, and nobody can intelligently claim someone is wrong for going one way or the other.

In the Lightroom vs. Aperture fight for my own personal use, the fight came down to three things:

• Lightroom’s Noise Reduction is absolutely amazing.
• Aperture’s book templates are way better than Lightroom’s.
• Lightroom’s workflow MAKES ME WANT TO PUNCH THINGS.

And the workflow is what makes Lightroom fall over for me. When making a book, every time I wanted to make an adjustment to an image I had to hop over to the Develop module, completely removing my book workspace from the screen and breaking my flow. For a while, I just started playing with the Noise Reduction slider to make myself happy again, but considering that I’ve never wanted to de-noise a photo before and that I make books relatively often, there’s no way me and Lightroom can be happy together.

But man, that Noise Reduction…

• Spent 71 hours on my bikes.
• Gone on 81 separate rides, which averages 2.5 per week.
• My longest ride was just over 30km.

You can see my full cycling stats on my Strava profile.

The ride home from work that tipped me over 1,000km.

My new bike has been put through a wide range of terrain, from the dry, sandy mountains of the Alps to wet but smooth rides into work to the muddy, dirty, leafy forests in there area around my home.

One of the reasons I replaced my bike this year was that my old bike had suffered from neglect. A few years ago I rode it a lot in wet, gravelly conditions and fine pieces of gravel got everywhere. I didn’t get my bike serviced (or service it myself), and the gravel wore away at irreparable parts of the frame. It wasn’t gone by any means, but as the bike started needing serious money spending to replace work parts, I didn’t want to spend that money on a failing frame.

Cycling in wet, muddy conditions takes its toll on me, too!

So, I’m preparing to give my bike a thorough service now I’ll be winding the riding down as it gets snowy. Armed with the knowledge I’ve gained over the years and The Big Blue Book of Bicycle Repair, I’ll be spending a weekend taking my bike apart and thoroughly cleaning and re-lubricating the sensitive parts. Since I’ll have it apart anyway, I’ve decided to do a couple of upgrades to the brake system (new hoses) and the tyres (converting to tubeless). It’ll be as good as new!

Here’s my list of tasks. It’ll be a busy weekend!

Brakes

• Bleed brake lines (if needed)
• Adjust lever travel and reach

Rear Gears

• Remove cassette and clean
• Clean and re-lubricate derailleur
• Check gear cables for smoothness/fraying, re-lubricate or replace if needed
• Check and adjust gear shifting

Rest of Drivechain

• Check chain for stretch, replace if needed
• Remove crank and bottom bracket, clean, lubricate and reassemble
• Check wheels and axles for lubrication, correct tightness

Suspension

• Check seals and pressures
• Re-adjust if needed

Frame

• Check frame for cracks etc
• Clean frame, sticker/paint over damage, observe friction points

Miscellaneous

• Check saddle height and position
• Remove dropper post, clean and re-lubricate if needed

I’ve written about models railways on and off on this blog for a few years. However, last year we moved into an apartment large enough for me to dedicate a room to a railway. No more cramped lofts!

Over the next few months, I’m planning to slowly build up a scenic model railway layout complete with towns, forests, lakes and so on. Turns out this quite a huge undertaking, and I’ve already spent a month planning and starting the build. Here we go!

InterCity 125 and Mallard.

Planning

The track, once properly laid, will be pretty much permanent - surrounded by scenery, attached to point motors and have its power lines soldered in. Because of this, make sure you take your sweet time settling on the layout!

I used an app called RailModeller to try various layouts on the computer. Once I’d settled on a rough design, I bought the track plus extras (RailModeller will give you a list of exactly what track you need to create the layout you’ve made) and plonked it down on the board. Inevitably, you’ll tweak the layout once you see it in real life - make sure you keep your changes in sync with RailModeller so you have an accurate inventory of track, and so you can try virtual changes at any time.

Once you have trains running around track set loosely on the table, start asking some questions:

• Is the track too dense? You need space for scenery.
• Is the track too sparse? After all, it is a model railway?
• What’ll go in that gap? How about over there?
• How about more interesting features like tunnels and bridges?
• Is there a station?
• Is there enough storage space to park trains when not in use?
• Is there at least one complete loop so you can set a train running on its own?

Once you’re settled on a layout that’ll make a good model, it’s time to make the track more permanent so you can build it!

My final layout in RailModeller. Real life is a little more flexible than RealModeller, so it’s ok if things don’t exactly line up.

Assembling

Things will get messy when you start assembing the layout!

Electrical

My layout is digital, powered by a system called DCC. DCC is a standard that uses AC current to power the trains and connected accessories. Each train/accessory has a unique address, and commands to them are encoded by varying the frequency of the AC current. This makes the electrical component of the layout slightly more fragile than a traditional DC system, so the layout is wired with a “master” wire running underneath the board, connecting to the track every few metres by smaller wires soldered to the track and passing through holes in the board.

The motors connected to the points are connected to the master wire directly rather than to the track, again through holes in the board.

Ramps

The ramps are made from 9mm plywood, strengthened by thicker timber underneath where appropriate. The drop from the point the 9mm plywood hits the board to the board itself is done using a polystyrene gradient from Woodland Scenics.

When designing and building ramps, it’s important not to make them too steep - about 4% is the steepest you can realistically get away with!

Track Bed

To keep the trains running smoothly and quietly, it’s important to have the track running on a foam or cork bed. I used track bedding once again from Woodland Scenics.

This will likely be the most tedious part of the initial build of the layout - it took me a few days to put the bedding on mine. The bedding needs to be cut and curved correctly then glued onto the track. Points are even harder!

…however, once it’s done it’ll be clean, tidy and smooth running.

Controlling

As mentioned earlier, my layout runs using a digital system called DCC. My controller is fairly normal looking, with a little UI to choose which train or accessory you’d like to control. While controlling trains like this is a lot of fun, controlling accessories is less so. There are thirteen sets of points on my layout, and unlike trains, they can’t be named. When I need to switch a point to drive a train into a siding, it’s often difficult to remember if that point is number 8 or 9.

This is where a piece of software called RailMaster comes in. Plug in the controller via USB and you can use it to build a rough version of your layout, telling it which points are where. Once you’re done, you can click the points on the map of your layout to switch them.

My layout in RailMaster.

The software can also control the trains and runs alongside the controller, allowing you to switch between the software and the controller as you wish.

Next Steps

And with that, my track is completely assembled, ready for the arid wooden plains to be converted into lush forests and busy towns.

And obviously, I didn’t attach my GoPro to a train and make any stupid… oh, who am I kidding?

Time to start stocking up on fake trees!

Soon after that, my fiancée and I decided to take our mountain bikes on a planned summer trip to the French Alps. I’d been saving for a new bike for a couple of months, and ended up going into crunch mode to try and get it before we left. I was successful, and a couple of weeks ago we set off to France with my shiny new yellow bike strapped to the back!

It didn’t stay this shiny for long!

2,400km each way. Totally worth it!

What greeted us after over 24 hours of driving over two days was, well, stunning.

Beats flat old Sweden any day.

Les 2 Alpes

Some of the ski resorts turn into mountain biking parks during the summer, and we were lucky enough to have one within a couple of hours of where we were staying. The general idea is that you rock up to the resort, pay for a lift pass and you get to fly down the fun descents while having lifts escort you and your bike bike up to the top again.

We ended up spending two days at Les 2 Alpes, which gave some of the most awesome bike riding I’ve experienced. It was a lot more technical than I was expecting, and on one of the routes were were thinking “This is a green run?!” a lot of the time.

As I’m helpfully pointing out, you can see some of the lower courses carving their way down the opposite mountain.

A rest stop halfway down one of the more difficult “green” runs.

It sucks to have to stop to adjust stuff, but at least there’s a nice view while you do it!

I also took my new GoPro camera with me, and we had fun attaching the camera to various bits of our bikes and ourselves. I’m really pleased with the result!

If you’re interested in a less editied version, here’s a complete run down the shorter green route at Les 2 Alpes, Vallée Blanche. Warning: There’s some horrible noise from my brakes in this video, which is discussed below!

Casualties

Unfortunately, everything has a weakest link. Much like a lower-end MacBook Pro might be held back by a crappy graphics card, my bike’s weakest stock component is widely known to be its brakes. Keeping a larger-framed gentleman such as myself in check down mountainsides generates a lot of heat, and two days worth of downhill work caused my brakes to start shrieking in pain, vibrating at the exact frequency to send a horrible resonance through my whole bike.

A day’s work of braking causes heat discolouration on my bike’s brake discs.

This is a well-known problem with the brakes (Avid Elixir 7) my bike was kitted out with from the factory, and while there are elaborate ways people have found to fix (or at least mitigate) it, I decided that I’d rather replace them entirely than have a set of brakes that I’d never be 100% confident in.

Thankfully, unlike a MacBook Pro, upgrading components on a bike is fairly simple, and I fitted some beefy Shimano XT brakes to mine when I got back to Sweden. These bad boys are well known to be tough, and even have heatsinks on the brake pads to help dissipate heat better.

Wait, there was an original goal?

Right! Snowboarding. The original plan was to get fit enough for snowboarding. I’ve already cycled over 550km this year and I’m aiming to hit 1,000km before the Swedish winter makes cycling too cold and/or dangerous to do. I genuinely feel a lot fitter already and think I’ll be physically fine when I hit the slopes without wheels.

As always, you can follow my efforts on Strava as I slowly make my way towards my goal.

I recently added some unit tests to CocoaLibSpotify, the Objective-C Spotify framework I’m responsible for. I’m new to using tests, and the benefits have been great — I’m somewhat a convert to test-driven development now. However, this post isn’t yet another essay on TDD — it’s about how to make your testing AWESOME.

On a recent hackday, I took the Mac mini that builds CocoaLibSpotify and runs the unit tests and gave it a slightly more… visual indicator on the test results.

Yellow = running tests, green = all passed, red = one more more failed.

To accomplish this, I made a simpler version of my previous project to control four individual RGB LED strips. The simplified unit uses an Arduino Uno instead of a Mega2560, and only has two channels instead of four (only one of which is used in this project).

The completed hardware - running wires underneath the board makes it much neater!

Once the hardware was up-and-running, I made a slightly modified version of the control software to go on the Arduino (since the Uno has different PWM pins to the Mega2560) and was ready to go! At this point, the unit is compatible with all of the previous code I’ve written for sending colours, except only channels 1 and 2 do anything.

Next, we get a strip of thin plastic and make a loop roughly the size of the Mac mini’s base, stick a flexible LED strip to it and voilà! One glowing Mac mini!

Linking to Unit Tests

Since this was a hackday, the rest of the project is slightly… slap-dash.

First, I wrote a stupid simple Ruby/Sinatra application that provides a REST API over HTTP, allowing you to push colours with a standard HTTP GET request:

http://localhost:4567/push-color?red=0&green=255&blue=0

The entirety of the code is below in its horrible, hardcoded, fragile glory. It’s worth noting that the Uno uses exactly the same protocol as the Mega, so it still needs to be given four colours even though it only supports two.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

require 'sinatra'
require 'serialport'
require 'json'

port = SerialPort.new("/dev/tty.usbmodemfa131", 57600)

get '/push-color' do

  # Push one colour to each channel
  red = params[:red].to_i
  green = params[:green].to_i
  blue = params[:blue].to_i

  message = Array.new(15, 0)
  message[0] = 0xBA
  message[1] = 0xBE
  message[2] = green
  message[3] = blue
  message[4] = red
  message[5] = green
  message[6] = blue
  message[7] = red
  message[8] = green
  message[9] = blue
  message[10] = red
  message[11] = green
  message[12] = blue
  message[13] = red
  message[14] = 0

  for currentIndex in 2..13
      message[14] = message[14] ^ message[currentIndex]
  end

  port.write(message.pack('c*'))

  return "<body style=\"background-color:rgb(#{red}, #{green}, #{blue})\">#{message.to_s}</body>"

end

Next, continuing the trend of implementing this in the worst way possible, I added HTTP requests directly into the unit test code in CocoaLibSpotify. If you start the tests with the command-line parameter -StatusColorServer localhost:4567 it’ll make HTTP requests to the given server:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

-(void)pushColorToStatusServer:(UIColor *)color {
  
  NSString *statusServerAddress = [[NSUserDefaults standardUserDefaults] stringForKey:kTestStatusServerUserDefaultsKey];
  if (statusServerAddress.length == 0) return;
  
  CGFloat red = 0.0;
  CGFloat green = 0.0;
  CGFloat blue = 0.0;
  
  [color getRed:&red green:&green blue:&blue alpha:NULL];
  
  NSString *requestUrlString = [NSString stringWithFormat:@"http://%@/push-color?red=%lu&green=%lu&blue=%lu",
                                statusServerAddress,
                                (NSUInteger)red * 255,
                                (NSUInteger)green * 255,
                                (NSUInteger)blue * 255];
  
  NSURL *requestUrl = [NSURL URLWithString:requestUrlString];                         
  NSURLRequest *request = [NSURLRequest requestWithURL:requestUrl
                                           cachePolicy:NSURLRequestReloadIgnoringLocalAndRemoteCacheData
                                       timeoutInterval:1.0];
  
  [NSURLConnection sendSynchronousRequest:request
                        returningResponse:nil
                                    error:nil];
  
}

And that, my friends, is it! The unit tests set the colour to yellow when it starts the tests, then red or green depending on the outcome. Don’t forget to put your IP address on the company IRC so your colleagues can blink the lights all day long!

This wasn’t the original plan — I was going to get a FitBit and use the Personal Trainer feature to slowly build up the amount of walking and exercise I do to improve fitness. I did get a FitBit and while I really enjoy having it, my use for it now is simply to motivate me to walk where before I might take the lift or an escalator.

What’s happened is that a side-note in my original blog post (”…as well as trying my hardest to cycle more.”) has become a rekindled love of mine — I’m cycling multiple times a week and am having a ton of fun doing it, almost to the point where I forgot about the original plan to go snowboarding!

Tips: Cycling For Fun

Bike

Try to match your bike to your terrain as much as you can. Or, rather — match where you ride to the bike you have. Mountain bikes do have more versatility in that you can ride one on the road much better than you can ride a road bike on forest trails, though. A few tips if you’re looking to buy a bike:

• Spend as much money as you can.

• Don’t get a full-suspension bike that costs less than £1,000/$1,500. There’s no hard-and-fast rule, but every full-suspension bike I’ve seen for less than £1,000 has suffered for simply not having the budget available for decent components (the rear shock absorber on my bike retails for about £300 and is considered “middle of the range”). The result is “pedal bob” — a lot the work you put into pedalling ends up bouncing you up and down on the suspension instead of propelling you forwards.

• Often, top-end components in one category are better than bottom-end components in the next category up. Cable disc brakes vs. hydraulic disc brakes, mechanically sprung forks vs. air sprung forks, etc.

• Make sure your bike is properly set up for your size and weight, including tyre pressures, suspension setup, etc.

• Find a good local bike shop to help you, and you’ll be rewarded in spades. See my recent story about my fiancée’s birthday for a good example.

• Most importantly: DO NOT BABY YOUR BIKE. Good bikes are rewarding when they take a pounding, get stupidly muddy and wet, etc. Plus, “So, I made it all the way to the bottom of the trail only to have my brakes not work right away because they were so covered in mud — I was squeezing so hard on the brakes that when the pads cleaned the discs they locked and I went right over the handlebars!” is a much more awesome story than “I went slowly, but at least my bike was clean!”

My friend Tim on a cycling trip to Germany. No pictures of me here since I had the camera, unfortunately.

Clothing

Cycling can be a literal pain in the ass — I wear a pair of padded lycra cycling shorts every single time I go out on my bike, and a skintight base layer on top to control heat and sweat. Since I’m well aware nobody wants to see a guy of my figure in stuff like that, I wear a pair of baggy shorts and a t-shirt over the top.

In addition, make sure you have a decent pair of gloves and a comfy helmet.

Equipment

I cycle with a decent backpack that has an “air circulating” back — there’s a plastic board in the pack that keeps it away from your back, resulting in a much less sweaty time. Inside that backpack I have:

• A CamelBak holding 1.5-2 litres of water for continual refreshment.
• A bike multi-tool.
• A spare inner tube.
• A puncture repair kit.
• A bike lock.
• A pump.

On longer journeys, or trips away from home, I also add:

• A spare chain.
• More inner tubes.

Also, my bike has a decent light (Light & Motion Seca 700) and a water bottle permanently attached, as well as my GPS, bell, etc.

Base Route

I have a 10km loop that I can do without feeling too tired. Over the past few weeks I’ve gotten faster and less tired around it, and it’s great to see my gradual improvement over time.

Data

These posts are going in a category called “A Nerd Outdoors” for a reason! I now have a Garmin Montana strapped to my bike’s handlebars, which is linked to a cadence sensor for keeping track of how fast I’m pedalling.

My bike’s “dashboard”

The Montana is perhaps overkill for this use, and you can get cheaper devices — even ones specifically designed for bike use — if you’re not interested in all of the features the Montana has.

Once I have this data, I upload it to Strava, an excellent online service for keeping track of cycling which lets me compare how I’m doing with my friends and see my progress and statistics. For example, since April I:

• Have cycled 202km.
• Am averaging 37km/week.
• Am averaging 2 hours, 30 minutes on the bike a week.

This is an example or a recent ride of mine:

I’m iKenndac on Strava if you sign up!

Maps

I’ve already written at length about the advantages of having decent maps for hiking/cycling, but one more use has cropped up: Quite often I’ll be cycling along and see a path disappearing off into a forest and I’ll think “That looks fun, I wonder where that goes?”. Now I make a mental note of where it starts, and once I get home I can look on the map and see if I can fit it into my next ride.

This has already come up trumps — one of my favourite sections of trail in the area was found with this method. The entrance to it is a tiny, root-covered path with a “No horses” sign on it, but it opens out to a fantastically fun, fast, and sweeping section of trail that you can see me on a bit further up the page.

Move To Sweden

Well, this last one might be a bit far-fetched, but man is it awesome for cycling here. I live 13km from the centre of the capital city, and I have a nature reserve full of lakes and awesome cycling trails right on my doorstep. A typical rest stop looks like this:

I guess I should get back out there!

Moving this close to a city — not to mention one in a foreign country — has taken some getting used to. Thankfully Stockholm is very small as cities go, and it’s a beautiful city at that. I’ve grown to love it here, and am finally starting to figure out that although Stockholm is small, it is the capital city of Sweden, so it’s very likely that if I want something I can find it nearby. However, most of the stores I’ve found are big-city style fancy shops — everything is expansive and the staff don’t know squat.

Finally I found a place that’s different, and just in time!

The Bike Shop

It’s a rainy March afternoon and I’m scuttling through Södermalm (a district of Stockholm), cursing myself for not bringing a coat to work. I’d just received some new parts for my bike from a big box retailer and realised that I needed a specific tool fit them. I found a close-ish bike shop that looked halfway decent, and headed out in hope they’d even heard of a HollowTech II BB Tool, let alone have it in stock.

I opened the door to the small looking-shop and stood there in shock. And wet. But mostly in shock — this place was nirvana. To the right, the walls were jam-packed full of bike parts and accessories literally up to the ceiling. To the left are hundreds of bikes of all kinds — from the road bikes that most bike shops I’ve tried specialise in to the mountain bikes I love and crave parts and expertise in.

“Do you have a HollowTech II BB tool in stock?” I ask, with not much hope.

“Well, be don’t have the Park one in, but we do have this other one that’s just as good,” the guy behind the counter says while rummaging through shelves before producing the tool I need.

Well, this is unexpected. In a distant, grey corner of Södermalm I’ve stumbled on what appears to be the perfect bike shop — packed to bursting with parts and tools for my bike, not those damn hipster things, at a reasonable price and, most importantly, with staff who seem to be knowledgable at the task at hand. I’m in love!

The Birthday

“Is there anything else I can help you with?”

I pause for a moment to think. I had considered ordering this from a big retailer in the UK, but for stuff this big I really prefer getting it from a local place, but had come up fruitless so far.

“How much would a Specialized Myka FSR Comp in ‘Small’ be? I’m buying one for my fiancé for her 25th birthday.”

“We don’t have it in stock here, but we could have one in a week or so,” he said, before telling me the price. It’s a buttload of money, but actually worked out cheaper than any UK prices I’d found so far.

“Great!” I say. ”I’ll have one of those, too.”

He looked slightly surprised at selling a bike so easily, and started taking my details.

~ One week later ~

After getting lost twice and likely scaring my friend Rick half to death — I’m so worried Alana will see through my weak excuse for going into Stockholm without her, my driving is less than ideal — we arrive back at Södermalm to pick up the bike.

To my surprise, the same guy is there again.

“I didn’t know how heavy your fiancé is, so I set up the suspension for the average sort of weight of someone that high. Once she gets the bike, you can come back and we’ll set it up properly for her, if you like.” At this point I’m gazing over the wall of parts again, fairly sure I’ll never need any other bike shop ever again, but assure him I already have the tools to set the suspension up myself and thank him for putting the bike together so quickly (it’d only arrived the day before, but he was sympathetic to my cause) and was on my way.

Hey look, a bike! And Rick’s arm.

~ Two weeks later ~

“Surprise!”

The Averted Disaster

My fiancé loves her bike. It’s been living in my friend’s apartment since I picked it up, and as I look it over properly for the first time, my heart begins to sink. The rebound on the rear shock absorber is so slow it’s like it has no pressure in it — when you push the bike down onto its suspension, it takes a good thirty seconds to come up again. I check the pressure — it’s fine. However, the rebound adjuster seems to be stuck and I don’t know enough about how shock absorbers to fix it.

Me and my fiancé are driving back to Södermalm to be at the shop for opening time. We walk in to find the same guy yet again.

“Hi, I picked this bike up a couple of weeks ago,” I say, ”and I think there’s something wrong with it — look.” I push the suspension down and show him the problem.

“Oh, that’s not right!” he says. ”Unfortunately if the shock is broken there’s nothing I can do until Monday — the supplier is closed at weekends.”

My heart sinks. I’d spent so much time organising not just getting the bike in secret, but organising a bunch of her friends to contribute towards it and to take photos saying ‘Happy Birthday!’ for a photo book to accompany it. I go pretty much silent, as is often the case when I get upset. All this effort for a broken gift!

“Oh, it’s your birthday, right?” he says, turning to my fiancé. ”I’m so sorry I ruined the surprise!”

Cheered up slightly by the fact that he remembered my plan, I ask ”Is there any chance you could take it apart today to see if it’s just stuck or something?” It’s a long shot, but I really want my fiancé to have a working bike on her birthday.

“Of course!” he says.

The drive back home is silent. I’m back to being grumpy about the whole thing, and my fiancé’s attempts at cheering me up aren’t really doing much. After a horrible fifteen minutes, we’re 200 metres from home and her phone rings. They’d fixed it! We turned around and drove back to the shop.

~Fifteen minutes later~

Back at the shop, it’s packed. There’s a queue out the door to be served by one of the two people working there, and when it’s our turn, the same guy I’d worked with this whole time (I really should learn his name!) explained that the rear shock had simply got stuck in the lowest position and when he’d taken it out of the bike’s frame and re-pressurised it, it’d popped right back into position and was working fine.

I turn slightly red, realising that that might’ve been my fault — I’d sat on the bike after picking it up, which was the equivalent of trying to support a tank with car suspension. Genuinely happy again, I thanked him for fixing the bike so quickly — especially when it was this busy — and started to leave.

“Okay, let’s get this bike properly set up for you,” he says to my fiancé and motions us to follow him as he carries the bike down a tiny staircase to the basement, which turns out to be a workshop at least as large as the shop upstairs! In the next twenty minutes he proceeds to set up the bike exactly for my fiancé, from the pressures in the suspension to the rebound rate and even cutting the seat post down a bit (she’s slightly… vertically challenged). We end up leaving the shop with a perfectly tuned bike and a free water bottle for our trouble.

This bike shop is the kind of local business I will gladly pay the slight price increase over big-box online retailers to. To recap:

• I dealt with the same person every time, who was technically knowledgable and remembered me and my plan over the month it all took place in.

• When something went wrong, not only did he bend over backwards to help us out in what I imagine is the busiest time of the week for the store, he took the time to make sure the bike was perfectly set up in every way once the problem was fixed.

I can’t remember the last time I’ve experienced customer service this good — they managed to turn having my fiancé’s gift broken on her birthday into two incredibly happy people. That place has me as a customer for life! Everyone should go to Cykelspecialisten on Långholmsgatan, Södermalm RIGHT NOW and buy LOTS OF BIKES.

I’ll have a Specialized StumpJumper FSR Comp EVO, please!

CocoaLibSpotify is an Objective-C wrapper around the libSpotify library, which is a C API providing access to Spotify’s service for music streaming, playlists, etc etc. A more advanced example of what you can do with (Cocoa)LibSpotify is my open-source Viva Spotify client.

CocoaLibSpotify contains a class called SPCoreAudioController that deals with getting audio data from libSpotify, through a Core Audio AUGraph and to the system audio output. The class also provides an easy way of customising the graph, and this post discusses the basics of Core Audio, AUGraph, and customising SPCoreAudioController with a 10-band graphic equalizier.

Note: While this post discusses Spotify technologies, I wrote this because I enjoy the topic at hand and thought it’d be nice to share. The opinions expressed here may not represent those of Spotify, etc etc.

Push vs. Pull

Core Audio and libSpotify have two opposing methods of dealing with audio data.

• libSpotify uses the “push” method, which basically means it says “Here is some audio data, you should play it!”

• Core Audio uses the opposite “pull” method, which means it asks “I need to play some audio, can I have some?”

This means that, unfortunately, we can’t simply hook libSpotify up to Core Audio and get playback happening. Instead, we need to store the audio provided by libSpotify into a buffer which we’ll then read from when Core Audio requests some audio data.

To solve this in an elegant manner, CocoaLibSpotify includes a ring buffer, which is a special kind of buffer that allows data to be read and written to is without reallocating memory, which can be expensive.

Audio Units and AUGraph

Core Audio uses a concept of “units” when working with audio. Each unit carries out a single task, such as applying an effect or actually playing the audio. AUGraph then provides a way to chain Audio Units together, much like how an amplifier stack works in the physical world.

To simplify this for most use cases, CocoaLibSpotify includes a class called SPCoreAudioController, which implements an AUGraph with three nodes:

• Converter Node: Takes audio as delivered from libSpotify from the ring buffer and converts it into the canonical format used by Core Audio.

• Mixer Node: Mixers are normally used to mix audio from multiple sources, but here it’s used simply to provide the ability to control volume separately from the system volume, since the audio output unit on iOS doesn’t provide volume control.

• Output Node: This node takes the completed audio and delivers it to the system’s default audio output.

Once this is up-and-running, SPCoreAudioController is managing an audio chain that looks like this:

Customising SPCoreAudioController

If you want to customise audio playback, SPCoreAudioController includes a handy pair of methods that allow you to insert any AUNode you like into the AUGraph without having to manage the whole graph, making the chain look like this:

So, let’s provide an example that inserts a 10-band graphic EQ into the graph:

Note: The completed sample project can be found on GitHub here.

First, create a new class subclassing SPCoreAudioController - the sample project calls it EQCoreAudioController - then override -connectOutputBus:ofNode:toInputBus:ofNode:inGraph:error:.

In this first example, set up a description of the EQ Audio Unit then have the graph add a node matching that description before getting a reference to the Audio Unit itself so we can set properties on it. Then, it initializes the Audio Unit and sets it to a 10-band EQ.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@implementation EQCoreAudioController {
    // Keep the node and unit around so we can reference them anytime.
    AUNode eqNode;
    AudioUnit eqUnit;
}

-(BOOL)connectOutputBus:(UInt32)sourceOutputBusNumber
                 ofNode:(AUNode)sourceNode
             toInputBus:(UInt32)destinationInputBusNumber
                 ofNode:(AUNode)destinationNode
                inGraph:(AUGraph)graph
                  error:(NSError **)error {

    // A description for the EQ Device
    AudioComponentDescription eqDescription;
    eqDescription.componentType = kAudioUnitType_Effect;
    eqDescription.componentSubType = kAudioUnitSubType_GraphicEQ;
    eqDescription.componentManufacturer = kAudioUnitManufacturer_Apple;
    eqDescription.componentFlags = 0;
    eqDescription.componentFlagsMask = 0;

    // Add the EQ node to the AUGraph
    AUGraphAddNode(graph, &eqDescription, &eqNode);

    // Get the Audio Unit from the node so we can set properties on it
    AUGraphNodeInfo(graph, eqNode, NULL, &eqUnit);

    // Initialize the audio unit
    AudioUnitInitialize(eqUnit);

    // Set EQ to 10-band
    AudioUnitSetParameter(eqUnit, 10000, kAudioUnitScope_Global, 0, 0.0, 0);

    //... continued in next code snippet.

At this point, our EQ is set up and inserted into the audio controller’s graph. All that’s left to do now is hook it up to the provided source and destination nodes so audio gets piped through it:

1
2
3
4
5
6
7
8
9
10
11
12

    // ... continued from previous code snippet.

    // Connect the output of the provided audio source node to the input of our EQ.
    AUGraphConnectNodeInput(graph, sourceNode, sourceOutputBusNumber, eqNode, 0);

    // Connect the output of our EQ to the input of the provided audio destination node.
    AUGraphConnectNodeInput(graph, eqNode, 0, destinationNode, destinationInputBusNumber);

    return YES;
}

@end

That’s it! The EQ node is now inserted into the AUGraph managed by SPCoreAudioController, which now looks like this:

It’s important to do cleanup as well so we don’t leak memory and cause problems. SPCoreAudioController provides -disposeOfCustomNodesInGraph: to be overridden for just this purpose:

1
2
3
4
5
6
7
8
9
10

-(void)disposeOfCustomNodesInGraph:(AUGraph)graph {

    // Shut down our unit.
    AudioUnitUninitialize(eqUnit);
    eqUnit = NULL;

    // Remove the unit's node from the graph.
    AUGraphRemoveNode(graph, eqNode);
    eqNode = 0;
}

Finishing Up & Adding UI

Now we have an EQ inserted into our Core Audio graph, we need to control the levels! To do this, the sample project implements the following method in EQCoreAudioController, which applies up to ten band values.

1
2
3
4
5
6
7
8
9
10
11

-(void)applyBandsToEQ:(NSArray *)tenBands {

    if (eqUnit == NULL) return;

    // Loop through our bands and update them.
    for (NSUInteger bandIndex = 0; bandIndex < MIN(10, tenBands.count); bandIndex++) {

        Float32 bandValue = [[tenBands objectAtIndex:bandIndex] floatValue];
        AudioUnitSetParameter(eqUnit, bandIndex, kAudioUnitScope_Global, 0, bandValue, 0);
    }
}

The sample project then has ten continuous vertical sliders all hooked up to different IBOutlets but calling the same IBAction. It’s best to set your sliders to range between -12.0 and +12.0 (this is the range iTunes uses in its EQ) otherwise the distortion gets a bit unbearable!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

-(IBAction)eqSliderDidChange:(id)sender {

    NSMutableArray *bands = [NSMutableArray arrayWithCapacity:10];

    [bands addObject:[NSNumber numberWithFloat:self.eqSlider1.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider2.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider3.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider4.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider5.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider6.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider7.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider8.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider9.floatValue]];
    [bands addObject:[NSNumber numberWithFloat:self.eqSlider10.floatValue]];

    [self.audioController applyBandsToEQ:bands];
}

Further Reading

Learning Core Audio: A Hands-On Guide to Audio Programming for Mac and iOS by Chris Adamson and Kevin Avila.

Yes! Sony’s PS Vita software seeing double and not communicating it very well.

This is why I’ve had this expensive GPS unit — a Garmin Colorado — strapped to my bike for nearly four years and I’ve barely even looked at the software. In 2008, Garmin’s software was largely Windows-only and while the mapping application (MapSource) was certainly powerful, its UI was very late-90s Windows and incredibly unintuitive to use.

I ended up with a set of incredibly detailed topographic maps on a device with a 3” display and nowhere else. I certainly got use out of them, but mainly on the trail with my bike or out hiking, using them to decide which direction to turn when I came to a junction.

A few weeks ago, while researching Gamin’s latest outdoor GPS unit, the Garmin Montana, I discovered they’d released a Mac version of their newer mapping application, BaseCamp. I decided to give it a try and it instantly increased the value of topographic maps ten-fold, and has completely transformed cycling and hiking for the better.

You PAY for maps?! But Google Maps is free!

As I was tweeting about this as I was researching it, someone derisively pointed out that “There’s an app for that!”, likely free. And sure, topographic maps are expensive — the maps on my device that cover the section of Sweden I’m in (roughly 1/4 of the country) cost $199. However, Google Maps doesn’t even come close to offering the level of detail these maps do, and while OpenStreetMap is better in my area they still don’t match the quality and level-of-detail of these proper maps. Oh, and there’s no way in hell I’m strapping an iPhone to my bike’s handlebars!

Google Maps on the left, 1:50,000 Topographic map on the right.

This path is on the topographic maps!

Using Garmin BaseCamp and Good Maps for Fun and Adventure

So, why is this so awesome? Well, BaseCamp has a superb map display, allowing you to virtually explore the paths and trails with ease and import logs of recent hikes and bikerides to be shown on the map.

BaseCamp’s Map Display, overlaid with a track of a recent bikeride (magenta).

The software comes into its own when planning where to go, though. You can draw out potential routes on the maps and you’ll be given standard stuff like distance, but also a height map of the route. This is invaluable for planning outdoor treks — the route shown above was great fun because as the height map below shows, it’s paced nicely with each steep uphill part followed with a rest, and running it in reverse on the way home has a nice long downhill section to finish on.

BaseCamp’s Height Map

As the quest to go snowboarding continues, this workflow is really helping me explore the countryside on my bike and have a lot of fun doing it. We’re going to the French Alps in the summer, and I’m really looking forward to getting maps of the area and going on some epic bikerides!

Of course, I stopped worrying and “slowly” became “nothing”, and I’ve been more or less a constant weight ever since. In fact, according to the Wii Fit, I’ve lost 6lbs in the past 617 days.

The problem is, I really enjoy the outdoors. I love hiking, cycling and more recently snowboarding, and being a big fat guy kinda gets in the way of that. Like many people, every year or so I vow that I’ll cycle and walk more, reduce my cake intake and generally get fitter. And, like most of those people, I fail pretty hard at changing my bad habits.

Me, right, cycling at the Nürburgring with friends

This Time, I Mean It — But Not Like Those Other Times I Said “This Time, I Mean It”

The problem is setting goals. I hate the gym and don’t care about my weight in that I have no interest in getting to some arbitrary number. I can already walk and cycle to some degree, so goals like “I should be able to cycle x kilometres” ends up being another arbitrary goal I don’t have much interest in.

However, I’ve found a new activity I really care about, and that I currently can’t do very well — sliding down the side of a mountain on a plank of wood! A year or so before we moved to Sweden, my fiancé and I took some skiing and snowboarding lessons and got proficient enough to tackle a mountain. As luck would have it, my mother lives literally twenty minutes drives from Risoul, a ski resort in the French Alps, so off we went for some mountainside action!

I absolutely adore snowboarding — I could’ve stayed there all week. Except that’s the problem — I don’t have the stamina to keep my ample frame upright on a snowboard for more than a day, and after that I started to get exhausted very fast, causing me to fall over more, causing me to get exhausted even faster.

I fell over a LOT.

There’s Nothing Like Public Shaming To Spur Motivation

I’m writing about this plan here simply so it’s out in the public domain — if I fail, my friends and internet strangers have full permission to mock me mercilessly.

The Goal: To be fit enough to go snowboarding in winter 2012/13 and have a damn good time.

The Plan: I’ve bought a FitBit to allow me to keep track of my daily activity. The software has a “Trainer” that slowly ramps up your activity targets over time, allowing me to increase my daily exercise levels in a way that doesn’t impact my daily routine. In addition, I’ll have a few of my friends set targets to meet that the software might not think of, as well as trying my hardest to cycle more.

And damnit, I’ll cut down on Coke/Pepsi/etc once and for all — which will be the hardest thing to do since there’s a fridge full of the damn stuff at work — for FREE!

So, friends and internet strangers — if I fail again, at least I’ll be doing it publicly so you can all yell at me for being a lazy bum.

Feel free to shout motivation and/or helpful goals to aim for - I’m @iKenndac on Twitter. A nice one a friend of mine suggested today was, given x as the number of weeks since you started, do 2x pushups each morning. In the first week it’s just two, which is nothing — but after a few months it really starts to add up!

Dragons LOVE Rayman!

Thursday morning. It’s cold and wet, and me and three friends are trudging round Stockholm to pick up the PS Vita consoles they wanted. “I’m not going to get one!” I proudly proclaim, “I have a PSP and never play on it, and Sony have never made good software. Ever!”

“True!” they agreed, “But the launch lineup looks really good! And look how shiny it is!” I couldn’t disagree — it is shiny.

We get back to the office and Rick boots his Vita. “Would you like to use your PSN account?” it asked. Of course! He put in his details. Confirms that yes, he’d like to use his account. “Please wait…”.

“You need to update your Vita to the latest software version to sign into PSN.” A single button — OK. At this point, the Vita is back one step, at “Are you sure?”. We’re now stuck in the first-boot tutorial with no way forward. After a couple of minutes, we figure out that you need to go back two steps, answer No to “Would you like to use your PSN account?” then tell it your date of birth and country to get out of the tutorial and update the software.

I sit, piling a McDonald’s Big Mac into my face, happy about my decision to not buy one. Sony’s software is as bad as ever! However, as Rick starts navigating around the device, it doesn’t look that bad.

You’ll see this a LOT.

The Downfall

I start to feel a bit woozy. Thinking that perhaps inhaling a Big Mac in less than a minute wasn’t such a smart idea, I head back to my desk to carry on work. After ten minutes, staying upright in my chair is becoming a challenge and I remember that the hole where I had a tooth removed the week previous felt a bit… funny. I head home, go to the dentist to get told that my mouth is infected “a bit”, that I’ll need to double the use of the antibacterial mouthwash stuff I got last week, and that I’ll just have to put up with being dizzy for a while.

I return home, feeling rather sorry for myself. Confirm with my team lead that it’s OK to work from home for the rest of the week since while falling over a lot is hilarious to begin with, its gets old fast. Work for a little while. Porting Objective-C code to C++ starts draining my soul. Now I’m even more sad.

Hey, look! The Vita is only 1990kr at Elgiganten! That’s cheaper than Amazon UK!

FINALLY The Review!

I’m not going to do a full review here. You can find a hundred of them online, so I’ll just sum up my opinions:

• The screen is beautiful.
• Proprietary memory cards and connectors are the spawn of Satan himself.
• Rayman Origins and Wipeout 2048 are the most beautiful mobile games I’ve ever seen.

Rayman Origins.

Oh, and the Mac software for connecting to the device is as awful as you might expect. It took 1.5Gb of RAM on my machine, then popped up this when I connected my Vita:

…so that got deleted pretty much right away.

What intrigues me most, though, about the Vita is the “home screen” menu system and multi-tasking UI, and the way it deals with the fact that only one “real” process can be active at a time. I really quite like the concepts they’ve employed, and this discussion will be looking past the stupid stuff Sony likes to do (like three separate “Please Wait…” dialogs when you sign into PSN) in favour of the overall flow of things.

A basic overview of the UI:

• The Vita displays applications as pebbles on a vertically scrolling grid. Each “screen” can hold ten pebbles, which can be moved around freely.

• When you tap an application’s pebble, its card is loaded and added to the stack, which scrolls horizonally. The main button on this card will launch or resume the application, so getting from the home screen to your application is at least two taps.

• An application’s card is customisable - each card has a button to launch or resume the application, as well as a optionally other buttons to launch to specific parts of the application, read the manual, visit related websites, and so on.

• Only one major application can be active at a time. If you press the PS button in an application you’ll be sent back to the home screen and can browse the web, do social stuff and so on. If you try to launch another major application, the Vita will warn you that the other one will be closed.

• Up to six cards can remain in the stack. If you want to remove a card from the stack, grab the top right-hand corner of it and rip it off the screen - this will remove the card and completely quit the application if it’s still running.

Application pebbles.

The PSN Store’s card, featuring buttons for categories and current “trending” games.

In Action

While that sounds like a complicated UI, it actually works really well in real-world use and I’m very fond of it. The cards allow applications to show useful information without actually launching the app, and tearing a card out of the stack has a wonderful feel. Navigating around the system to find what you need is slick and fast.

Below is a video of the stacks UI, which shows the first-world problem shiny, glossy devices bring - very visible dust!

Only time will tell, but I’m really enjoying the experience with the Vita - the games are fun to play and absolutely gorgeous, and the hardware is beautiful. Hopefully it’ll stand the test of time better than the PSP.

They’ve been saying for a while now that an official Aperture Export plugin is coming, and there seems to be a lot of demand. Well, I got bored of them taking their sweet-ass time and threw together my own.

It requires Mac OS X 10.7 (Lion) and Aperture 3.x, and do bear in mind that I made this in less than 48 hours, so it may be buggy and it’s certainly light on features. But, it gets my photos directly from Aperture into 500px, so I’m happy!

You can find out more and download the plugin from GitHub. Enjoy!

Oh, and if anyone loves this plugin so much that they want to get me a gift, well, gifting me a year’s worth of awesome would certainly be appreciated!

Two days after we arrive in the UK, the lens my friend gave us stuck at 17mm and wouldn’t budge. I felt super-bad about this, even though it turned out it was a common problem with this lens.

Still feeling bad about breaking my friend’s lens, I dived right into the tutorial and tried to fix it! Lenses are incredibly intricate, and my first attempt wasn’t so successful - I’d fixed the zoom sticking, but now the focus didn’t work!

Take Two

Tonight, I tried to fix it again, and was successful! The lens’ zoom is a smooth as ever and the focus works too. I was ecstatic, and I looked down to see my dog staring at me with glee, raising his paw as if to say “HIGH FIVE bro, you tha man!”

A couple of seconds later I realised he was actually trying to say “Damnit I’m hungry - give me food!” Still pleased with my dexterity and skill, I went to the kitchen to distribute food for him and ended up with, well, a less than optimal result.

I guess there’s no brain surgery in my future after all.

This routine is lovely and lazy, but isn’t really helping me get stuff done - I have a ton of side projects, I want to play my guitar, I want to occasionally spend time listening to music as a primary activity (rather than in the background while I’m doing something else), etc etc.

It’s also been very easy to fall into the trap of thinking I simply don’t have time to do all these things - I mean, I get home, eat dinner, spend a small amount of time on the computer and now it’s bed time!

Be Selfish!

Recently, I’ve been trialling having an enforced “me time” - one hour per weekday, in the evening, where I’ll stop what I’m doing (within reason!) and go and do one of the above things.

So far, it’s working out really well. I’m fortunate to live in an apartment large enough to have a room available for filling with the kind of toys required for this - so far it’s decked out with a model railway, a fairly decent audio system and a small guitar rack with an amp. Best of all, it’s right at the opposite end of the apartment to the living room and above the entrance hall to the building, meaning I can make a racket without bothering my fiancé or anyone else.

Now I’ve settled into the routine - I’ve been doing this for a couple of weeks now - I’m actually finding that I’m enjoying my evenings way more and I still have plenty of time to do the things I’d normally do anyway - I can eat dinner, faff around on the computer a bit, play World of Warcraft with my fiancé and still have an hour for Me Time. My fiancé heartily approves because it means she can watch her crappy girl TV without me complaining about it.

So, if you’re finding you don’t have time to do the things you’d like to do in your spare time - I’d thoroughly recommend giving an hour of forced “me time” a try - it doesn’t even have to be every day!