Alex J

Sauna 1.0

Wed, 24 Jun 2020 17:00:00 +0100

I’m pleased to announce the release of a new macOS app I’ve been working on for a few weeks. Called Sauna, it’s a lightweight app that displays your Steam friends list and notifies you when a friend comes online. Of course, this is all functionality that the Steam client provides but the goal of Sauna is to be a good macOS citizen and to be extremely lightweight.

Sauna regularly updates your friends list throughout the day and notifies you when a friend comes online or starts playing a new game. It’s focused on doing just this one thing.

Sauna is useful for those of us who game in Boot Camp or have a dedicated PC for playing games. With Sauna you can check in on your friends without rebooting your Mac or booting your PC.

You can download the first release of Sauna from the project’s GitHub page. It requires macOS 10.15 or later. You’ll need a Steam API key to use it which you can get by filling in this form on Steam’s website.

Fetched Results Controller & Diffable Data Source Snapshot Issues

Thu, 02 Jan 2020 13:00:00 +0100

In iOS 13, NSFetchedResultsController gained support for delivering changes to its content as a NSDiffableDataSourceSnapshot via. its delegate. The snapshot contains the contents of the controller and can be used to populate a table or collection view complete with animations for content updates.

Unfortunately the API has a few issues. The way it’s bridged from Objective-C to Swift makes using it a bit confusing and it doesn’t match all the functionality of the older delegate methods. In this post I’ll document a couple of the issues I’ve run into and how I’ve worked around them.

Using Snapshots in Swift

The first issue I encountered using the new API is accessing the snapshot from Swift. The documentation declares the signature of the snapshot delegate method as

func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith snapshot: NSDiffableDataSourceSnapshot)

but this isn’t correct as NSDiffableDataSourceSnapshot has two generic parameters for the SectionIdentifier and ObjectIdentifier that are missing. The delegate method’s signature actually bridges from Objective-C as:

func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith snapshot: NSDiffableDataSourceSnapshotReference)

The snapshot is an instance of NSDiffableDataSourceSnapshotReference, a class that lacks the generic type parameters found on the struct version. By itself this class seems useless as there aren’t any other APIs that use it and it seems to only exist to bridge this delegate method. To use the snapshot, you must cast it to a NSDiffableDataSourceSnapshot<String, NSManagedObjectID>:

func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith snapshot: NSDiffableDataSourceSnapshotReference) {
 let snapshot = snapshot as NSDiffableDataSourceSnapshot<String, NSManagedObjectID>
 // Do something with the snapshot
}

Note that you can put any type for the SectionIdentifier and ItemIdentifier parameters and it’ll compile but only String and NSManagedObjectID are valid as can be seen in the declaration of the Objective-C protocol:

- (void)controller:(NSFetchedResultsController *)controller didChangeContentWithSnapshot:(NSDiffableDataSourceSnapshot<NSString *, NSManagedObjectID *> *)snapshot

At this point you’ve got a normal NSDiffableDataSourceSnapshot that can be used with a table or collection view. I don’t quite understand why the delegate method gets bridged this way though since the Objective-C declaration is using lightweight generics that should bridge across to Swift generics.

Tracking Object Updates

The traditional delegate methods for NSFetchedResultsController updates provide notifications of object insertions, updates, moves and deletes. Although NSDiffableDataSourceSnapshot supports tracking all these events, the snapshot provided to NSFetchedResultsController’s delegate only tracks insertions, deletions and moves.

If you need to track object updates via. a data source snapshot, you’ll need to use the traditional delegate methods to build and maintain your own snapshot. Using Swift’s new CollectionDifference type this isn’t too hard, particularly if you only need to deal with one section. Note that you won’t be able to use the NSManagedObjectID as an ItemIdentifier in the snapshot though for reasons I’ll explain below.

In my situation when dealing with a single section I was able to get away with an implementation like this:

import UIKit
import CoreData
import Combine

/// A singleton section for the snapshot
struct Section: Hashable {
 private init() { }
 static let main = Section()
}

final class SingleSectionController<Object: NSManagedObject>: NSObject, NSFetchedResultsControllerDelegate {

 @Published
 var results = NSDiffableDataSourceSnapshot<Section, Object>()

 private let resultsController: NSFetchedResultsController<Object>

 init(context: NSManagedObjectContext, request: NSFetchRequest<Object>) {
 self.resultsController = NSFetchedResultsController(fetchRequest: request, managedObjectContext: context,
 sectionNameKeyPath: nil, cacheName: nil)

 super.init()

 resultsController.delegate = self
 }

 func fetchData() {
 // Handle errors gracefully in production
 try! resultsController.performFetch()
 generateNewSnapshot()
 }

 private func generateNewSnapshot() {
 var initialSnapshot = NSDiffableDataSourceSnapshot<Section, Object>()
 initialSnapshot.appendSections([.main])

 if let objects = resultsController.fetchedObjects {
 initialSnapshot.appendItems(objects, toSection: .main)
 }

 self.results = initialSnapshot
 }


 // MARK: - Fetched Results Controller Delegate

 private var transientChanges: [CollectionDifference<Object>.Change] = []
 private var updatedObjects: Set<Object> = []

 func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
 transientChanges.removeAll()
 updatedObjects.removeAll()
 }

 func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
 guard let object = anObject as? Object else { return }

 switch type {
 case .insert:
 let insertionIndex = newIndexPath!
 transientChanges.append(.insert(offset: insertionIndex.row, element: object, associatedWith: nil))

 case .update:
 updatedObjects.insert(object)

 case .move:
 let sourceIndex = indexPath!.row
 let destinationIndex = newIndexPath!.row

 updatedObjects.insert(object)
 transientChanges.append(.insert(offset: destinationIndex, element: object, associatedWith: sourceIndex))
 transientChanges.append(.remove(offset: sourceIndex, element: object, associatedWith: destinationIndex))

 case .delete:
 let deletedIndex = indexPath!.row
 transientChanges.append(.remove(offset: deletedIndex, element: object, associatedWith: nil))

 @unknown default:
 fatalError("Unhandled \(NSFetchedResultsChangeType.self) \(type)")
 }
 }

 func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
 guard let collectionDifference = CollectionDifference(transientChanges) else {
 // In theory, NSFetchedResultsController should deliver valid changes. In practice, I don't trust it so fall
 // back to generating a new snapshot if the changes can't be used as a diff.
 assertionFailure("Unable to create a collection difference from the changes \(transientChanges)")
 generateNewSnapshot()
 return
 }

 var newSnapshot = self.results
 for change in collectionDifference {
 switch change {
 case .insert(0, let object, _) where newSnapshot.numberOfItems(inSection: .main) == 0:
 newSnapshot.appendItems([object], toSection: .main)

 case .insert(0, let object, _):
 newSnapshot.insertItems([object], beforeItem: newSnapshot.itemIdentifiers(inSection: .main).first!)

 case .insert(newSnapshot.itemIdentifiers(inSection: .main).count, let object, _):
 newSnapshot.appendItems([object], toSection: .main)

 case .insert(let index, let object, _):
 let existingItem = newSnapshot.itemIdentifiers(inSection: .main)[index]
 newSnapshot.insertItems([object], beforeItem: existingItem)

 case .remove(_, let object, _):
 newSnapshot.deleteItems([object])
 }
 }

 newSnapshot.reloadItems(Array(updatedObjects))
 assert(newSnapshot.itemIdentifiers == resultsController.fetchedObjects ?? [],
 "Final snapshots items do not match the FRC's fetched objects")

 self.results = newSnapshot
 }
}

This tracks insertions, updates, moves and deletions using Swift’s CollectionDifference type to handle applying the updates in the correct order. Compared to the controller(_:didChangeContentWith:) method, this implementation does have one downside. As the snapshot’s ItemIdentifier are instances of NSManagedObject, you can’t apply the snapshot from a background queue (or at least, a different queue to the controller’s context’s queue) whereas you can when using NSManagedObjectIDs as identifiers.

The Problem with Object IDs

The reason for using NSManagedObject as the ItemIdentifier instead of NSManagedObjectID is due to how NSFetchedResultsController handles temporary object IDs. As soon as an object matching the controller’s fetch request is inserted into the context, the controller will notify the delegate of an insertion. At this point the object only has a temporary ID as it hasn’t been saved to the context’s persistent store yet. If we were using an NSManagedObjectID as the snapshot’s ItemIdentifier, we’d add a temporary ID to the snapshot at this point.

When the context is saved, the inserted object is given a (different) permanent object ID. Although we can continue to use the temporary ID to retrieve the object from its context, the NSManagedObjectID returned by the object’s objectID property will be the new, permanent ID.

Any subsequent updates to the object will be delivered to the results controller’s delegate as updates or moves. When we try to update the data source snapshot using the updated object’s NSManagedObjectID, the data source will throw an exception because it only contains the temporary object ID, not the permanent ID.

If you must use NSManagedObjectID as the data source’s ItemIdentifier, you can (kind of) exclude objects with a temporary ID from the results controller by creating a private, read-only child context of the main context for the results controller. The child context (and by extension the results controller) will not know about newly inserted objects until the parent context is saved at which point the objects will have a permanent ID (assuming the parent context is a root context).

This setup creates some new problems though. If you need to merge changes into the parent context from another context (say a background context), the merged changes won’t propagate to the child context automatically, even if automaticallyMergesChangesFromParent is true for the child context.

Normal Screensaver

Mon, 28 May 2018 09:00:00 +0100

I published a new project on GitHub today. It’s a screensaver for macOS called Normal. It simply applies a Gaussian blur to the contents of the screen. I wrote it a year ago when I was procrastinating from my dissertation. Go ahead and check it out on GitHub.

A Banner View for iOS 11+

Thu, 07 Dec 2017 18:00:00 +0000

I needed a way to present non-modal alerts inside an app I’m working on and wanted to use a banner system that’s a bit like what Tweetbot¹ does. I ended up writing a UIView subclass called BannerView that I’ve open sourced for anybody to use.

The banner view uses the new safe area layout guides introduced in iOS 11 to lay itself out correctly when navigation bars are present. The top of the banner expands to fill the top safe area which looks really cool on an iPhone X²:

Ack! Your browser doesn't support WebM or MP4 videos! What is this, the 3DS browser?

The appearance of the banner is easily customised and an optional icon can be displayed alongside the message. There’s support for a swipe-to-dismiss gesture baked in too.

There are a few minor issues but they shouldn’t be too hard to fix. The banner doesn’t quite resize properly if the phone’s rotated and things get a bit funky if the banner’s embedded inside a navigation bar with prefersLargeTitles = true. Oh, and there’s no built in way to perform an action when the user taps the banner although you could accomplish that by attaching a UITapGestureRecognizer to the view.

Again, you can get BannerView from here. It’s licensed under an MIT license.

I haven’t used Tweetbot for almost a year but I know it used to have these banners. ↩︎
At least, it does in the simulator. I can only imagine what it looks like on an actual device. ↩︎

How a Core Data Attribute's Name Can Lead to Crashes

Fri, 10 Nov 2017 19:55:00 +0000

TL;DR: You can’t name a Core Data attribute new* in Objective-C or Swift because of how automatic reference counting interacts with manual reference counting. If you do, you’ll crash unreliably when your Core Data stack is deallocated.

I’ve spent the better part of a day trying to fix this hard to track down bug in my Core Data stack that was causing a crash. The crash was introduced when I added a new entity to my object model. The NSManagedObject subclass looked a little like this:

public final class RenamedThing: NSManagedObject {
 @NSManaged private(set) public var newName: String
 @NSManaged private(set) public var oldName: String
 @NSManaged public var markedForLocalDeletionDate: Date?
}

Any tests that accessed RenamedThing’s newName attribute would crash when the NSPersistentContainer was set to nil in the test’s tearDown() method. The crash message looked like:

xctest(..) malloc: *** error for object ..: pointer being freed was not allocated
*** set a breakpoint in malloc_error_break to debug

After eliminating any possibility of this being a bug related to Core Data’s concurrency model, I broke out Xcode’s memory graph debugger and then NSZombie to see if I could find anything. This felt like an odd thing to do since this is Swift and so automatic reference counting (ARC) is active and I can’t make any manual calls to release anywhere. In the end, neither the memory graph debugger nor NSZombie were of any help.

At this point I was starting to think that this might be a bug in Core Data. To check I wasn’t doing something crazy stupid with ARC though, I checked through the documentation on ARC. Eventually, I came across the Transitioning to ARC release notes and found this lovely tidbit under the “new” rules section:

You cannot give an accessor a name that begins with new. This in turn means that you can’t, for example, declare a property whose name begins with new unless you specify a different getter[.]

I renamed the newName attribute to something else and, of course, my tests stopped crashing. This is both my favourite and least favourite type of bug—a bug that takes hours to figure out but just a second to fix.

I was surprised to find that the transitioning to ARC guide is still relevant today, even in Swift. I think this means that Core Data is still using manual memory management (at least in parts) which is a little surprising given how long ARC has been available and how complicated the memory management must be for Core Data. Still, “if it ain’t broke then don’t fix it” is probably a really good rule to stick by for something as complex as Core Data.

Core Data Property-Level Model Validation in Swift 4

Mon, 25 Sep 2017 19:00:00 +0100

I ran into an issue while writing property validation methods for a Core Data stack where the methods simply weren’t being called. After a bit of head scratching I realised it was because the methods needed to be annotated with @objc. This wasn’t needed in Swift 3 because @objc was inferred on all methods of subclasses of NSObject; however, the behaviour of @objc inference changed in Swift 4. Now, subclasses of NSObject must explicitly mark methods that need to be accessible from Objective-C. This took longer to realise than it should have since the Core Data documentation’s sample code for property-level validation hasn’t been updated for Swift 4.

Strongly Typed Notifications in Swift

Fri, 07 Jul 2017 14:48:00 +0000

While working on rewriting Spotijack in Swift, I started to feel dissatisfied with Foundation’s notification API. It’s a stringly typed API that makes heavy use of Any and as someone who loves their types this makes me sad. To cheer myself up, I set about writing a more strongly typed notification system.

The end result is a small library¹—TypedNotification—that provides a set of protocols defining a more descriptive type system for notifications. Check out the GitHub project if you’re interested. There’s a Playground in it demoing the protocols. The rest of this blog post will cover them in a bit more detail.

Features

Before I show you the protocols, let me run you through what I wanted to achieve.

Closure Based API

First, I wanted to have a closure based API that closely mirrors the foundation API. Swift has a concise syntax for closures that makes it easy to create short pieces of code. For longer blocks of code, Swift has function references that let functions be used as closures. Furthermore, closures encapsulate information on the types of their arguments which selectors lack. The foundation API already contains a block based function for notifications so my protocol can simply mimic that API.

Notifications as Types

The second requirement is for notifications to convey as much information as possible using their types. That means no identifying notifications by a string (at least, not to the user) and no userInfo dictionary to attach data to a notification. A notification’s identifier should be inherent to its type and any data attached to the notification should be declared as properties.

Automatic Removal of Observers

Finally, I wanted to get rid of the need to think about the lifetime of observers. The block based foundation API returns an opaque object that users must remember to unregister before it is deallocated. Forgetting to manage these objects creates bugs that are difficult to pass off as features.

The TypedNotifcation Protocol

Overview

This is the core protocol of TypedNotifications. Types that conform to this protocol can be posted as notifications. The protocol declaration is simple:

protocol TypedNotification: Namespaced {
 associatedtype Sender
 /// The name of the notification to be used as an identifier.
 static var name: String { get }
 /// The object sending the notification.
 var sender: Sender { get }
}

All types conforming to TypedNotification have a name property that’s used to identify the notification and a sender property that’s used to identify the sender. The sender property has an associated type that can be used to constrain senders to a subset of types.

This protocol reduces the chances of making a mistake with the stringly typed notification system by only having to declare the name of the notification once. It also adds some information about the contents of the notification by providing an associated type for the sender property.

To reduce the chances of a notification name collision, I’ve made the TypedNotification protocol conform to a Namespaced protocol which looks like:

protocol Namespaced {
 static var namespace: String { get }
}

A protocol extension on TypedNotifcation uses the Namespaced protocol to provide a default implementation for the name property:

extension TypedNotification {
 static var name: String {
 return "\(Self.namespace).\(Self.self)"
 }
}

This will generate a notification name using the namespace property and the name of the type conforming to TypedNotifcation.

Usage

For each notification that your application posts, create a type that conforms to TypedNotification and implement the required properties. Thanks to the aforementioned protocol extension, only the sender and namespace properties need to be implemented. You can write a protocol extension on Namespaced to reduce the implementation down to just the sender property. As an example:

extension Namespaced {
 static var namespace: String { return "org.alexj" }
}

struct ExampleNotification: TypedNotification {
 let sender: ExampleClass
 let newValue: Double
}

Here, ExampleClass is the only class that’s responsible for sending instances of ExampleNotification. If multiple types can post a notification, consider constraining the sender property using a protocol. If worst comes to worst, you can make sender an instance of Any? at the expense of some type safety.

The TypedNotificationCenter Protocol

Overview

To post instances of TypedNotifcation, the library provides another protocol called TypedNotificationCenter. This declares three methods to post notifications, add observers and remove observers:

protocol TypedNotificationCenter {
 /// Post a `TypedNotification`
 func post<T: TypedNotification>(_ notification: T)
 /// Register a block to be executed when a `TypedNotification` is posted.
 func addObserver<T: TypedNotification>(forType type: T.Type, object obj: T.Sender?,
 queue: OperationQueue?, using block: @escaping (T) -> Void) -> NotificationObserver
 /// Deregister a `NotificationObserver`.
 func removeObserver(observer: NotificationObserver)
}

Aside from a different type signature, these methods mirror the Foundation NotificationCenter APIs. TypedNotification includes an extension on NotificationCenter that adds conformance to the TypedNotificationCenter protocol. You can use the protocol when writing tests.

The NotifcationObserver Class

The addObserver method returns an instance of NotificationObserver rather than the NSObjectProtocol conforming object returned by the Foundation API. NotificationObserver is a lightweight class that stores an NSObjectProtocol conforming object. When a NotificationObserver is deallocated, removeObserver is automatically called. There’s no need to manually remove observers any more, just store² a strong reference to the NotificationObserver.

Usage

Usage is almost identical to using the Foundation API. Building on the previous example, here’s how to use a TypedNotification conforming type with NotificationCenter:

class ExampleClass {
 private let center = NotificationCenter.default
 private var _valueObserver: NotificationObserver? = nil

 init() {
 _valueObserver = center.addObserver(forType: ExampleNotification.self, object: self, queue: nil) { (noti) in
 print("New value: \(noti.newValue)")
 }
 }

 var value = 0.0 {
 didSet {
 center.post(ExampleNotification(sender: self, newValue: value))
 }
 }
}

Note that the closure parameter noti is of type ExampleNotification so you can directly access the newValue property without any downcasting. Also note that the observer is tied to the lifetime of ExampleClass. When an instance of ExampleClass is deallocated, _valueObserver will remove itself as an observer.

Conclusions

I think the advantages of this library compared to the Foundation API are clear. Representing notifications as types improves the safety of your code by eliminating manually managed string identifiers and weakly typed userInfo dictionaries. A further advantage of typed notifications is self-documentation. As data attached to a notification is part of the type, there’s no need to document the keys of a userInfo dictionary. Users can look at the public interface of a TypedNotification conforming type to see what data it provides.

The TypedNotificationCenter protocol goes hand in hand with the TypedNotification protocol. It improves run time safety by automatically removing observers when they are deallocated, eliminating an entire class of bugs. Furthermore, it provides a starting point for writing tests for notifications.

The TypedNotification library is available from GitHub under an MIT license. It is compatible with the Swift Package Manager and Carthage.

I believe the cool kids call this a µFramework. ↩︎
Xcode will emit a warning if you don’t store the returned NotificationObserver. It might be a good idea to enable “Treat Warnings as Errors” in your build settings. ↩︎

Fixing MATLAB on Fedora

Fri, 10 Mar 2017 15:00:00 +0000

The other week I had to set up a new installation of MATLAB r2016a on a (somewhat) fresh Fedora installation. After running the installer, I ran into a bunch of library errors when trying to run external C++ programs¹ from MATLAB or when trying to plot something. When running an external C++ program, MATLAB would complain about missing versions of CXXABI and GLIBCXX in libstdc++². When plotting something, MATLAB would complain about libmwosgserver.so.

The first problem is caused by MATLAB trying to use its own, older version of libstdc++. The second problem is caused by MATLAB trying to use the system’s version of libmwosgserver. To fix the error when running C++ programs, I had to tell MATLAB to use the system’s version of libstdc++. To fix the error when plotting, I had to tell MATLAB to use its own OpenGL libraries rather than the system’s.

The fixes are easy to make, you need to edit a couple of lines in a startup script. First of all, find out where the system’s version of libstdc++ is located ($ indicates text to enter in a shell):

$ find /usr -name 'libstdc++.so.6' -exec dirname '{}' \;
/usr/local/MATLAB/R2016a/sys/os/glnxa64
/usr/lib64
/usr/lib

The first line is MATLAB’s version of the library, the second the system’s 64-bit version of the library, the third the system’s 32-bit version. If you’re somehow still on a 32-bit system you’ll need to note down the path /usr/lib. Otherwise, the path you need is /usr/lib64. Now you need to edit MATLAB’s init script. The exact location will depend on where you installed MATLAB to. Assuming you installed MATLAB into the /usr/local directory then you’ll need to edit /usr/local/MATLAB/R2016a/bin/.matlab7rc.sh.

This script is essentially a massive switch statement that sets different environment variables depending on which operating system and architecture you’re on. Find the case statement corresponding to your architecture (glnxa64 for 64-bit Linux) which will look something like this:

case "$ARCH" in
 glnx86|glnxa64)

For me that was around line 164 but it will probably depend on which version of MATLAB you’re running. Inside this case, find the line that says

LDPATH_PREFIX=""

and change it to

LDPATH_PREFIX="$MATLAB/sys/opengl/lib/$ARCH:/usr/lib64"

This pushes MATLAB’s OpenGL libraries and the system’s C++ libraries to the front of MATLAB’s load path, forcing it to use those versions of the libraries. Save the file, restart MATLAB and you should be good to go.

Since I use fish as my shell, that meant any external command. ↩︎
Really it was the external program complaining, not MATLAB. ↩︎

Integrating Receipts with ledger-mode

Sat, 02 Jul 2016 16:00:00 +0000

I’ve written a couple of functions for Emacs’ ledger-mode that make working with receipts a bit easier. With the cursor on a transaction, calling alex/ledger-attach-receipt will prompt for a file. This function copies the file to a receipts directory, renaming it to its hash and sorting it in subdirectories according to the transaction’s year and month¹. Finally, the function adds a comment to the transaction with the hash of the file. The function alex/ledger-open-attached-receipt reads this comment and opens the associated file in Emacs. The receipts folder can be customised through the variable alex/ledger-receipt-folder.

(defvar alex/ledger-receipt-folder "~/finance/receipts")
(defun alex/ledger-get-xact-date ()
"Read the effective date (before =) of a
transaction. Returns the date as a time value."
(save-excursion
 (ledger-navigate-beginning-of-xact)
 (re-search-forward ledger-iso-date-regexp)
 (encode-time 0 0 0 (string-to-number (match-string 4))
 (string-to-number (match-string 3))
 (string-to-number (match-string 2)))))

(defun alex/ledger-construct-receipt-path (date hash &optional ext)
"Construct a path to a receipt file. DATE is a time value. HASH is a
string. EXT is the file extension (with dot) and defaults to .pdf"
(unless ext (setq ext ".pdf"))
(concat (file-name-as-directory alex/ledger-receipt-folder)
 (file-name-as-directory (format-time-string "%Y" date))
 (file-name-as-directory (format-time-string "%m" date))
 hash
 ext))

(defun alex/ledger-attach-receipt ()
"Prompt for a receipt file, calculate its hash and move the file to
alex/ledger-receipt-folder, renaming it to its hash. Inserts the new file name
as a comment to the transaction."
(interactive)
(let* ((fname (read-file-name "Receipt File Name:"))
 (fhash (with-temp-buffer
 (insert-file-contents fname)
 (secure-hash 'sha1 (current-buffer))))
 (xdate (alex/ledger-get-xact-date))
 (newpath (alex/ledger-construct-receipt-path xdate fhash (file-name-extension fname t))))
 (mkdir (file-name-directory newpath) t)
 (copy-file fname newpath)
 (save-excursion
 (ledger-navigate-beginning-of-xact)
 (end-of-line)
 (insert "\n; Receipt: " fhash (file-name-extension fname t))
 (indent-line-to ledger-post-account-alignment-column))))

(defun alex/ledger-open-attached-receipt ()
"Open the receipt file specified by the Receipt tag in a new buffer."
(interactive)
(save-excursion
 (ledger-navigate-beginning-of-xact)
 (let* ((xact-date (alex/ledger-get-xact-date))
 (xact-end (save-excursion (ledger-navigate-end-of-xact)))
 (receipt-pos (re-search-forward "; Receipt: \\(.*\\)" xact-end t nil))
 (receipt-hash-fname (match-string 1)))
 (when (not receipt-pos) (error "No receipt found for current transaction"))
 (find-file (alex/ledger-construct-receipt-path xact-date
 (file-name-base receipt-hash-fname)
 (file-name-extension receipt-hash-fname t))))))

With evil-leader, I’ve bound the attach and open functions to SPC-i and SPC-I respectively. Combined with git, I’ve found these functions work nicely for sorting scans of receipts.

With the default receipt folder, files get copied to ~/finance/receipts/$YEAR/$MONTH. ↩︎

Using Ledger With an Encrypted Journal

Thu, 15 Oct 2015 17:00:00 -0600

I’m a pretty big fan of Ledger, a command line accounting system based on the double entry bookkeeping system. One of its strengths lies in the fact that the journal file that contains your transactions is a plain text file. This makes it super easy to sync the journal using your favourite file syncing service. Of course, before putting the journal file on a remote server, you’ll probably want to encrypt it. Ledger program doesn’t support encrypted journal files but, using GPG and a shell alias, you can get the vast majority of Ledger’s functionality to work with an encrypted journal.

To read the encrypted journal, I use a simple shell alias to pipe the output of gpg into ledger, telling it to read from stdin. For the fish shell, the alias I use is:

alias eledger "gpg --batch -d -q $LEDGER_FILE | ledger -f - "

Adjust this for your shell of choice. Here I’ve assumed you’ve defined the $LEDGER_FILE env variable, which Ledger uses by default. I’m also running gpg in batch mode, which suppresses most of its output. Remove the --batch flag if you’d rather see this output (it won’t get piped into Ledger).

Use this alias like you’d use the ledger command. Any commands or arguments get added to the end of the alias and passed on to ledger. The majority of Ledger’s commands will work using this method. Only commands that rely on the journal’s path will fail.

Editing

If you edit your Ledger journal in Emacs then good news, Emacs will decrypt the journal file automatically and encrypt it when you save. Unfortunately, if you use ledger-mode, not all of the built in commands will function correctly. In particular, reports won’t work since these are generated by running the ledger command. This is probably easy to fix but I haven’t tried yet.

Spotijack 0.6 Released

Fri, 24 Jul 2015 23:00:00 +0000

After sitting on the project for a few months, I’ve just released the next version of Spotijack on GitHub, as well as the application’s source code. This is the first public version of Spotijack because I’ve spent a while contemplating whether the project is OK to release.

Spotijack is a utility for the Mac that automates the process of recording music playing in Spotify with Audio Hijack Pro. Whenever the song changes in Spotify, Spotijack tells Audio Hijack Pro to split the recording and update the new recording’s metadata. Obviously the program enables piracy which I do not support, and this is why I’ve sat on it for so long.

I wrote the first version of Spotijack back in December of 2011. At this point it was a simple AppleScript with no user interface and a lot of bugs. After that I didn’t touch the project for another two years, largely because I didn’t use it. In 2013, looking for a new side project, I started working on Spotijack again. I ported the application to Cocoa-AppleScript (a horrible experience) and gave it a proper user interface. In 2014, I then rewrote the application in Objective-C using the ScriptingBridge framework (a mostly non-horrible experience). Ditching AppleScript made the project much more fun to work on. As a result, I started adding new features and fixing bugs just for fun. I started to treat it like a proper project and wanted to make the code public.

I’m aware that the application’s only real use is for music piracy but, it’s a fairly inefficient way of pirating music. I don’t think anybody will actually use Spotijack because there are far more efficient ways to get music. So, I don’t think I’m doing much harm by releasing Spotijack and treating it as a little side project.

Always Switch Sockets off Before Plugging in

Tue, 20 Jan 2015 09:00:00 +0000

Oh, and make sure your stuff is on a surge protector.

Normally I’m a stickler when it comes to electrical safety, probably because my Granddad was an electrician and taught me about it. The other night though, in a lapse of consciousness, I plugged my laptop’s charger into a power strip that was still switched on at the mains. Or, should I say, started to plug in the charger because as the plug went in, the air between it and the power strip ignited in a decent explosion.

The boom was loud enough to leave a ringing in my ears and it sent out a perceptible air wave from the socket too. Fortunately the power strip doubled as a surge protector and it did its job in protecting the desktop computer and monitor that were also plugged in at the time. The damage to the laptop charger’s plug was pretty interesting though. Aside from being charred, the neutral pin has deformed slightly as has the live pin, although to a lesser extent. The ground pin looks perfectly fine.

Amazingly, the laptop’s power brick still works but I haven’t tested—and don’t want to test—the actual plug. Thanks to the surge protector, the only costs were for a new fuse and a new power cable but I’d hate to think what would’ve happened without the surge protector. Lesson learnt though, always switch sockets off before plugging in.

julius 0.2.0 Released

Tue, 09 Sep 2014 14:02:51 +0100

Besides the project page, I haven’t written about julius on this blog before so here’s a quick overview. julius is a stupidly simple command line tool for encrypting and decrypting text using the Caesar Cipher. It’s designed to play nicely with Unix redirections so you can use it to easily encrypt/decrypt the output of commands.

Everyone knows that the Caesar cipher is unbelievably weak which is why nobody in their right mind uses it for anything serious. Version 0.2.0 of julius highlights this weakness by adding the brute subcommand. Using this command, julius will try every possible key for an encrypted message and output the plaintext. Because there’s only 25 possible keys, this takes next to no time to run even on very modest hardware.

As an example, here’s some benchmarks performed on a Raspberry Pi Model B+ running ArchLinux:

Text to Brute-force	Text Size (Bytes)	Time Taken (ms)
“Hello, world!”	14	4.18
julius sourcecode	6007	56.42
Alice in Wonderland	167518	1080.00

On more powerful hardware (like, say, a MacBook Air), it takes julius no time at all to brute force a message.

You can download 0.2.0 today from the GitHub releases page. There’s builds available for 64 bit versions of OS X, Linux and Windows as well as an ARM build for Linux.

New Design, New Tools, New Everything

Mon, 01 Sep 2014 21:43:00 +0100

I’ve spent the past week working on a new design for this site which should be live right now. The site wasn’t in desperate need for a redesign to begin with but I wanted to try out some new tools and figured a redesign was the best way to do it.

The new design is “inspired” by Google’s Material Design UI. I’ve sprinkled plenty of shadows and animations throughout the site to give it a sense of depth and fluidity. If you get chance, check out one of the projects with screenshots. The screenshot gallery is built with vanilla JavaScript and all the animations are done with CSS 2D transforms so they run at 60FPS even on low end devices.

Hugo

While the new design is interesting and all, the really interesting things with this redesign are the new tools being used. First up, the site is no longer built with Jekyll instead using Hugo. Hugo is a relatively new static site generator that is written in Go—one of my favourite programming languages. The biggest advantage Hugo has over Jekyll is its speed. It’s crazy fast compared to Jekyll and I love this. The site builds nearly instantly which is great for development when combined with LiveReload, which, may I add, comes built into Hugo.

Hugo also offers a more flexible way of organising content than Jekyll. Jekyll pretty much assumes you’re working with content for a blog while Hugo assumes that the way you lay out your source content is how you want your site to be. This is awesome and really makes me want to move Geography AS Notes over to Hugo so I can stop doing some weird organisation techniques with the content.

Unfortunately, Hugo is still young and is missing a few features that Jekyll has. This hasn’t been much of a problem with this site but it is stopping me from moving Geography AS Notes over to it. One very simple feature that is missing is the ability to get the next/previous piece of content of a certain type. Hugo currently provides the {{ .Next }} and {{ .Prev }} template variables for the next/previous piece of content but they ignore the type of the content (for example mixing blog posts with project pages) and there’s no way to specify the sorting that determines what the next/previous content is.

Other issues I ran into include a lack of plugin support (Hugo has “shortcodes” which are similar to Jekyll’s custom liquid filters but can’t run external commands), a lack of an asset pipeline and a pretty bare bones {{ .Summary }} variable for generating post summaries. The generated summaries are processed by Markdown but the resulting HTML is stripped leaving a blob of plaintext.

Despite these shortcomings, I still love Hugo. It’s fast, it’s stable and it has, in my opinion, a superior way of organising content. I’ve been watching the project on GitHub for the past couple of weeks and it’s very active so I have a lot of hope for the future of this project. I’ll definitely be using Hugo for new projects going forwards.

Gulp.js

Another new tool I got to play around with was gulp.js. Gulp is a task runner written in JavaScript that proved to be super useful in working around Hugo’s lack of an asset pipeline. Initially I didn’t want to use Gulp and instead wanted to use Make as a task runner, my main reason being the Node.js dependency. Ten minutes of trying to figure out Make’s syntax though and I gave Gulp a go.

I’m pretty happy with the result. Despite being (almost) illiterate when it comes to JavaScipt¹, writing tasks in a Gulpfile wasn’t too hard. The biggest challenge was wrapping my head around the concurrency system Gulp uses. By default tasks are run concurrently so it’s important to specify task dependencies to make sure things run in the right order. After rewriting my Gulpfile a few times the concurrency issues were fixed and things seemed to just work.

Gulp and Hugo seem to work quite well together. Using Gulp I can recompile CoffeeScript and Sass files when they change. This, in turn, makes Hugo regenerate the site (did I mention it does this quickly?) and then the site automatically reloads in the browser. Brilliant.

Autoprefixer

Autoprefixer is a useful little Node.js utility that automatically adds vendor prefixes to experimental CSS properties. It works nicely with gulp.js and helped make my Sass files cleaner. It also made development a little faster since I didn’t have to spend time looking up which properties require vendor prefixes and which don’t. Autoprefixer makes life easier, there’s not much else to say about it.

Open Source

Because this site is built using Hugo and because Hugo is still quite a young project, I’ve decided to put the source for the site up on GitHub. Previously I kept it in a private repository but I think it’s for the greater good to make the source publicly available as a potential learning resource for people new to Hugo. Just a small point, the repository was private in the past and I may have been a bit neglectful when it came to commit messages. Don’t judge.

I can read and write JavaScript it’s just I don’t do it often enough to remember the syntax and when I do write it, I prefer to use CoffeeScript. ↩︎

Restoring the Network Manager Applet After Upgrading to Lubuntu 14.04

Sat, 19 Apr 2014 22:30:00 +0000

It seems there’s a bug when upgrading Lubuntu to version 14.04 that causes the network manager applet to disappear from the system tray. I’ve experienced the problem on two separate installations so I’m going to guess this is a widespread problem.

The fix is easy. Just open a terminal session and run this command:

echo "nm-applet" >> ~/.config/lxsession/Lubuntu/autostart

All the command does is add nm-applet to your LXDE autostart file. If you logout and log back in, the network manager applet should be running.

Some .sexy New TLDs

Wed, 12 Mar 2014 21:45:00 +0000

Today I became the proud owner of alexj.sexy following in the footsteps of people like Myke Hurley of myke.sexy. This is possibly the best $25 I’ve ever spent.

Joking aside, I couldn’t help but notice how stupid some of the new TLDs are. A sliver do allow for some creative and memorable domains but for the most part they’re pretty useless. Take, for example, the .guru TLD. How many times in the past year have you referred to someone as a guru? I’d guess it’s a pretty small number.

I’m probably getting cranky over nothing here. Nowadays people don’t access a website via its domain name anyway so the new TLDs will likely be of little importance. Still, I find it funny to think that a board of people at ICANN looked at TLDs like .sexy or .cool and thought they were good.

Nginx—Surprisingly Easy

Mon, 03 Feb 2014 00:15:00 +0000

Out of curiosity I spent my Sunday afternoon moving this blog from Amazon S3 to a DigitalOcean VPS (spoiler, that’s a referral link). I didn’t have a solid reason to do this—it’s both more expensive and more effort—aside from to learn. I’ve never set up a web server from scratch before let alone owned a VPS. I kind of felt I needed one so I could earn some geek cred.

I’m running Ubuntu 12.04 LTS on the VPS since Ubuntu’s the Linux distribution I have the most experience with¹. Nginx is acting as the web server and seems to be fast. It’s not like I have anything to compare it with though. The VPS is DigitalOcean’s cheapest droplet—512 MB of RAM and a 20 GB SSD.

Given my lack of experience with web servers, I was expecting Nginx to be a pain to set up. Surprisingly, it wasn’t. Within 30 minutes I had a test page up and within an hour I was serving a mirror of this site from a subdomain of this site. Granted, this is a purely static site, so I didn’t have to set up the full LEMP stack.

I won’t go into detail about how I set up the VPS but I’ll share a few resources I found. DigitalOcean’s support website has some good documentation on setting up a Linux VPS. There’s also a tutorial on setting up a LEMP stack but I’m not a fan of it. The tutorial uses the outdated nginx package provided in the Ubuntu repositories. It needs updating with info on getting the latest version of Nginx.

A very useful resource I found for learning about Nginx was Martin Fjordvald’s blog. He’s written several useful and interesting articles especially “Nginx Configuration Primer”. He’s also written a short book that goes into a bit more detail. It’s a quick read and definitely worth the ~£6.00 if you’re new to Nginx.

Advantages

More than anything this was a learning exercise but there were a few benefits.

The biggest advantage is native support for root domain names. AWS doesn’t support them unless you use their Route 53 service. As a result, I had to use a 3^rd party service to redirect the root domain to the www cname record. This added an extra 200–300 ms to the DNS look up if somebody used the naked domain. It was a noticeable difference in performance. Now, the homepage loads in ~300 ms regardless of which domain you use.

Another advantage is the extra control I get. With S3, supporting features like gzip compression was an all or nothing choice. If a browser didn’t support gzip—an admittedly rare occurrence—it’d receive nothing but garbled data. With Nginx though I can enable the gzip_static directive and support these browsers.

Going forwards I’m probably going to serve Geography AS Notes from the same DigitalOcean droplet since GitHub pages offers even less control than Amazon S3. I don’t see any reason why I can’t serve it from the same droplet since this website is such a low volume site, it will have a negligible performance impact. If need be I can get a better DigitalOcean droplet but since Geography AS Notes is strictly not for profit and advertisement free I’d have to find some way to subsidise the cost.

I’ve been running and maintaining Ubuntu on my Grandmother’s computer since 8.04. She uses my old MacBook now but had no problems with Ubuntu when she used it. ↩︎

Redesigning Geography AS Notes

Wed, 08 Jan 2014 21:45:00 +0000

Just under a month ago, I wrote about which projects I’d be focusing my time on in the coming year. The main takeaway from the post was that Geography AS Notes was going to get some love. Well, here’s my first packet of love¹, a redesign.

It’s been nearly two years since I last refreshed Geography AS Notes’ design and in that time its grown boring and stale. The website’s design has never been eye catching—one frequent piece of feedback I get is that the site is boring to look at—but for the past two years I’ve taken the function over form approach. This needed to change.

If a site is boring to look at, the reader is more likely to perceive the content as boring which isn’t good if you want them to study using it. Furthermore, I’ve realised that Helvetica (or Arial on Windows) ins’t a good body font and my choice of font was hurting the legibility of the site, a problem that grew worse with the length of articles.

For the redesign, I wanted to make something that not only looked half decent but was comfortable to read on a multitude of devices. In addition, I wanted to simplify the site’s markup and make use of the new HTML5 semantic elements to improve accessibility, something which is very important when you’re dealing with people’s education. Finally, I wanted to make it easier for people to find content on the site by implementing site search. These were the four main objectives when redesigning the website.

The first objective I worked on was improving the HTML semantics. This didn’t take too long and drastically simplified the site’s markup. I found a fantastic new method for writing CSS sticky footers. By using it I was able to eliminate lots of un-semantic wrapper styles and layout my pages with just the <header>, <article> and <footer> elements. The new CSS sticky footer doesn’t work in IE <= 7 but nobody uses that anymore.

Speaking of IE, I raised my minimum target from IE 7 to 8². I was surprised by how painless it was developing for IE 8. All I needed to do was drop in html5shiv.js and there were no further problems. I’ve actually had more problems with IE 9/10/11 and their funky way of resizing <img> elements with SVG content (which I still haven’t fixed).

With the site’s structure modernised, I started working on how the site looks. I opted for a dark colour scheme with splashes of orange. I think it looks good and it’s much better than the old design. Article headers receive more emphasis than they used to while the site’s header is less dominant to focus on the content. The new design is more fluid than the old one, relying less on media queries and making extensive use of % dimensions. This kept the SCSS clean.

I made some significant changes to the homepage. Previously, the homepage used a set of expanding divs that contained the site’s content. It looked sort of cool but didn’t work well on small screens and content was often truncated since I couldn’t use height:auto on the divs and have CSS3 transitions work. In the new design, a (pseudo) segmented control is used to control the visible topic. This works better on mobiles and doesn’t have any problems with truncated content as I’m only toggling the div’s (well, <section> now) visibility and display properties.

The next objective to strike off was legibility. I played around with a few font combinations from Google Fonts and ended up combining Arvo and Raleway. Arvo—a slab-serif font—is used for the site’s body while Raleway—a sans-serif font—is used for headers. I like the combination, they look nice together and, most importantly, they’re highly readable.

The final objective was search. Most people arrive at Geography AS Notes using Google but once they’re on the site, there’s no further search functionality. Since the site’s Jekyll powered, implementing search has a few challenges. Mainly, it needs to be handled client-side. I toyed with writing a search engine back in January last year. It worked—surprisingly efficiently may I add—but it needed a lot of work and I never got around to finishing it.

I tried again to implement client-side site search, this time using lunr.js so I didn’t have to handle the actual searching. Lunr.js is simple to set up but, in my limited testing, it proved too slow at indexing full text content for every page. It was unreasonable of me to expect it to handle such a large index but it was worth a shot.

Ultimately, I offloaded site search to a third party service. I tried Tapir but the service seems to have shut down³. I ended up using DuckDuckGo which offers some limited customisation of the search results. It’s a compromise though—I’d much rather have results on my website.

The final design ended up looking like this:

For reference, the old design:

I made a few smaller changes while working on the redesign. All the topics now have their own page which can be linked to. In addition, I’ve made it more obvious that people can edit existing articles and create new ones. All articles have an edit link in their footer and I’ve written about other ways people can contribute.

This redesign is just the first in what I hope is a string of updates to Geography AS Notes that will be coming throughout the year. If you have any suggestions for the website, let me know via the GitHub repository.

It’s quantum love, coming in discrete packets. ↩︎
I’d like to raise it higher than this but a lot of schools—where the website’s most commonly accessed from—still use IE 8. ↩︎
I never received an email with my private API key and received no response from the API with the public key when I tried to use it. ↩︎

Project Updates

Wed, 11 Dec 2013 01:22:00 +0000

This is a boring updated on the status of several of my projects. If you don’t care about them then just give this post a miss. There’ll be a new post in a couple of months which may be more interesting.

My situation’s changed a lot in the past couple of months. I’m now at university, living away from my parents, studying what I want to study with some great people. It’s pretty awesome. It’s also a lot of work which is why I’m changing what projects I’m focusing on in my spare time.

SimpleCode

SimpleCode is dead. The website’s been inactive for some time now¹ and, on December 4^th 2013, I let the domain name expire. I’ve been waiting to kill this project and I’m glad that it’s finally gone. Looking back on the programming tutorials I wrote when I was a less experienced programmer I feel sorry for anybody who tried to learn from them. There’s so much incorrect or poorly explained information, it’s horrible. I feel only a small bit of sadness killing this projects as it was the first website that I actively maintained and the first domain name I ever owned.

SymSteam

SymSteam is on an indefinite hiatus. I love SymSteam. It was the first Mac application I worked on where I actually understood most of what I was doing. I didn’t need to refer to Stack Overflow² every other line of code and I was actively trying to follow best practices rather than doing my own thing. It was also my first useful application. SimpleCalc was useless, there are thousands of calculators far more powerful than it but SymSteam, as far as I can tell, is unique.

Work on beta 3 of SymSteam started in April 2013 and the most recent commit was in the tail end of June. Since then, the project’s stalled. Ever since building a dedicated computer for gaming, I’ve failed to find the motivation to work on SymSteam and it’s for this reason that I’m officially putting it on hold. I’m not calling the project dead because one day I may find the motivation to start working on it again but for now, it just isn’t there.

Appcastr

It’s dead. Appcastr’s a funny project. I enjoyed making it despite the constant headaches autolayout gave me but for some reason, I completely lost interest in it. It’s annoying because I still have ideas for features to add but I don’t want to set aside the time to work on them when there’s other things I can be doing.

The project page for Appcastr has, for almost a year, said that it’s not dead and that version 0.2 will be released some day. That’s not happening. If you want to try out version 0.2, compile it from the 0.2 branch in the git repository. Otherwise, you can download a ‘stable’ and usable build of version 0.1.1.

Geography AS Notes

It’s alive!. Work on Geography AS Notes has been all over the place this year. At the start of the year, I rewrote the rivers topic over the space of three months, replacing the old content that was essentially notes with researched prose³. After the rewrite though, I haven’t done much but manage the technical side of the website. In the coming months, I’m going to start focusing on the website’s content again.

Currently, I’m converting diagrams to the SVG format so that they look good at all resolutions. I’m also adding more information to several of the diagrams to make them more useful. After this, there will be some significant content updates to the coasts and population change topics. The latter topic is in desperate need of a rewrite so I’ll try to prioritise this. After that, I will look into adding some new content. I’d like to write something about volcanoes & plate tectonics so I think that’ll probably be what’s coming next.

A Prototype

Although my main focus for the coming months is going to be my degree and Geography AS Notes, I recently started prototyping an application that I may or may not develop further. I don’t want to reveal too much about it as it’s something that I’m considering making for profit but let’s just say it’d be my first proper attempt at iOS & graphics programming⁴ and it’d be related to my degree…

I’ve had a 4,000 word draft for a post sitting uncommitted in the git repository for nearly 18 months. ↩︎
OK, I did ask one question on SO when I couldn’t figure out why SymSteam was crashing when started on login but I ended up solving that my self any way. ↩︎
The feedback on the rewrite’s been great by the way. Thanks to everyone who’s emailed me with comments and suggestions. It’s really nice. ↩︎
It isn’t a game. ↩︎

Review - Tomb Raider

Sat, 10 Aug 2013 23:00:00 +0000

The newest entry in the Tomb Raider franchise is a much needed reboot of an ageing series. Published by Square Enix & developed by Crystal Dynamics, the game is a major improvement over past titles in the series with the developers focusing a significant amount of their resources on creating an engaging and enjoyable solo experience.

The story of the new Tomb Raider is the real meat of the game. It focuses on the early days of Lara Croft as she is thrown between a rock and a hard place and starts to develop her survival skills. Lara, an archaeologist, and her colleagues/friends are investigating the ancient Yamani Kingdom when their ship is shipwrecked on an island that happens to be Yamani. They pretty quickly find out they’re not alone and that there are other survivors on the island who aren’t very friendly and kidnap them. Lara escapes and begins trying to rescue her friends while doing some archaeology on the side like any good scholar.

The story is told through a series of cutscenes as well as several of Lara’s self narrated diary entries. The cutscenes are interesting to watch and the diary entries are equally interesting to listen to. The voice acting in both is well done with some convincing performances. Overall the story is well told, entertaining and captivating. The development of the characters, more specifically Lara, is very good. By choosing to have parts of the story re-told through Lara’s diary entries, it really helps hammer home just how much she is changing as a result of the events and by the end of the game, you’ll see a very big difference between the Lara you started with and the Lara you ended with. The other characters don’t get as much attention as Lara does but their relationship with Lara is well portrayed and there is a strong sense of emotional attachment between her and some of the characters such as Roth.

Tomb Raider’s gameplay is by no means poor or boring but compared to the fantastic story it feels a little second rate. It relies a little too much on quicktime events & button mashing. After the first two hours of gameplay I’d already been through nearly a dozen quicktime or button mashing sequences and there were many places in the game where said sequences felt unnecessary. At the same time, there were some places where the sequences did actually work well.

There are essentially two components to Tomb Raider’s gameplay, platforming and shooting. There is arguably a third in the form of stealth but that really takes a back seat as while there appears to be the option to stealthily take out entire groups of enemies I think that this is just an illusion as when I tried this I often found myself in the midst of a firefight just moments later. Maybe I was just doing it wrong.

The platforming sections work well. The controls are tight and it’s always fairly obvious where you need to go thanks to Lara’s “Survival Instincts”. The threat of dying in the platforming sections is next to non existent thanks to some very lenient platforming targets. When I did die it was generally because I hit the wrong key and made Lara go the wrong way not because a certain jump was too hard to make.

The shooting sections tend to be duck and cover affairs. You’ll spend most of your time crouching behind a crate, popping out every now and then to shoot some enemies. Sometimes the shooting sections can feel a bit boring as you face wave after wave of enemy, especially later on in the game when the enemies start throwing grenades that force you to keep moving from cover to cover, often not giving you chance to actually return fire. At other points though the combat can be fun and exciting. The level where Lara obtains a grenade launcher is particularly memorable for me. The cover system in Tomb Raider works well enough. Lara automatically takes cover behind objects as you approach them assuming there are enemies nearby. I would have preferred a dedicated button to make her stick to cover but there’s nothing up with the cover system that has been implemented.

Shooting sections are occasionally spiced up with the introduction of boss fights. These tend to be heavy gunners dressed in body armour or with shields. They put up a bit more of a fight than the regular enemies but you tend to face them one-on-one which sort of eliminates the threat of them since you can easily dodge their attacks and attack their weak points. Doing so then leads to a joyous quicktime event. Failing said event causes the enemy to get back up but in the time it takes for them to get back up, you can probably hit them in their weak spot again causing them to go back down. It’s a bit of a cheap tactic but hey, it works.

The weapons in the game are OK. You get a bow & arrow which, if used correctly, is possibly the most powerful and certainly the most versatile weapon in the game. You also get a pistol, rifle & shotgun which get upgraded to more advanced models as you progress through the story. You’ll probably find yourself using your pistol the most often since ammo is so plentiful for it and it tends to kill enemies in one or two shots. Throughout the game there are weapon modifications to collect and also a sort of in game currency called salvage which allows you to purchase said modifications. The modifications improve the base stats of your weapons and a few add some cool new functions to them like firing incendiary rounds from your shotgun.

You also gain experience as you kill enemies in the game which allows you to buy perks. The experience rewarded is based on how badass the kill is. Body shots earn the least, followed by headshots and then executions. Executions can only be performed by purchasing the required perk though. Aside from adding executions, perks also make various improvements to Lara such as reducing fall damage or making her more efficient at looting enemies. The perks are all helpful but there isn’t much need to ration your experience points. You earn a significant quantity of experience every time you finish a story mission so you’ll never really run short and be unable to afford a perk.

There are many collectibles to be found in this game too ranging from artefacts which have their own L.A. Noir like inspection mode to diary entries from other characters which help flesh out their backstory a little bit. It is actually sort of worth trying to find these collectibles since they add a bit to the story but the placement of them is often illogical. It would seem, for example, that characters that are kidnapped right in front of you and you chase after take the time to leave their diary entries as they are kidnapped.

In addition to hidden items to find there are also hidden tombs to find. Known as Challenge Tombs, these sections are one of my favourite parts of the game aside from the story. Challenge Tombs lack enemies, offering some slightly more relaxing gameplay. Instead, they have one large central puzzle which you must solve in order to access a reward (generally a weapon modification). Some of the puzzles require a few minutes of thought but solving them is fairly satisfying, generally employing a bit of platforming, timing and interacting with the environment. The puzzles are made a bit easier by the use of Lara’s “Survival Instincts” which highlight points of interest in the environment. While it’s helpful, “Survival Instincts” sort of spoils the challenge of the Challenge Tombs. To get maximum enjoyment out of the challenge tombs, try and ration your usage of the “Survival Instincts”.

The graphical design of the game is truly fantastic. The game looks beautiful with the character models being very detailed and believable. Environments are rich and detailed with some great vistas at various points in the game. The graphics aren’t just eye candy though, they do a great job of adding to the atmosphere of the game and making the world as a whole more immersive. Another aspect of the game’s design which is fantastic is the sound. As I’ve already said, the voice acting in this game is terrific and that’s not just for the cutscenes. Enemies in the game have their own conversations which are fun to listen to before killing them. It’s really cool to hear how enemies go from questioning how some girl can be running circles around them to genuinely fearing her. Then, when things start to go their way again, they fear her less.

Not only is the voice acting great but the ambient sound is brilliant too. The sound of Lara climbing up a craggy cliff face is incredibly satisfying as is the sound an arrow makes as it lodges itself in an enemy’s skull. All the individual grunts and breaths Lara takes sound brilliant and add to the immersion of the game.

As far as reboots go, Tomb Raider is a shining example of how to do one properly. Thanks to some TLC by the developers, Tomb Raider is a fantastic game with an engaging and worthwhile story mixed in with some beautiful set pieces. Yes the gameplay isn’t the most original or exciting thing out there but it’s easy to forget when the story is this good. I only wish that the developers had laid off the quicktime events and button mashing because it really did make some sections of the game tedious to play. Still, even though these sequences exist throughout the game, they make up a relatively small amount of the actual game and won’t detriment from your overall enjoyment of the game. Definitely play this game.

A Side Note - The Multiplayer

It’s obvious that Tomb Raider is a game focused on a solo experience but, for better or for worse, the publisher decided that a multiplayer component was also necessary. The multiplayer section of the game was developed by a separate studio and, while it isn’t terrible, it’s easily forgettable. The multiplayer includes a standard PvP deathmatch mode as well as a scavenger mode where one team must collect supplies while the other tries to stop them and an escort style mode where one team must transport supplies to a specific point on the map.

The multiplayer might occupy you for two or three hours at best but seriously, go into this game expecting a great single player experience, not a multiplayer one.

SymSteam Beta 2.1 Released

Sun, 31 Mar 2013 12:32:00 +0000

This is a very small update for SymSteam that fixes two bugs you probably didn’t even know existed. The first, a simple spelling mistake in an error message. The second, a cock-up with pointers that meant that if an error occurred while deleting an old symbolic link an empty error message would be displayed. Not particularly helpful.

Code wise, SymSteam should be easier to translate into other languages because I’ve changed all the user interface strings so that they’re created using NSLocalizedString() and are stored in a strings file. If anyone wants to go ahead and translate SymSteam into another language please do.

You should be prompted to install the update if you already have SymSteam installed. If not, you can view the changelog and download it from SymSteam’s project page. As always, you can find the source code for SymSteam on GitHub.

S3 Deployment Script Mk 2

Sun, 17 Feb 2013 16:16:00 +0000

Since releasing the first version of the script I use to deploy this blog to S3, I’ve iterated on the script a little bit and made a few changes. Most of the changes in version 2 of the script are syntax changes to the script itself that make it a little bit easier to read¹ however there are a couple of functionality changes.

The biggest change is the introduction of command line flags. Three flags have been added, -b, -s and -n. These tell the script to not minify sass files, not compile sass files and to perform a dry run respectively. The first two flags speak for themselves while the third, the dry run flag, simply means that the site will be generated as usual but it won’t be deployed to S3. It’s akin to running s3cmd sync --dry-run src/ s3://bucket.

Another new ‘feature’ is a countdown that is performed before deploying to S3. After generating the site, the script waits three second before pushing the generated site giving you opportunity to cancel the deployment if you forgot to pass the -n flag or realise that you’re (somehow) deploying to the wrong bucket. I’m sure some people aren’t going to like this but seriously, what’s waiting 3 seconds compared to the time it’d take to fix the mess after deploying your testing site to the wrong bucket?

A couple of the smaller changes to the script relate to Python 3 compatibility. I’ve removed the dependency on PyYaml since it isn’t compatible with Python 3 and it was a bit of an overkill to get just one line out of the _config.yml file. In addition, I’ve fixed a crash that would occur when gzipping files and the script is run under Python 3.

The updated script is below and you can also find the script as a gist on GitHub.

#! /usr/local/bin/python3

import gzip
import os
from subprocess import PIPE, check_call, CalledProcessError
from sys import exit
from time import sleep
import argparse

def get_s3_bucket_name():
 with open("_config.yml") as f:
 for line in f:
 if line.split(':')[0] == "s3bucket":
 return line.strip("s3bucket:").strip()
 exit("Error: No bucket was found in the site's _config.yml file")

def compile_sass(input_file, output_file, minify=True):
 command = "sass " + path_to_sass_file + ":" + sass_compile_path
 if minify:
 command = command + " --style compressed"
 try:
 check_call(command, shell=True)
 except CalledProcessError:
 print("Something went wrong compiling sass files.")

def generate_site():
 try:
 check_call(["jekyll", "--no-auto"], stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong generating the site with Jekyll.")

def gzip_files():
 for root, dirs, files in os.walk("_site/"): # Traverse the _site/ directory
 for f in files:
 if os.path.splitext(f)[1] in ['.html', '.css', '.js']:
 current_path = os.path.join(root, f)
 with open(current_path, 'rb') as f_in:
 with gzip.open(current_path + '.gz', 'wb') as f_out:
 f_out.writelines(f_in)
 os.replace(current_path + '.gz', current_path)

def deploy_to_s3_bucket(bucket, dry_run=False):
 if dry_run:
 print("Doing a dry run!")

 try: # Upload all uncompressed files
 command = "s3cmd sync -P --exclude '*.html' --exclude '*.js' --exclude '*.css' _site/ " + bucket
 if dry_run:
 command_ls = command.split()
 command_ls.insert(-2, "--dry-run")
 command = ' '.join(command_ls)

 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong deploying the site to s3.")

 try: # Upload all compressed files and add an appropriate header
 command = "s3cmd sync -P --add-header='Content-Encoding: gzip' --exclude '*.*' --include '*.html' --include '*.js' --include '*.css' _site/ " + bucket
 if dry_run:
 command_ls = command.split()
 command_ls.insert(-2, "--dry-run")
 command = ' '.join(command_ls)

 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong setting the content encoding on the files deployed to s3")

 try: # Remove any files that have been deleted
 command = "s3cmd sync -P --delete-removed _site/ " + bucket
 if dry_run:
 command_ls = command.split()
 command_ls.insert(-2, "--dry-run")
 command = ' '.join(command_ls)
 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong removing files from the bucket")

if __name__ == "__main__":

 parser = argparse.ArgumentParser(description="Deploy a Jekyll site to Amazon S3")
 parser.add_argument('-s', '--no-sass', help="Don't compile Sass files", action='store_true')
 parser.add_argument('-b', '--beautiful-sass', help="Don't minify Sass files", action='store_false')
 parser.add_argument('-n', '--dry-run', help="Perform a dry run when deploying to S3 (akin to running s3cmd with the --dry-run flag)", action='store_true')
 args = parser.parse_args()

 path_to_sass_file = "assets/styles/sass/styles.scss" # Change to your path
 sass_compile_path = "assets/styles/css/styles.css" # Change to your path

 if args.no_sass == False:
 print("Compiling Sass Files...")
 compile_sass(path_to_sass_file, sass_compile_path, minify=args.beautiful_sass)

 print("Running Jekyll...")
 generate_site()

 print("Gzipping File...")
 gzip_files()

 print("Getting Bucket Name...")
 bucket_name = get_s3_bucket_name()

 for i in reversed(range(1,4)):
 print("\rDeploying to {0} in {1}".format(bucket_name, i), end='')
 sleep(1)

 print("\nDeploying...")
 deploy_to_s3_bucket(bucket_name, dry_run=args.dry_run)
 print("Successfully Deployed Site!")

At the same time, I’ve removed half of the comments in the script because most of them were #increment i by one style comments. ↩︎

Deploying This Jekyll Site to S3

Thu, 17 Jan 2013 21:22:00 +0000

If you’re the type of person who likes to read the footers of websites (who doesn’t?) you’ll have seen that this website is “powered” by Jekyll. In case you haven’t heard, Jekyll is a static site generator that is especially useful for generating static blogs. That is, you run the Jekyll program on a computer, point it at a “source” directory for your website and let it generate a load of HTML files that you can upload to practically any web server that serves files. There’s no need to install PHP or Rails and no need to get a fancy server that can run them. Jekyll is a really awesome utility and that is a terrible description of what it does. You’re better off checking out the GitHub page and seeing how that describes Jekyll.

The purpose of this post isn’t to describe what Jekyll is though, it’s to tell you how I deploy this blog that is built with Jekyll to Amazon S3. As a lot of people have written, Amazon S3 is a great place to host small Jekyll blogs. It’s cheap, it’s fast and it has an exceptionally good uptime.

Deploying a Jekyll blog to Amazon S3 is relatively straightforward by using a tool called s3cmd. s3cmd is a powerful tool that provides a good, command line method for synchronising a directory with a bucket on Amazon S3. While running s3cmd on your generated site will produce a website that’s hosted on S3 (once you’ve set up permissions, DNS etc.) there’s a few things that can be done to optimise your website and make it a bit faster.

You can run gzip to compress all your CSS, HTML & JavaScript files but in order to serve these files, you’ll need to specify the correct content encoding on the compressed files otherwise browsers won’t render your pages. You can also run CSS & JavaScript minification, heck, you can even run HTML minification if you’re desperate to squeeze some speed out of your site. The problem is, running all of these processes requires you to remember a lot of different and complicated commands. Even if you have the memory of a sea lion, running all these commands makes deploying your site slow and tedious. I’ve gone ahead and written a script that combines all the commands I need for deploying my website and I thought I would share it with the world.

The script is written in Python because I don’t know any other scripting languages that well. I don’t know Python that well too but it’s the scripting language I’m most confident in. The script does a couple of things. The first thing it does is compile any sass files that need to be compiled and minifies the resulting CSS file. This is (possibly) quite specific to my website since not all Jekyll sites are going to use sass (though I do recommend it) and not all sites are going to compile just one sass file¹. After compiling the sass files, the jekyll command is run, building the site. I’ve added a plugin to Jekyll to minify HTML² so that gets done when the site is generated rather than by using another package. Once the site is generated, I run the gzip command to compress all HTML, CSS & JavaScript files. Finally, the generated website is uploaded to an Amazon S3 bucket with the gzipped files having the appropriate content header set so that they will be loaded by browsers.

The script basically wraps up five or six commands into one simple python _deploy.py command. Any way, enough waffle. The script:

#! /usr/local/bin/python3

import yaml
import gzip
import os
from subprocess import PIPE, check_call, CalledProcessError
from sys import exit

def get_s3_bucket_name():
 try:
 with open("_config.yml") as f:
 config_file = yaml.load(f)
 try:
 return config_file["s3bucket"]
 except KeyError:
 exit("Error, no S3 bucket was found in _config.yml.")

 except IOError as e:
 exit("I/O error({0}): {1}".format(e.errno, e.strerror))

def compile_sass(input_file, output_file, minify=True):
 command = "sass " + path_to_sass_file + ":" + sass_compile_path
 if minify:
 command = command + " --style compressed"
 try:
 check_call(command, shell=True)
 except CalledProcessError:
 print("Something went wrong compiling sass files.")

def generate_site():
 try:
 check_call(["jekyll", "--no-auto"], stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong generating the site with Jekyll.")

def gzip_files():
 for root, dirs, files in os.walk("_site/"): # Traverse the _site/ directory
 for f in files:
 filename, extension = os.path.splitext(f) # Get the extension of the current file
 if extension == ".html" or extension == ".css" or extension == ".js": # Check to see if it's a compressible extension
 with open(os.path.join(root, f), 'r') as f_to_compress: # Open the file
 with gzip.open(os.path.join(root, f) + ".gz", 'wb') as f_compressed: # Open a new gzip file
 f_compressed.writelines(f_to_compress) # Write the original file into the gzip file
 os.remove(os.path.join(root, f)) # Remove the original file.
 os.rename(os.path.join(root, f) + ".gz", os.path.join(root, f)) # Rename file to original


def deploy_to_s3(bucket, dry=False):
 if dry:
 print("DOING DRY RUN")

 try: # Upload all uncompressed files
 command = ""
 if not dry:
 command = "s3cmd sync -P --exclude '*.html' --exclude '*.js' --exclude '*.css' _site/ " + bucket
 else:
 command = "s3cmd sync -P --exclude '*.html' --exclude '*.js' --exclude '*.css' _site/ --dry-run " + bucket
 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong deploying the site to s3.")

 try: # Upload all compressed files and add an appropriate header
 command = ""
 if not dry:
 command = "s3cmd sync -P --add-header='Content-Encoding: gzip' --exclude '*.*' --include '*.html' --include '*.js' --include '*.css' _site/ " + bucket
 else:
 command = "s3cmd sync -P --add-header='Content-Encoding: gzip' --exclude '*.*' --include '*.html' --include '*.js' --include '*.css' --dry-run _site/ " + bucket
 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong setting the content encoding on the files deployed to s3")

 try:
 command = ""
 if not dry:
 command = "s3cmd sync -P --delete-removed _site/ " + bucket
 else:
 command = "s3cmd sync -P --delete-removed --dry-run _site/ " + bucket
 check_call(command, shell=True, stdout=PIPE)
 except CalledProcessError:
 exit("Something went wrong removing files from the bucket")

if __name__ == "__main__":

 path_to_sass_file = "assets/styles/sass/styles.scss"
 sass_compile_path = "assets/styles/css/styles.css"

 print("Compiling Sass Files...")
 compile_sass(path_to_sass_file, sass_compile_path, minify=True)

 print("Running Jekyll...")
 generate_site()

 print("Gzipping File...")
 gzip_files()

 print("Getting Bucket Name...")
 bucket_name = get_s3_bucket_name()

 print("Deploying to %s..." % bucket_name)
 deploy_to_s3(bucket_name, dry=False)
 print("Successfully Deployed Site!")

There’s a few prerequisites for the script. You’ll need to install the PyYaml library for Python, as well as the sass & s3cmd packages. You’ll also need to modify your website’s _config.yml file so that it has the name of the s3 bucket you want s3cmd to upload your website to:

s3bucket: s3://bucketname

If you don’t need to compile any sass files, go ahead and comment out³ the 6th line of the __main__ method (that’s where it says compile_sass(path_to_sass_file, sass_compile_path, minify=True)). If you do need to compile sass files, modify the path_to_sass_file and sass_compile_path variables so that they point to where the main sass file is and where you want it to be compiled to.

And that’s it. It’s not the most general script in the world but I can see it coming in handy for one or two people who have similar deployment processes to me. If you want to leave some feedback on the script, I’ve created a Gist on GitHub for the script with some more extensive documentation.

By one sass file I don’t mean I’ve got all of my sass in one file, I just compile lots of different sass files into one CSS file. ↩︎
I know HTML minification isn’t the safest or best way to boost a site’s performance, you don’t need to tell me. ↩︎
To comment a line out in Python just add a # to the start of the line. ↩︎

Fixing Slow Wireless Speeds in Ubuntu 12.10

Mon, 31 Dec 2012 00:00:00 +0000

After building a new computer recently I went ahead and installed Ubuntu 12.10 on it alongside Windows. Since the computer doesn’t have a wireless card and isn’t anywhere near a router, I bought a cheap Wireless USB adapter so that I could connect to my wireless network. I actually bought the adapter several years ago and used it on a computer running Ubuntu 10.04 that was in a similar situation. The adapter I bought was a Belkin F5D8053, the v6 revision. I bought this adapter because I’d been told that it had good compatibility with Linux and I remember it working perfectly well in Ubuntu 10.04. I was surprised to find then that when I used the adapter with my new installation of Ubuntu 12.10 it was very unreliable. The adapter worked but after arround five minutes of usage, the connection speed would drop substantially and anything, be it on the internet or my local network, was incredibly slow.

I set about trying to figure out what was up. The first thing I thought was that maybe the driver used for the adapter had been messed up somehow between Ubuntu 10.04 and 12.10. Running lsusb revealed that the adapter used a RTL8191SU chipset by Realtek so I went to Realtek’s website and downloaded the source to compile the driver for the adapter. Turns out, something changed in version 3.4 of the Linux Kernel that made compiling these drivers impossible without some minor modifications. Version 3.5 of the Kernel broke even those modifications so compiling new drivers wasn’t an option any more.

Some more Googling produced some interesting information. Apparently, there’s a bug in network-manager, the package used by Ubuntu to connect to networks, that results in the connection speed slowing down after a few minutes of use. The solution, install an alternate to network-manager and disable network-manager. I went ahead and installed wicd and disabled network-manager and so far, in the past 36 hours of use (around 12 hours continuous use over 3 days), I’ve had no drop in connection speed. It would seem that the drop in connection speed is due to network-manager which means that people having similar problems with connection speed could find that replacing network-manager will solve their problems.

The Fix

The fix is quite simple, install wicd and disable network-manager. The steps for doing this are outlined below:

First, install the wicd package:

sudo apt-get intall wicd

Next, disable network-manager and stop it from starting on startup too:

sudo stop network-manager
sudo mv /etc/init/network-manager.conf /etc/init/network-manager.conf.off

Now start the wicd daemon and bring up the GUI tool so you can connect to your wireless network:

sudo /etc/init.d/wicd start
wicd-client

And that’s it, assuming that network-manager was your problem, you should now have a far more stable wireless connection and wicd should start on login too. If you want to get wicd in Unity’s system tray, you’ll need to run the following command:

gsettings set com.canonical.Unity.Panel systray-whitelist "['wicd']"

Then logout and log back in, you should now have a (fairly ugly) tray icon for wicd. There’s replacement icons available, just Google for them.

Once you’re certain that wicd has solved your problem and you don’t need network-manager anymore, you can go ahead and remove nework-manager. First, revert the changes made to network-manager’s upstart job and then remove the package:

sudo mv /etc/init/network-manager.conf.off /etc/init/network-manager.conf
sudo apt-get remove --purge network-manager

That solved the problem for me. If it does for you, be sure to file a bug report so that this issue hopefully gets fixed in network-manager.

SymSteam Beta 2 Released

Mon, 31 Dec 2012 00:00:00 +0000

It may have taken nearly 9 months but beta 2 of SymSteam is finally available for download. This is a huge update for SymSteam that completely changes how it works and fixes many bugs as a result. SymSteam no longer manages drives based on their names, rather, it relies on the UUID of a drive to determine if the drive is the Steam drive. This makes SymSteam more reliable in situations where you have drives with the same name but it does introduce a new requirement. The drive you’re storing your games on must have a UUID which essentially means that the drive must be HFS+ formatted¹.

In addition to this major change, lots of small changes have also been made that make SymSteam easier to use and more reliable. The error correction performed on your Steam folders when SymSteam is launched is far more reliable now and SymSteam can fix incorrect folder setups in many more cases, reducing the number of situations where SymSteam will fail to work. The setup process has been rewritten to make it much simpler to use and also to make it less likely to fail. The preferences window has been expanded upon too, providing more in-depth options for notifications and an option to start SymSteam on login. Oh, SymSteam finally has an icon too! It’s not amazing but it’s better than the generic app icon that SymSteam had before the update.

The full changelog for beta 2 can be found here.

SymSteam now has some fairly extensive documentation available on its new project page. The new documentation includes information on setting up SymSteam and some troubleshooting information too. The documentation can be accessed here.

If you already have SymSteam installed then it will prompt you to update (assuming you’ve allowed it to). If not, you can download beta 2 of SymSteam here.

There are other filesystems that assign drives a UUID but I don’t think any of these have native support in OS X. ↩︎

Recent Projects

Wed, 13 Jun 2012 00:00:00 +0000

It would seem that pretty much the only thing I use this blog for is announcements. Guess what’s in this post, some more announcements, specifically regarding some new projects that I’ve started in the past month (and a bit).

Now that I’ve got a lot more free time on my hands, I’ve managed to start two new Cocoa projects for the Mac, one of which I’ve been intending to do for several months. They’re both free applications and they’re both open source, with the source code being available off of my GitHub page. If you were to categorise both of these projects, they’d both fall into two categories that are totally new to me in terms of development. One of the projects is a game and another is an utility aimed at developers.

MemTester ( - Mac)

MemTester is the game. I’ve never made a game before so this was/is quite a fun little project to work on. MemTester is a very simple memory testing game (surprise, surprise) that tests your ability to memorise an increasingly lengthy sequence of numbers, letters or symbols. The game has three difficulties, easy (just numbers), medium (just lowercase letters) & hard (nearly all possible ASCII characters) and has amazing features like a high scores table & fancy animations (/sarcasm). I started working on MemTester as a port of a similar game that a friend of mine made. My friend’s version was written in Java and was very un-Mac like so I decided to make a native Cocoa port of the game for fun. He wasn’t best pleased.

So far, version 1.0 of MemTester has been released and there’s been no further development since then (though I do have a couple of things planned). Development for MemTester will be on and off, but you can watch the project on GitHub. You can also download the latest version from here.

Appcastr

Appcastr is the development tool. It’s quite possibly my most ambitious project to date and so far, developing it has been a joy and I’ve learnt a lot of new things working on it. Appcastr is a tool for developers who use the Sparkle update system, that’s the update system used by 99% of Mac applications that aren’t in the Mac App Store, that makes it easier & quicker for developers to create and maintain appcast files by providing a GUI to edit them with. Appcast files are just RSS files with a special <enclosure> element in them that allows them to include information on the latest version of an application and where to get it from. The appcast file is downloaded by the Sparkle update framework and then parsed to see if there’s a new version of the application available.

Since appcast files are just XML files, it’s not exactly hard to edit the files by hand but it’s a lot faster to use a GUI application and I plan on adding a couple of handy features that will make distributing an update significantly faster if the developer chooses to use Appcastr.

I’m a bit concerned working on a project like Appcastr. Given that it’s aimed at developers, it’s much more likely that the source code will be viewed by, and possibly edited by, other developers than my other projects. This means the quality of my code is a lot more important and will probably receive some judgment. Make no mistake, I really want other developers to look at my code and tell me where to improve it. Given that I’ve taught myself to program, I’m certain that my code is rife with malpractice and things that’d probably make more experienced developers cry. I’d love to hear some constructive criticism about the quality of my code.

Appcastr version 0.1 was released just yesterday and version 0.1.1 was released this morning. I’m going to work diligently on this project so expect frequent updates. You can get the bleeding edge version of Appcastr by visiting the project’s GitHub page and checking for the branch which is the most commits ahead (at the time of writing, version 0.2). Be warned though, things could be broken or buggy in that branch. The “master” branch will have more stable code and (should) be a representation of the most recent build available off of the project’s downloads page.

So they’re the two new projects that I’ve launched recently. My third project, SymSteam, hasn’t received much love recently. It’s been stuck on beta 1 for a while. To be honest, I’ve been using the application day-in-day-out for several months now and haven’t noticed any bugs in my usage so I’m tempted to make an icon for the application and release it as version 1.0. Laziness FTW!

Thoughts on WWDC 2012

Tue, 12 Jun 2012 00:00:00 +0000

Yesterday (June 11th) marked the first day of Apple’s famous WWDC event. As per usual, Apple opened the event with the only part of the event that isn’t under NDA (and hence the only part that I’ve actually been able to see so far), the keynote. The keynote was a blast with lots of new, exciting things announced. Here’s my thoughts on a couple of those things that were announced.

Updated MacBook Airs

The updated MacBook Airs are really nice. They’re a lot faster now thanks to both a new generation of Ivy Bridge processors and faster SSD technology. I’d really like to get one but I’ve just splashed out on a last generation MacBook Air, so can’t afford the new generation any time soon. The graphical performance of the new Airs has been improved by “up to 60%” which really excites me. The Airs still have an integrated graphics card but it’s an Intel HD 4000 series card, which is a surprisingly beefy integrated card and performs respectably at many modern games. The price of the Airs has been dropped a bit too. Here in the UK, the prices have gone down enough that the low end 13 inch model costs the same as the previous generation low end 11 inch model. Nice.

The MacBook Pros also got an update, just a small bump in specs, nothing too exciting. Apple seems to have deprecated the 17 inch MacBook Pro though which’ll annoy about ten people.

MacBook Pro With Retina Display

Wow. Just wow. This thing is awesome. This isn’t the 15 inch Air that everybody was hoping for but I think it’s better. The new MacBook Pro has a completely redesigned case which is stunning to look at. What’s even more stunning to look at though is that new display. It has over 5 million pixels in it. I haven’t seen one of these yet but I know from the numbers, that display is gorgeous. The new MacBook Pro has really excited me, it represents the start of a revamp of Apple’s line of computers. I envision new designs & retina displays coming to most of Apple’s computers throughout the next couple of years.

OS X Mountain Lion

Mountain Lion was probably my favourite piece of news from the WWDC keynote. True, most of what Apple talked about in the keynote had already been posted on their website but there was still some interesting new features that they announced. The new “Power Nap” feature is pretty neat, allowing you to download updates to your Mac while it’s in sleep mode. It’ll also keep all of your iCloud stuff in sync while your Mac sleeps which is handy. If Apple includes support for updating your (App Store) applications while in sleep mode too then that’d just be fantastic.

The inclusion of speech-to-text processing in Lion too is pretty cool. If the processing is as good as iOS’s speech-to-text then I can see this feature actually being really useful for dictating long text documents. Apple says that the dictation works in any text field too, so no need to wait for developers to update their applications. The only saddening part was that there was no mention of a speech API, something which I would love to play around with.

There were a couple of other tidbits in 10.8 that looked interesting. The new version of Safari seems pretty good and I’ll probably switch back to it from Chrome when it is released. GPU accelerated scrolling was also mentioned, which would make scrolling a lot smoother in OS X and would help make OS X feel even faster. The fact that Apple seems to have “fixed” full screen mode on external displays is fantastic too. Full screen mode might actually be useful in 10.8 now.

iOS 6

iOS 6 was probably the most disappointing of all the announcements at WWDC this year. There were good aspects to the announcement but overall I felt unsatisfied with the new features that had been announced. Siri was updated with support for getting information on sports & movie, a feature which I doubt will be used much. She also got some new voice commands, a few of which will be useful. She finally gained support for obtaining local business information outside of the US, something which I’ve been waiting for since the iPhone 4S launched back in October. There’s still no API for Siri though which is really annoying. I like to control my music using Siri (saves getting the phone out of my pocket) but I don’t use the built in music app. It would be nice if I could use music voice commands in other apps like Rdio, something which would only be possible with an API.

Unfortunately, there was no UI refresh in iOS 6 which was the main thing I was hoping for. Well, I say there was no UI refresh but really there was a mixture of UI updates which seems to have removed a lot of consistency in the iOS’s UI. Different shades of colours have been changed throughout the UI. The status bar, for example, is now a silvery blue instead of grey which is an interesting colour choice. There seems to be a slightly different shade of blue being used in navigation bars too. The new maps app has been given the silver UI treatment. It doesn’t look out of place in the OS but it certainly isn’t consistent with the rest of the OS’s UI. I don’t see why Apple would update parts of the UI in one application without updating the rest of the OS. It really doesn’t play nice with the consistency of the user interface throughout the operating system.

As expected, Apple updated the maps app and they’re now using their own custom mapping service rather than Google Maps. The new maps (as in the actual maps) look a lot nicer and cleaner when compared to Google’s and Apple’s included some swanky 3D mode in the maps which looks pretty awesome. The new maps application also includes support for turn by turn directions which is pretty neat. I don’t have any use for it (yet) though.

There were tons of other new features in iOS 6. The phone application (yeah, I’d forgotten about that too) got some nice updates which could come in handy for gracefully rejecting phone calls. There’s also a new Passbook application which looks like a virtual wallet for different types of tickets. I think it’ll be really awesome but I doubt it’s going to get much use outside of the US for a long time which is a crying shame. Such an application could be really useful.

The major disappointment with iOS 6 is its lack of backwards compatibility. Apple’s saying the update is compatible with the iPhone 3GS and onwards, the second & third generation iPad & the fourth generation iPod Touch. I don’t understand why the 3rd generation iPod Touch or 1st Generation iPad aren’t on the list though since they’re basically identical to the iPhone 3GS and iPhone 4 respectively in terms of processing power. Maybe I can understand the 1st Generation iPad not making the shortlist, it is quite slow to use with iOS 5 at the moment, but the 3rd generation iPod Touch, that represents a sizeable chunk of the iOS market and it’s pretty much the same as the 3GS. Strange.

Overall, this year’s WWDC keynote has been very impressive. Lots of new products that are very exciting. I’m really looking forward to Mountain Lion (due in July) and I think it’s going to be a good all around update to OS X. iOS 6 will be pretty good too though, for me, it’s not as exciting as Mountain Lion. The thing I’m waiting for now is the release of the actual development sessions from WWDC, they’re probably the best part of the whole week for me.

SymSteam Beta 1 Released

Wed, 11 Apr 2012 00:00:00 +0000

Good news! Just the other day, SymSteam, my small pet project, received a pretty major update. In fact, this update is so major, I’ve labelled it Beta 1. Pretty much everything to do with SymSteam has changed.

Beta 1 brings numerous new features and changes to the application. A list of the changes is available on SymSteam’s new website here but in this post I’d just like to elaborate on some of the features and the work that’s gone into beta 1 of SymSteam.

Development on SymSteam 0.2 began back in February with the simple aim of adding support for Growl notifications and fixing some bugs to make SymSteam more usable. Growl support was added pretty quickly but I had the idea of rewriting the underlying logic of SymSteam which helped to remove a substantial number of bugs. The rewrite took the best part of a day and made SymSteam far easier to use. It simplified the setup procedure and helped make SymSteam less likely to fail in difficult situations. After this rewrite, I rewrote the scanning system for detecting the SteamApps folder. I changed it so that SymSteam performed first a shallow scan (only scanning top level directories) and then it performed a deep scan, should it not find the SteamApps folder when performing the shallow scan. This change in the scanning mechanism helped to significantly reduce the time it took for SymSteam to detect the SteamApps folder when a drive was plugged in, in around 90% of cases.

After making all these changes to the scanning system however, I decided to endulge on another rewrite, completely changing the way SymSteam functions. SymSteam no longer scans all drives that are connected for the SteamApps folder, rather it will resolve the symbolic link you point it to and only scan at that directory, performing a simple check to see if the folder exists at the symbolic link or not. If the correct drive is connected, the folder will exist and SymSteam can update the SteamApps folders so that Steam loads its games off of the external hard drive. If the folder doesn’t exist however, then life carries on as normal and nothing changes. This is a lot faster than scanning each drive that is connected and SymSteam can now work in a split second rather than a few seconds.

After this rewrite, I attempted to write a startup method that would run when SymSteam is launched that would attempt to fix any naming problems with the SteamApps folders that may arise when SymSteam is quit without being given the ability to rename the SteamApps folders so that the local folder is active. This error prevention method seems to work with limited success and I’ll continue to develop it in future versions to make it more successful.

I decided to update the preferences window in SymSteam too, using the MASPreferences framework to provide a proper preferences window. I wrote about how to use MASPreferences and my experiences with it on SimpleCode here.

There were several other changes within SymSteam, however I feel that these were the most substantial. Other changes include a vastly simplified setup procedure (which I briefly touched upon when talking about the rewrite), a new tool to help ease the creation of symbolic links and a new autoupdate system too, which will make pushing updates much easier in the future.

SymSteam beta 1 is available now and I’ve already got plans for the next version of SymSteam, beta 2. SymSteam now has its own website, so you can get access to SymSteam beta 1 and the source code via http://alexjohnj.github.com/symsteam.

SymSteam 0.1.5 Released

Sat, 18 Feb 2012 00:00:00 +0000

SymSteam, my small project I released just a few weeks ago, received its first major update today. Version 0.1.5 was pushed to the GitHub repo a few hours ago and with it came an important new feature and some bug fixes.

The most important new feature is a new preferences window which allows you to change the where your symbolic and local SteamApps folders are located. This is pretty handy since, previously, the only way to change these paths was to delete SymSteam’s plist file. Under the hood, SymSteam’s got a new system for managing connected drives so that it knows what drives are connected and, of those connected drives, which one is actually a Steam drive. This should remove a couple of bugs related to having multiple connected drives. It could, however, introduce some new ones. Watch out. One more thing to note, scanning drives for SteamApps folders should be a little bit faster now. Not massively, but a little bit.

To download the latest version of SymSteam, head over here. If you’re interested in the source code, you can check out the code here. The code in the master branch should be reasonably in sync with the latest version of SymSteam available to download. Most major new features will get their own branch while they’re being developed.

0.2

I also started working on version 0.2 today. The plan for version 0.2 is to add support for Growl notifications, improve the error handling logic for missing folders and add the ability to specify a single drive and path to scan for a SteamApps folder, improving performance greatly. So far, basic support for Growl has been added but not tested.

If you want to see and (hopefully) contribute towards the development of the latest build of SymSteam, you can look at the symsteam-2.0 branch here (I know, that should be symsteam-0.2.0 but I wasn’t thinking when I named the branch). Be warned, stuff will likely be unstable and broken in that branch.

Moving from 1Password To LastPass to 1Password Again

Tue, 14 Feb 2012 00:00:00 +0000

In the past few weeks I’ve had a bit of an epiphany. I’ve become incredibly security and privacy conscious. I’ve closed my Facebook account, started moving away from Google and begun using far stronger, unique passwords. In the past, for websites, I’ve had one strong password which would be impossible to guess and then used that on every website (except my bank, which doesn’t allow special characters in a password). I know, shoot me. That’s the worst thing you can do in terms of passwords next to having 123456 as your password. Every website had the same password and email and (normally) username. If you got the password to one website, you had it to all of them. I’ve realised this security flaw and over the past couple of weeks, changed all of my passwords so that they are unique to each website and totally unintelligible to humans. 30 characters of random, well, characters. How the hell was I meant to remember them? I used a password manager. In the past, I’d been using 1Password to “manage” my passwords. I’d really been using 1Password, not because I couldn’t remember my passwords, but rather to reduce the number of keystrokes needed when entering a password.

Now that I was using impossible to remember passwords, a password manager was no longer a convenience, it was a necessity. After updating all my passwords in 1Password, everything was fine for a few days. 1Password is an excellent piece of software and is incredibly simple to use. Three days after changing all my passwords though, I hit a roadblock. I was on a public computer and needed to login to a website. Normally I’d just use 1Password but this wasn’t any computer. a) It didn’t have 1Password installed & b) It ran Linux. 1Password doesn’t run on Linux. It’s Mac & Windows only. I had a problem. To be fair to the 1Password developers, I could actually access my 1Password database from the computer via Dropbox. The 1Password data file includes a small web application that allows you to view your 1Password data from any web browser, without the main application being installed. The problem is, this requires my Dropbox account to have a memorable, and therefore insecure password, something I wasn’t comfortable doing. When I was back on my own computer, I started looking into a cross platform solution (since I use non Mac computers a lot) and came across the famous LastPass. Reading through the feature list, the free version seemed to cover most of my needs and the incredibly cheap premium version would cover the rest (mobile support). Best of all, LastPass was cross platform, since it is only a web service and browser extension.

I signed up to LastPass and installed its extension to my (at the time) browser of choice, Chrome (now Firefox). I was initially quite impressed. Setup was simple. LastPass offered to import my passwords from 1Password (though this did require me to export the passwords to a plaintext format) and even scanned them to tell me if there were any duplicate passwords or other potential security risks. Functionality wise, LastPass was incredibly impressive. It wasn’t anywhere near as aesthetically pleasing as 1Password but it had far more functions. After installing LastPass on my Mac and Linux boxes I carried on as normal, with the intention of replacing 1Password and purchasing a premium subscription to it after a few days. Within a few hours though, I began to become concerned about my security with the service though.

Typically, peoples concern with LastPass’ security comes from the fact that the service stores all their passwords on a server (for synchronisation). This wasn’t my concern as, before signing up, I’d done extensive research into the service’s security. LastPass’ password storage is very secure. LastPass can’t access your passwords, they can only see the encrypted file. The passwords themselves are only decrypted on your computer. I wasn’t concerned about somebody accessing my passwords remotely. I was concerned about someone getting them from my computer.

The LastPass extension works like this. You login to your LastPass account and all of your passwords are synchronised to your computer. When you visit a site, the extension offers to autofill the password for you. If you allow it to, it will continue to do so in the future. 1Password has a similar extension. With 1Password, you visit a site and press a key combination. Up pops a window asking you to unlock your password with a master password. The extension then fills in the username & password and will optionally submit the login for you. When you revisit the website again, you must do the same action. At first glance, 1Password’s method of autofilling logins seems to be slow(er), requiring several steps. LastPass is far more simple, automatically filling in the form when you visit a site. You don’t need to log back in or unlock your passwords. LastPass just assumes that it’s you using the computer and not, say, someone who’s just stolen your computer. That’s my security concern with LastPass. By default, you’re never logged out of the extension. That’s one hell of a major security flaw. Even worse is the fact that it automatically fills in passwords for you. With 1Password, even if your password vault is still unlocked (it doesn’t actually lock until after 5 minutes; you tell it; or some event happens like closing the laptop’s lid), you have a small layer of security in terms of a key combination to fill in the password. Your common laptop thief isn’t going to know what buttons to press to activate the 1Password extension. With LastPass, they don’t need to know any buttons. It’ll do it for them.

Again, in the interest of fairness, LastPass does provide two options in its settings menu to

Automatically logoff when all browsers are closed for x minutes.
Automatically logoff when idle for x minutes.

The option’s there but I’m extremely concerned by the fact that these two options aren’t enabled by default. Enabling these options then throws up an annoying usability problem. When the LastPass extension logs you out automatically and you visit a site, the extension doesn’t prompt you to login to autofill the password. This can result in a bit of head scratching as you try and work out why the extension isn’t filling in your passwords. 1Password has this problem too, but it’s alleviated slightly by the fact that the key combination to autofill passwords becomes a reflex action and so you ultimately end up being prompted for your password anyway.

That’s my main problem with the LastPass extension. While this was annoying, it was fixable and so I continued using the service and, ultimately, ended up signing up for the premium service solely for the ability to access my passwords on mobile devices, in my case, an iPhone. This is where the service became sickeningly bad.

A years subscription to LastPass premium cost £7.49 ($12) which, in terms of coffee pay is maybe 3 and a bit coffees? Either way, it’s not going to break the bank. I downloaded the iPhone(/iPad) app and went through the setup. As expected, the UI was pretty rough. I’d come to expect this, given LastPass’ track record with the browser extensions. After logging in, you’re presented with a list of your sites according to their groups. If you haven’t set up any groups, you’ll just get a list of sites under a group called “none”. Tapping on a site presents a modal list of options including the ability to copy a password or username to the clipboard. Counter intuitively, the button to cancel the list is at the top, whereas it’s normally at the bottom in iOS. This is just one of the many user interface and design flaws in the application. The most frustrating of these flaws is the option (or lack thereof) to logout on close.

The mobile application, like its desktop counterpart, likes to keep you logged in for as long as it can. If you close the app so that it enters the background, you stay logged in until the application is killed full stop. As soon as the application is killed, everything’s nice and secure. Digging around in the settings, there’s an option called “log out on close”. Logic foretells that enabling this will log you out of the application when you close the application, even if it’s still running in the background. Oh no. It does nothing. At all. At least, as far as I can tell it does nothing. The app continues to keep you logged in until you kill the application. This is a major security flaw, especially on a mobile device. Having to remember to logout of a mobile application is just stupid, especially one with as sensitive data as this. Mr iThief could happily take my phone and, even if I haven’t launched LastPass in a while, it could still be running in the background and Mr iThief could easily get my passwords.

Again, In the interest of fairness, 1Password (Touch) does a similar thing and can stay logged in indefinitely as long as it’s running in the background. Whether it does this by default I can’t remember but it does provide some fairly extensive options to configure auto locking. Currently, my copy of 1Password requires a pin as soon as it is enters the background, requiring the master password after 5 minutes of inactivity. I think this is pretty secure and works nicely.

Thanks largely to the terrible iOS application (it has so many problems), I’ve stopped using LastPass for now and switched back over to 1Password. I’ve also sent a message to LastPass asking for a refund, I should get one. It’s going to be annoying on my Linux machines trying to use 1Password but, in terms of design and local security, 1Password feels a lot safer since it doesn’t leave me logged in for indefinite periods of time. LastPass is an excellent product assuming you only use the browser extensions with automatic log out enabled. Otherwise, despite the excellent security LastPass takes in storing your passwords, it fails miserably at keeping your passwords safe on your devices, especially mobile ones.

Update Within minutes of writing this post and a few hours of requesting a refund, I’ve received an email from LastPass confirming a refund for the premium service. Ultimately, no harm done.

Update 2 The other night (14/02/12), I got two emails from Joe at LastPass in response to the issues I raised in this post. Here’s what he had to say:

Email 1

For windows we force you to choose if you want to be logged out or stay logged in, the fact that we don’t have this option on OS X / Linux prompting you by default is something we’ll rectify.

For iOS, we have the option to logout on close, and to pin prompt if you’ve left LastPass logged in the background – did you miss this in the ‘more’ menu?

Best,

Joe

Email 2

I should also mention that you might want to try LastPass Icon -> Preferences -> whatever 1password key combo for fill in next site to get that behavior.

Joe

Nice to see a response from someone at LastPass! So it would seem I missed a setting in the iOS application. Apparently, enabling pin prompt in LastPass (along with logout on close) will solve my security concern on the iOS app. I didn’t realise that both of these settings had to be enabled, the app didn’t (but should) point this out. I can’t actually verify that this would solve my security concern since I don’t have a premium subscription (and hence access to the mobile application) anymore but I trust the guys and girls at LastPass and don’t see why they’d lie.

I’m pleased to see that LastPass are aware of the issue of remaining logged in indefinitely to the browser extension on Mac OS X (and, it would seem, Linux). Judging by the email, the Windows version asks the user if they should remain logged in during setup, which I think is a pretty good implementation as I know it would annoy some users if they where being logged out of the extension all the time.

Finally, in response to using a keyboard combination to fill in site login info, while using a custom keyboard combo is handy, LastPass continues to offer to autofill passwords after enabling the keyboard shortcuts (as expected). After experimenting a bit, I’ve found that, in order to get the extra layer of “security through obscurity” that the 1Password extension offers, it’s necessary to change a few other preferences. You must also disable the “Automatically Fill Login Information” preference (LastPass Prefs > General) and the “Show Fill Notifications” preference (LastPass Prefs > Notifications). This way, LastPass wont throw up an alert telling you that it can autofill a login form and it wont attempt to automatically fill a login form either. The only way that the form can be filled is by you explicitly telling the extension to do so, hopefully via a slightly obscure shortcut that someone couldn’t guess.

In light of this information, I’m going to reconsider using LastPass since it really is a fantastic service and cross platform compatibility is so useful to me. It would just seem that LastPass requires some tweaking in order to get its local security to levels which I feel comfortable with.

SymSteam

Sun, 05 Feb 2012 00:00:00 +0000

I’ve just released a new project on GitHub. It’s called SymSteam and it’s for anybody who likes to play Steam games on their MacBook Air (or any other Mac for that matter). MacBook Airs are reasonably powerful machines, not gaming machines but with the Intel HD graphics inside of them they can handle many of the games on OS X without too much difficulty. The problem is, games are big and SSDs are small. The baseline MacBook Air only has a 64GB SSD and, while the top of the line model has a 256GB SSD, that still isn’t a lot of space for your games once you’ve got all of your other stuff on there too. The solution to this storage problem that most people use is to put their games on an external hard drive and create a symbolic link to them where Steam would expect to find them. This way, you can play games off of your external hard drive when you’ve got the hard drive with you. And there’s the problem, it’s sort of an all or nothing solution. You can either sacrifice some portability, convenience and speed and have all of your games on an external hard drive or you can have your games on an internal hard drive, just not that many. What if you want to play a quick game of Plants vs Zombies while you’re out but don’t have your hard drive with you? That’s not a huge game, it’d only take up maybe 100MB on your hard drive. That game would be fine on your internal hard drive but if you choose to put all your games on an external hard drive you won’t be able to play it off of your internal drive without doing a bit of messing around with folders. This is where SymSteam comes in.

Enter SymSteam

SymSteam runs in the background. It doesn’t have a dock icon or a menu bar icon. It doesn’t have any windows apart from a setup window. It’s not going to get in your way. SymSteam watches for when you plug in a USB storage device. It then scans said device to see if it can find a SteamApps folder. If it doesn’t, nothing happens. If it does though, it will configure your Steam folder so that Steam will load games off of the device you just plugged in. Unplug the device and you’re playing games off of your internal hard drive. It’s seamless, when it works.

SymSteam is really immature at the moment. It works, but only just. I’m running it on my system because it’s handy and I’ll continue to work on it for now. Currently, I want to get some sort of preferences window and Growl notifications implemented. There’s also a lot of bugs that need fixing.

If you’re a developer, or want the latest, cutting edge build, you can get SymSteam from its GitHub repository here.

If you’re just interested in downloading a ready to use, reasonably/partly/just about stable version, get version 0.1 from here.