The New Macbook Pros

As someone who was forced to pick a new laptop about two weeks ago, i.e. just before the new Macbook Pros were announced, I have to confess that I’m a little pleased that the new machines don’t blow my current machine away. But, for all the pissing and moaning on the interwebs about Apple’s underwhelming new laptops, people seem to forget that PC performance has pretty much stagnated for the last eight years.

My 2012 Mac Pro (which was, effectively, a 2009 Mac Pro) still seems perfectly decent compared to the latest and greatest, and if I gave a damn it could be upgraded to give the 2013 Mac Pros a run for the money (in CPU benchmarks at any rate, the 2013 Mac Pros have stunning throughput).

The problem here is that CPU speed has hit a wall, pixel counts have gotten ludicrous (so that people are complaining about game performance on 4K displays), the benefits of GPUs for everyday computing haven’t really materialized, and 8GB of RAM is probably still plenty for most people’s daily use, and 16GB is ample.

Still, what happened last time Apple was forced to release an underwhelming upgrade after a long pause? The Intel transition. So, I’m willing to bet that the “let’s switch Mac OS  — oops macOS — over to our ARM architecture” faction within Apple is now winning a lot of arguments it was losing two years ago. (I suspect that the Macbook is the form factor of the first ARM-based macOS device.)

We’ll see — my predictions are often correct but wildly premature.

What does a good API look like?

I’m temporarily unemployed — my longest period of not having to work every day since I was laid off by Valuclick in 2010 — so I’m catching up on my rants. This rant is shaped by recent experiences I had during my recent job interview process (I was interviewed by two Famous Silicon Valley Companies, one of which hired me and the other of which “didn’t think I was a good fit”). Oddly enough, the company that hired me interviewed me in an API-agnostic (indeed almost language-agnostic) way while the company that didn’t interviewed me in terms of my familiarity with an API created by the other company (which they apparently are using religiously; although maybe not so much following recent layoffs).

Anyway, the API in question is very much in vogue in the Javascript / Web Front End world, in much the same way as CoffeeScript and Angular were a couple of years ago. (Indeed, the same bunch of people who were switching over to Angular a few years back have recently been switching over to this API, which is funny to watch). And this API and the API it has replaced in terms of mindshare is in large part concerned with a very common problem in UI programming.

A Very Common Problem in UI Programming

Probably the single most common problem in UI programming is synchronizing data with the user interface, or “binding”. There are three fundamental things almost any user-facing program has to do:

  • Populate the UI with data you have when (or, better, before) the UI first appears on screen
  • Keep the UI updated with data changed elsewhere (e.g. data that changes over time)
  • Update the data with changes made by the user

This stuff needs to be done, it’s boring to do, it often gets churned a lot (there are constant changes made to a UI and the data it needs to sync with in the course of any real project). So it’s nice if this stuff isn’t a total pain to do. Even better if it’s pretty much automatic for simple cases.

The Javascript API in question addresses a conspicuous failing of Javascript given its role as “the language of the web”. In fact almost everything good and bad about it stems from its addressing this issue. What’s this issue? It’s the difficulty of dealing with HTML text. If you look at Perl, PHP, and JSP, the three big old server-side web-programming languages, each handles this particular issue very well. The way I used to look at it was:

  • A perl script tends to look like a bunch of code with snippets of HTML embedded in it.
  • A PHP script tends to look like a web page with snippets of code embedded in it.
  • A JSP script tends to look like a web page with horrible custom tags and/or snippets of code embedded in it.

If you’re trying to solve a simple problem like get data from your database and stick it in your dynamic web page, you end up writing that web page the way you normally would (as bog standard HTML) and just putting a little something where you want your data to be and maybe some supporting code elsewhere. E.g. in PHP you might write “<p>{$myDate}</p>” while in  JSP you’d write something like “<p><%= myDate %></p>”. These all look similar, do similar things, and make sense.

It’s perfectly possible to defy these natural tendencies, e.g. write a page that has little or no HTML in it and just looks like a code file, but this is pretty much how many projects start out.

Javascript, in comparison, is horrible at dealing with HTML. You either end up building strings manually “<p>” + myDate + “</p>” which gets old fast for anything non-trivial, or you manipulate the DOM directly, either through the browser’s APIs, having first added metadata to your existing HTML, e.g. you’d change “<p></p>” to “<p id=”myDate”></p>” and then write “document.getElementById(‘myDate’).text = myDate;” in a script tag somewhere else.

The common solution to this issue is to use a template language implemented in Javascript (there are approximately 1.7 bazillion of them, as there is of anything involving Javascript) which allow you to write something like “<p>{{myDate}}</p>” and then do something like “Populate(slabOfHtml, {myDate: myDate});” in the simplest case (cue discussion about code injection). The net effect is you’re writing non-standard HTML and using a possibly obscure and flawed library to manipulate markup written in this non-standard HTML (…code injection). You may also be paying a huge performance penalty because depending on how things work, updating the page may involve regenerating its HTML and getting the browser to parse it again, which can suck — especially with huge tables (or, worse, huge slabs of highly styled DIVs pretending to be tables). OTOH you can use lots of jQuery to populate your DOM-with-metadata fairly efficiently, but this tends to be even worse for large updates.

The API in question solves this problem by uniting non-standard HTML and non-standard Javascript in a single new language that’s essentially a mashup of XML and Javascript that compiles into pure Javascript and [re]builds the DOM from HTML efficiently and in a fine-grained manner. So now you kind of need to learn a new language and an unfamiliar API.

My final interview with the company that did not hire me involved doing a “take home exam” where I was asked to solve a fairly open-ended problem using this API, for which I had to actually learn this API. The problem essentially involved: getting data from a server, displaying a table of data, allowing the user to see detail on a row item, and allowing the user to page through the table.

Having written a solution using this unfamiliar API, it seemed very verbose and clumsy, so I tried to figure out what I’d done wrong. I tried to figure out what the idiomatic way to do things using this API was and refine them. Having spent a lot of spare time on this exercise (and I was more-than-fully-employed at the time) it struck me that the effort I was spending to learn the API, and to hone my implementation, were far greater than the effort required to implement the same solution using an API I had written myself. So, for fun, I did that too.

Obviously, I had much less trouble using my API. Obviously, I had fewer bugs. Obviously I had no issues writing idiomatic code.

But, here’s the thing. Writing idiomatic code wasn’t actually making my original code shorter or more obvious. It was just more idiomatic.

To bind an arbitary data object to the DOM with my API, the code you write looks like this:


The complex case looks like this:

$(<some-selector>).bindomatic(<data-object>, <options-object>);

Assuming you’re familiar with the idioms of jQuery, there’s nothing new to learn here. The HTML you bind to needs to be marked up with metadata in a totally standard way (intended to make immediate sense even to people who’ve never seen my code before), e.g. to bind myDate to a particular paragraph you might write: “<p data-source=”.myDate”></p>”. If you wanted to make the date editable by the user and synced to the original data object, you would write: “<input data-bind=”.myDate”>”. The only complaints I’ve had about my API are about the “.” part (and I somewhat regret it). Actually the syntax is data-source=”myData.myDate” where “myData” is simply an arbitrary word used to refer to the original bound object. I had some thoughts of actually directly binding to the object by name, somehow, when I wrote the API, but Javascript doesn’t make that easy.

In case you’re wondering, the metadata for binding tabular data looks like this: “<tr data-repeat=”.someTable”><td data-source=”.someField”></td></tr>”.

My code was leaner, far simpler, to my mind far more “obvious”, and ran faster than the code using this other, famous and voguish, API. There’s also no question my API is far simpler. Oh, and also, my library solves all three of the stated problems — you do have to tell it if you have changes in your object that need to be synced to the UI — (without polluting the source object with new fields, methods, etc.) while this other library — not-so-much.

So — having concluded that a programming job that entailed working every day with the second API would be very annoying — I submitted both my “correct” solution and the simpler, faster, leaner solution to the second company and there you go. I could have been laid off by now!

Here’s my idea of what a good API looks like

  • It should be focused on doing one thing and one thing well.
  • It should only require that the programmer tell it something it can’t figure out for itself and hasn’t been told before.
  • It should be obvious (or as obvious as possible) how it works.
  • It should have sensible defaults
  • It should make simple things ridiculously easy, and complex things possible (in other words, its simplicity shouldn’t handcuff a programmer who wants to fine-tune performance, UX, and so on.

XCode and Swift

I don’t know if the binding mechanisms in Interface Builder seemed awesome back in 1989, but today — with all the improvements in both Interface Builder and the replacement of Objective-C with the (potentially) far cleaner Swift — they seem positively medieval to me, combining the worst aspects of automatic-code-generation “magic” and telling the left hand what the left hand is doing.

Let’s go back to the example of sticking myDate into a the UI somewhere. IB doesn’t really have “paragraphs” (unless you embed HTML) so let’s stick it in a label. Supposing you have a layout created in IB, the way you’re taught — as a newb — to do it this is:

  1. In XCode, drag from your label in IB to the view controller source code (oh, step 0 is to make sure both relevant things are visible)
  2. You’ll be asked to name the “outlet”, and then XCode will automagically write this code: @IBOutlet weak var myDate: UILabel!
  3. Now, in — say — the already-written-for-you viewDidLoad method of the controller you can write something like: myDate.text = _myDate (it can’t be myDate because you’re used myDate to hold the outlet reference).

Congratulations, you have now solved one of the three problems. That’s two lines of code, one generated by magic, the other containing no useful information, that you’ve written to get one piece of data from your controller to your view.

Incidentally, let’s suppose I wanted to change the outlet name from “myDate” to “dateLabel”. How do I do that? Well, you can delete the outlet and create a new outlet from scratch using the above process, and then change the code referencing the outlet. Is there another way? Not that I know of.

And how to we solve the other two problems?

Let’s suppose we’d in fact bound to an input field. So now my outlet looks like this: @IBOutlet weak var myDate: UITextField! (the “!” is semantically significant, not me getting excited).

  1. In XCode, drag from the field in IB to the view controller source code.
  2. Now, instead of creating an outlet, you select Action, and you make sure the type is UITextField, and change the event to ValueChanged.
  3. In the automatically-just-written-for-you Action code add the code _myDate = sender.text!

You’re now solved the last of the three problems. You’ve had a function written for you automagically, and you’ve written one line of retarded code. That’s three more lines of code (and one new function) to support your single field. And that’s two different things that require messing with the UI during a refactor or if a property name gets changed.

OK, what about the middle problem? That’s essentially a case of refactoring the original code so that you can call it whenever you like. So, for example, you write a showData method, call it from viewDidLoad, and then call it when you have new data.

Now, this is all pretty ugly in basic Javascript too. (And it was even uglier until browsers added documentQuerySelector.) The point is that it’s possible to make it very clean. How to do this in Swift / XCode?

Javascript may not have invented the hash as a fundamental data type, but it certainly popularized it. Swift, like most recent languages, provides dictionaries as a basic type. Dictionaries are God’s gift to people writing binding libraries. That said, Swift’s dictionaries are strongly typed which leads to a lot of teeth gnashing.

Our goal is to be able to write something like:


It would be even cooler to be able to round-trip JSON (the way my Javascript binding library can). So if this works we can probably integrate a decent JSON library.

So the things we need are:

  • Key-value-pair data storage, i.e. dictionaries — check!
  • The ability to add some kind of metadata to the UI
  • The ability to find stuff in the UI using this metadata

This doesn’t seem too intimidating until you consider some of the difficulty involved in binding data to IB.


The way tables are implemented in Cocoa is actually pretty awesome. In essence, Cocoa tables (think lists, for now) are generated minimally and managed efficiently by the following mechanism:

The minimum number of rows is generated to fill the available space.

When the user scrolls the table, new rows are created as necessary, and old rows disposed of. But, to make it even more efficient rather than disposing of unused rows, they are kept in a pool and reallocated as needed — so the row that scrolls off the top as you scroll down is reused to draw the row that just scrolled into view. (It’s more complex and clever than this — e.g. rows can be of different types, and each type is pooled separately — but that’s the gist.) This may seem like overkill when you’re trying to stick ten things in a list, but it’s ridiculously awesome when you’re trying to display a list of 30,000 songs on your first generation iPhone.

In order for this to work, there’s a tableDelegate protocol. The minimal implementation of this is that you need to tell the table how many rows of data you have and populate a row when you’re asked to.

So, for each table you’re dealing with you need to provide a delegate that knows what’s supposed to go in that specific table. Ideally, I just want to do something like self.bind(data) in the viewDidLoad method, how do I create and hook up the necessary delegates? It’s even worse if I want to use something like RootViewController (e.g. for a paged display) which is fiddly to set up even manually. But, given how horrible all this stuff is to deal with in vanilla Swift/Cocoa, that’s just how awesome it will be not to have to do any of it ever again if I can do this. Not only that, but to implement this I’m going to need to understand the ugly stuff really well.


Adding Metadata to IB Objects

The first problem is figuring out some convenient way of attaching metadata to IB elements (e.g. buttons, text fields, and so on). After a lot of spelunking, I concluded that my first thought (to use the accessibilityIdentifier field) turns out to be the most practical (even though, as we shall see, it has issues).

There are oodles of different, promising-looking fields associated with elements in IB, e.g. you can set a label (which appears in the view hierarchy, making the control easy to find). This would be perfect, but as far as I could tell it isn’t actually accessible at runtime. There’s also User Defined Runtime Attributes which are a bit fiddly to add and edit, but worse, as far as I’ve been able to tell, safely accessing them is a pain in the ass (i.e. if you simply ask for a property by name and it’s not there — crash!). So, unless I get a clue, no cigar for now.

The nice thing about the accessibilityIdentifier is that it looks like it’s OK for it to be non-unique (so you can bind the same value to more than one place) and it can be directly edited (you don’t need to create a property, and then set its name, set its type as you do for User Defined Runtime Attributes). The downside is that some things — UITableViews in particular — don’t have them. (Also, presumably, they have an impact on accessibility, but it seems to me like that shouldn’t be a problem if you use sensible names.)

So my first cut of automatic binding for Swift/Cocoa took a couple of hours and handled UITextField and UILabel.

class Bindery: NSObject {
    var view: UIView!
    var data: [String: AnyObject?]!
    init(view v:UIView, data dict:[String: AnyObject?]){
        view = v
        data = dict
    func subviews(name: String) -> [UIView] {
        var found: [UIView] = []
        for v in view!.subviews {
            if v.accessibilityIdentifier == name {
        return found
    @IBAction func valueChanged(sender: AnyObject?){
        var key: String? = nil
        if sender is UIView {
            key = sender!.accessibilityIdentifier
            if !data.keys.contains(key!) {
        if sender is UITextField {
            let field = sender as? UITextField
            data[key!] = field!.text
    func updateKey(key: String){
        let views = subviews(key)
        let value = data[key]
        for v in views {
            if v is UILabel {
                let label = v as? UILabel
                label!.text = value! is String ? value as! String : ""
            else if v is UITextField {
                let field = v as? UITextField
                field!.text = value! is String ? value as! String : ""
                field!.addTarget(self, action: "valueChanged:", forControlEvents: .EditingDidEnd)
    func update() -> Bindery {
        for key in (data?.keys)! {
        return self

Usage is pretty close to my ideal with one complication (this code is inside the view controller):

    var binder: Bindery
    var data:[String: AnyObject?] = [
        "name": "Anne Example",
        "sex": "female"

    override func viewDidLoad() {
        // Do any additional setup after loading the view, typically from a nib.
        binder = Bindery(view:self.view, data: data).update()

If you look closely, I have to call update() from the new Bindery instance to make things work. This is because Swift doesn’t let me refer to self inside an initializer (I assume this is designed to avoid possible issues with computed properties, or to encourage programmers to not put heavy lifting in the main thread… or something). Anyway it’s not exactly terrible (and I could paper over the issue by adding a class convenience method).

OK, so what about tables?

Well I figure tables will need their own special binding class (which I shockingly call TableBindery) and implement it so that you need to use an outlet (or some other hard reference to the table) and then I use Bindery to populate each cell (this lets you create a cell prototype visually and then bind to it with almost no work). This is how that ends up looking like this (I won’t bore you with the implementation which is pretty straightforward once I worked out that a table cell has a child view that contains all of its contents, and how to convert a [String: String] into a [String: AnyObject?]):

    var data:[String: AnyObject?] = [
        "name": "Anne Example",
        "sex": "female"
    override func viewDidLoad() {
        tableBinder = TableBindery(table:table, array: tableData).update()

In the course of getting this working, I discover that the prototype cells do have an accessibilityIdentifier, so it might well be possible to spelunk the table at runtime and identify bindings by using the attributes of the table’s children. The fact is, though, that tables — especially the sophisticated multi-section tables that Cocoa allows — probably need to be handled a little more manually than HTML tables usually do, and having to write a line or two of code to populate a table is not too bad.

Now imagine if Bindery supported all the common controls, provided a protocol for allowing custom controls to be bound, and then imagine an analog of TableBindery for handling Root view controllers. This doesn’t actually look like a particularly huge undertaking, and I already feel much more confident dealing with Cocoa’s nasty underbelly than I was this morning.

And, finally, if I really wanted to provide a self.bindData convenience function — Swift and Cocoa make this very easy. I’d simply extend UIView.

Affinity Photo — First Impressions

Affinity Photo in action

Note: if you’re interested in using Affinity Photo for processing RAW photos (i.e. its “non-destructive workflow”) you’re probably going to be horribly disappointed. See my followup article.

Affinity Photo has just come out of beta and is being sold for a discounted price of $40 (its regular price will be $50). As with Affinity Designer, it’s well-presented, with an attractive icon and a dark interface that is reminiscent of late model Adobe Creative Cloud and Apple Pro software. So, where does it fit in the pantheon of would-be Photoshop alternatives?

In terms of core functionality, it appears to fit in above Acorn and below Photoline. In particular, Photoline supports HDR as well as 16-bit and LAB color, while Affinity Photo lacks support for HDR editing. Unless you work with HDR (and clearly not many people do) then Affinity Designer is both less expensive than Photoline, and far more polished in terms of the features it does support.

Affinity Designer supports non-destructive import of RAW files. When you open a RAW file you enter “Develop” mode where you can perform adjustments to exposure, curves, noise, and so forth on the RAW data before it gets converted to 8- or 16-bit RGB. Once you leave Develop mode, you can return and second-guess your adjustments (on a layer-by-layer basis). This alone is worth the price of admission, and leaves Acorn, Pixelmator, and Photoline in the dust.

In essence you get the non-destructive workflow of Lightroom and the pixel-manipulation capabilities of Photoshop in a single package, with the ability to move from one to the other at any point in your workflow. Let me repeat that — you can “develop” your raw, go mess with pixels in the resulting image, then go back and second-guess your “develop” settings (while retaining your pixel-level manipulations) and so on.

This feature isn’t quite perfect. E.g. you can’t go back and second-guess a crop, and vector layer operations, such as text overlays, get reduced to a “pixel” layer if you go back to develop mode. But it’s a big step in the right direction and for a lot of purposes it’s just dandy.

This is just my first impressions, but there are some things that could be better.

Affinity Photo provides adjustment layers, live filter layers, filters, and layer effects — in many cases providing multiple versions of the same filter in different places. Aside from having functionality scattered and in arbitrary buckets, you get several different user interfaces. This is a mess, and it is a direct result of copying Photoshop’s crazy UI (accumulated over decades of accumulated functionality) rather than having a consolidated, unified approach the way Acorn does.

At first I thought Affinity Photo didn’t support layer styles, but it does. Unfortunately you can’t simply copy and paste layer styles (the way you can in Photoshop and Acorn), so the workflow is a bit more convoluted (you need to create a style from a selection and then apply it elsewhere — often you just want to copy a style from A to B without creating a reusable (or linked) style so this is a bit unfortunate).

I really like the fact that the RGB histogram gives a quick “approximate” view but shows a little warning symbol on it. When you click it, it does a per-pixel histogram (quite quickly, at least on my 24MP images).

I don’t see any support for stitching images, so if that’s important to you (and it’s certainly very important to landscape photographers) then you’ll need to stick with Adobe, or specialized plugins or software.

It also seems to lack smart resize and smart delete or Photoshop’s new motion blur removal functions. (Photoline also does smart delete and smart resize.)

Anyway, it’s a great first release, and definitely fulfills the promise of the public betas. It seems to me that it’s a more solid overall effort than Affinity Designer was when first released, and I’m probably a more demanding user of Photoshop-like programs than I am of Illustrator-like programs. I can understand the desire to provide a user interface familiar to Adobe products even at the cost of making them unnecessarily confusing and poorly organized, but I hope that sanity prevails in the long run.

Bottom line: a more complete and attractive package than either Photoline or Acorn (its most credible competitors) and better in some ways than Photoshop.

The Race to Replace Illustrator: Affinity Designer

Just as Core Graphics created a race to replace Photoshop (at least for the great unwashed masses who don’t care about Color Spaces, CMYK, Lab Color, HDR, Stitching, Content-Aware Resizing and Deletion, seamless integration with other Adobe software, and so forth) there is now a race to replace Illustrator. Part of the problem is that the bewildering range of screen densities has made working primarily with bitmaps essentially a mug’s game (even Apple-targeted designers, used to supporting two resolutions, are suddenly faced with four (one of which is seriously weird).

You may recall some old stalwarts, such as Inkscape, Intaglio Designer, iDraw, Artboard, ZeusDraw, EasyDraw — of which I like iDraw — and Sketch; some of these are pretty credible Illustrator replacements (at least for casual users) but there are even more entrants in the field now, and they’re even more interesting:

Sketch 3 is the new version of Sketch — the vector-based, UI-focused drawing tool. It adds user interface refinements, symbols (“instances”), scripting via Javascript, automatic detection of colors used in a layout, and streamlined export functions. The fact that most of the new features are focused on workflow shows that BohemianCoding has been listening to professional users. I’ve not bought Sketch 3 yet because I’m a bit miffed that there’s no upgrade path for Sketch 2 owners (for which Apple is at least partially responsible) and — worse — that they pulled Sketch 2 from the App Store so I can’t conveniently reinstall the old version on my computers. Again, that might be Apple’s fault (i.e. perhaps they can’t set things up so that existing owners could continue to download and install it while taking it off the market).

Let me pause here to say this: I freaking love Sketch (2). I probably use it more than any other non-3d graphics program (I use it in preference to iDraw these days). I probably use it more than all other non-3d graphics software put together. Sketch is my go-to app for UI graphics and textures for (cartoony) 3d models.

Paintcode and Webcode are, like Sketch, focused on user interface design. The big difference between these tools and predecessors is that they’re focused on outputing your graphics as code that will recreate them at arbitrary resolutions (Paintcode will output Objective-C, Swift, or C# Xamarin, while Webcode will output SVG, Javascript (Canvas), and HTML+CSS. I’ve got a Paintcode 1.x license which seemed a bit limited (Paintcode 2 has beefed up its import and export functionality, as well as adding Swift support). Of the two, Webcode actually looks more compelling to me than Paintcode (and it doesn’t hurt that it’s much cheaper) — I’d probably pony up for Paintcode if it offered all of Webcode’s functionality, but it appears not to.

Finally, Affinity Designer comes from Serif, a company dedicated to competing with Adobe at the low-end in the Windows market, switching over to the Mac-only market with a bang. Their plan is to start with an Illustrator-killer, then proceed with Affinity Photo and Affinity Publisher. (Publisher? Really? Do they want to take on Pages and InDesign at once because that seems to me to be a losing proposition.) Of the three, Affinity Designer is clearly the most Illustrator-like, while Sketch 3 is kind of an Illustrator/Fireworks hybrid, and Paintcode/Webcode are simply unique.

iDraw is my current benchmark for wannabe Illustrator-replacements.
iDraw is my current benchmark for wannabe Illustrator-replacements.

Affinity Designer

I played with Affinity Designer briefly during the free beta, but it didn’t leave me with a strong impression. When they announced its release, I ponied up the (discounted) $40 (iDraw, my current favorite, is $25, but there’s been no significant improvements to it over the last year, and the things that annoy me about it still annoy me). The first thing I noticed when I launched Affinity Designer is that — like Illustrator — it defaults to print usage (CMYK, paper-oriented layout). It’s nice to discover that it also has web- and device-centric settings and defaults, and @2x retina support out of the box (but unlike Paintcode it hasn’t figured out what to do about the iPhone 6/Plus).

Screen Shot 2014-10-06 at 11.26.51 AM
I imported the SVG from iDraw into Affinity Designer. Everything looks great (and it even preserved layers) except for the fonts (which unfortunately are not easily fixed).

The first thing I did was take a pretty damn complicated SVG file (with layers and typography) and export it from iDraw and import it into Affinity Designer. Every font failed to import correctly (Helvetica Bold and DIN Condensed), but otherwise it seemed to do a pretty good job — overall, it did a better job than Sketch (2) at importing the same file. I think the problem lies with how SVG stores font information (Sketch had the same issue when importing the file; note that iDraw can import its own SVGs flawlessly.)

But here’s where things get ugly — when I tried to fix the font issues, I discovered that I can’t change the character style settings for more than one object at a time. (And this is not a problem in Sketch or iDraw.) As a workaround, I tried to create a style from one object and apply it to others but that didn’t work at all — styles seem to be limited to fill color and the like (and fill color doesn’t seem to be the same thing as text color). Bad start.

Time to look at the program in its own terms. One of the best things about Sketch relative to iDraw is its support for gaussian blur as a style. Affinity Designer has this and more (e.g. emboss, and a weird “3D” effect that I’m not sure what it’s supported to do). What it doesn’t do (and what Sketch and iDraw both do) is allow you to apply the same filters multiple times (e.g. much the same way you can stack box-shadow effects in CSS). Another annoyance with Affinity Designer’s effects is that important settings are buried in a modal dialog box (iDraw is annoying in a different way in that you need to disclose the settings with an extra double-click, but that’s a pretty minor annoyance). So far, I’d call this a mixed result.

Here’s an example of Affinity Designer at its worst. I draw a test bezier curve and then try to apply a stroke to it. So far so good. But it’s stroked in the center of the curve.

  • I almost always want to stroke inside the curve, and sometimes outside, but almost never centered on the curve. So I look at the stroke settings, and all that is exposed is color, opacity, and radius.
  • To access the extra properties I need to click on the little “gear” icon that lets you configure the other settings of a given filter.
  • As I’ve mentioned before, this dialog is modal; it also defaults to showing some random filter setting, not the one you were working on (which confused me a minute, since it was showing bevel/emboss options and not line options).
When I clicked the stroke "gear" I get deposited in a modal dialog with Bevel selected. WTF?
When I clicked the stroke “gear” I get deposited in a modal dialog with Bevel selected. WTF?


  • OK, so having switched over to the line settings, I discover that the options (inside, outside, centered) which — for some reason — is not the top setting (compositing mode is at the top).
To add injury to insult, the stroke settings don't actually work — note that I've chosen outside and it's displaying a centered stroke.
To add injury to insult, the stroke settings don’t actually work — note that I’ve chosen outside and it’s displaying a centered stroke.
  • Here’s the rub — the different options (a) don’t work and (b) appear to override and block the modeless setting (i.e. when I change radius in the modeless view, the setting no longer works. WTF?).
The basic selection / transformation affordances are nice.
The basic selection / transformation affordances are nice.

This is a freaking disaster. First of all, how can an Illustrator clone go out the door with broken strokes?

I do like the basic selection affordances. In particular rotation gets its own affordance (the little dot out on its own) rather than requiring mouse/keyboard chording. The basic Bezier drawing tools seem to be solid.

But there’s one more global observation I need to make before I move on: the tools all feel wrong. There’s a nuance to the rules that govern how 2d graphics tools, in drawing programs especially, behave. When they should be sticky vs. revert to a selection tool, and so forth. This stuff is so basic that it happens below the level of conscious decision-making. For better or (mostly) worse, a lot of us have Illustrator’s behavior in our muscle memory (where it displayed MacDraw, which was generally more intuitive).

In any event, just as iDraw and Sketch and many other Mac graphics programs get this somehow right, Affinity Designer gets this somehow wrong, and it bugs the hell out of me. If the program were in a more functional state, I might even spend the time to go figure out exactly what’s wrong and write some kind of detailed bug report for the development team, but I find the program, as a whole, to be so fractally unusable that I just can’t be bothered.

At this point, it’s not worth continuing the review. Affinity Designer is a promising and polished looking piece of software, but basic functionality is completely broken, and it has horrific workflow problems (styles don’t work with text formatting, you can’t edit multiple selections in a useful way, the wrong properties are disclosed in the modeless floater, and the modal dialog is both weird and buggy). So, in summary:

  • Some features that are lacking in iDraw (Gaussian Blur effect)
  • Single window UI (unlike iDraw which suffers from palette-itis)
  • Better SVG import than most rivals
  • Limited effects options (can’t apply multiple instances of a given effect to a single element)
  • Editing effects is clumsy (useful stuff is buried in modal dialog, which does not open on the right effect) and buggy (the settings don’t work properly).
  • Affinity Designer’s tools just feel wrong; they stick in modes when they shouldn’t (or I don’t expect them to) and it’s just infuriating.

Affinity Designer manages to be promising, attractive, and completely useless in its current form.

Note: I purchased Affinity Designer from the App Store after using the public beta a few times. I was so frustrated with the release version that I have requested a refund from Apple, and have deleted the app. (I think this is maybe the second time I have ever asked for an App purchase to be refunded.)

Dropbox vs. Box vs. HubiC

Edit: Brain Fart — I seem to have omitted about a paragraph of pertinent information.

I’ll assume you all know what Dropbox is. If you don’t, go get Dropbox now. It’s free and it’s awesome.

The only downside of Dropbox is that if you want more than the 2GB of storage you get for free, it gets more expensive, and the upper limit on how much you can store is (for practical purposes) quite low. Personally, I haven’t found either of these an issue — but thanks to my link on, I have a pretty huge “free” account. But it would be awesome to have something like Dropbox that was so big I could just stop managing what I keep on it altogether (of course, this is the problem with stuff that’s free — you waste it). has been around about as long as Dropbox (heck, it has an even better domain name, right?) but has been targeted at the enterprise. (their capitalization) I just found out about via Hacker News. It offers more free storage than Dropbox, but not quite as much as Box, and vastly cheaper paid plans, including about $140/year for 10TB. (I’m not sure how you can actually get 10TB into it, short of using a ZFS or Drobo style multi-disk volume.)

2GB vs 50GB vs 25GB

This is how much storage you get for free.

$100/year for 100GB vs. $10/month for 100GB vs. $13.60/year for 100GB (or $136/month for 10TB)

Edit: I’ve corrected the costs for HubiC.

This is how much it costs for more storage. Box gives you — by far — the most free storage but gets more expensive than Dropbox (while offering various enterprisey features). HubiC is insanely cheaper than both of them. By way of comparison, iCloud costs $20/year for 20GB, so in terms of dollars per unit storage, only HubiC is a better deal. In terms of useful features out of the box, Dropbox support is built into far more programs while iCloud offers useful functionality (notably over-the-air backups of devices and integration with Apple products) to Mac and iOS users that no other platform can (currently) match.

For Android users, the iCloud equivalent is Google Drive, which gives you 15GB free, and costs $60/year for 100GB, making it a bit cheaper (and less useful) than Dropbox.

Mac OS X Integration

All three programs appear as folders in your home directory by default, and stick shortcuts to themselves in Finder’s sidebar. Having installed HubiC and then Box after installing Dropbox, Box was very flaky when first installed. Its installer provided no feedback, and the first few times I tried to launch the application nothing seemed to happen, followed by weird broken delayed launches. Once I’d patiently killed a bunch of instances and started over it worked well.

Box and Dropbox have similar levels of Finder integration — they indicate the state of files and provide context menu items for sharing links. HubiC appears not to do anything like this, unfortunately.

All three applications provide status menus — those icons that appear in the menubar to the left of the Spotlight magnifying glass. I should note that HubiC’s icon looks like a shapeless blue blob — a blue cloud? — which is an anti-feature. The status menus of all three seem to be perfectly fine and offer decent functionality. Oddly enough, Box and Dropbox no longer keep you apprised of your usage level whereas HubiC does.

Box has one glaring defect — it won’t sync Mac OS X “bundles” (i.e. directories masquerading as files). I have no idea why — they’re just directories. It tells you to zip them up first (gee, how about doing it yourself?)

All three services offer support for all the usual platforms — although I can’t comment on how good any of them are (except the Dropbox client for iOS is decent, and all three work decently in a web browser, although HubiC’s in-browser account management is awful). I cannot yet comment on the security of Box or HubiC. Dropbox offers, and I use, two-factor authentication, and I’m pretty sure HubiC does not (but its website is pretty hard to navigate so maybe it’s there somewhere).


If you just want some free storage and don’t mind not being able to sync bundles then Box is a better deal than Dropbox and it’s probably quite robust given the money behind it. If you’re already using Dropbox and don’t need more storage, Box does not work as well so unless you want its enterprisey features (and you know who you are) you might as well stick with Dropbox. I can’t really comment on HubiC until I’ve exercised it by, saying syncing a buttload of RAW files to it (if I’m going to get more cloud storage, I want enough of it to not need more than one service). If you’re interested, HubiC is a damn good deal for free and it works side-by-side with the others. If it turns out to deliver the goods, I may well end up buying a 10TB plan and switching to it from Crashplan.