A Modest Usability Proposal: double tap keystrokes

As I painfully deleted the trailing part of a URL for perhaps the ten thousandth time in my life … heck, hundred-thousandth … it occurred to me that there ought to be a simple keystroke for deleting to the previous obvious separator. In text editors there are typically all kinds of shortcuts for doing things like extending a selection to the end of a word, or deleting a line, but these tend to be inconsistent between programs (and thus very hard to commit to muscle memory) and highly domain-specific. What I’d like is to be able to tap delete (on a Mac — i.e. backspace) twice quickly to delete to the next logical separator. In a word-processor this would be a space or punctuation mark, in a url this would be a ? or slash.

While double-clicking is a well-used convention in UIs these days, double-tapping keys is not used at all, despite the fact that holding down a key for repeating keystrokes (which was an electric typewriter convention) is pretty much gone — so it’s “unused real estate” in a sense. There are all kinds of obvious uses for double keystrokes. E.g. differentiating return (I want a new paragraph) with return (I’m done — often enter, but often not. E.g. in several Mac programs it’s command-return).

I’d only suggest double-tap be used carefully. E.g. overloading double-tap “o” would cause a lot of grief, e.g. when touch-typing “too”. Overloading double-tap return is dangerous unless the overload does what you expect it to (e.g. explicitly create a new paragraph in a word-processing context).

Well, it’s an idea. Now why did I log into WordPress?

How I learned to stop worrying and love Blender

Blender's complexity is necessary, but some of the difficulty getting to grips with it stems from gratuitously different design decisions or easily fixed mistakes.
Blender's complexity is necessary, but some of the difficulty getting to grips with it stems from gratuitously non-standard UI features or easily fixed foibles.

As my reader knows, I’ve something of a love/hate relationship with Blender. Or perhaps it’s more of a need/despise relationship. If there’s ever a feature I need in a 3d program but don’t have in my current favorite, the answer is always “well, Blender does it and it’s free” (unless the feature is motion blur — Blender’s motion blur sucks … or it did last time I tried to use it).

My favorite 3d tool for the past few years has been Cheetah 3d, which has many virtues, a few flaws, and a lot of missing features. I think it’s important to differentiate between a missing feature and a flaw, the latter being a feature that doesn’t work as well as it should, or isn’t as easy to use as it should be. Blender, measured in the same way, has many virtues, a spectacular number of flaws, and not many missing features (that I can think of).

It’s worth noting that for any given user, sometimes it’s better to have a flaw than a missing feature (if you need that feature, however flawed), while at other times it’s worse (e.g. if that flawed feature creates clutter or confusion and you didn’t need it anyway). Although after over fifteen years of 3d experience I thought myself a pretty advanced 3d artist, I still have a lot to learn, and Cheetah 3d’s simplicity has helped me learn some of it. But, over time, Cheetah 3d’s missing features have become an increasing sore point, while my continued grappling with Blender’s apparent flaws has led me to better understand its significant, but less apparent virtues.

The real problem with Blender, it turns out, is that it has a lot of hidden modes. Most powerful software has hidden modes, and understanding those hidden modes slowly turns the software from incomprehensible to amazing as you have “aha” moments. Sometimes the developers of great software will recognize a few or many of the moments necessary to help you on your way and explain them to you at the right time minimizing the time it takes for you to reach nirvana. Sometimes developers will leverage your understanding of existing software rather than [gratuitously] create new paradigms of their own. The fact that Blender has done neither doesn’t make the software bad, merely the process of grokking it unnecessarily unpleasant.

It’s full of modes!

Clicking this icon in the NLA window toggles between Action and NLA mode
Clicking this icon in the NLA window toggles between Action and NLA mode. Which mode you're in is not apparent aside from this.

A lot of software today tends to be virtually modeless when used for common purposes. Modes were recognized as a bad thing in user interface design when Apple produced the original Human Interface Guidelines for the Mac.

Even so, the early Mac programs were very modal. For example, if you pressed command-F in MacWrite a “Find Dialog” appeared which was modal. You couldn’t, for example, select some text in the underlying document and paste it into the text field. If you were “finding” stuff and saw a typo you had to leave “Find Mode” to correct it, and then resume “Find Mode”. In MacPaint when you zoomed in you were in “fat bits” mode and the only tools you could use were the pencil and eraser. Much of the complexity in modern software has resulted from eliminating modes — in essence making all things possible all the time.

It’s not acceptable for a modern word processor not to offer all its formatting functionality in headers and footers when, once upon a time, you essentially entered a crippled mini word-processor to modify your header or footer.

The worst kinds of modes are hidden or implicit modes — i.e. modes you can be in without being able to tell. A classic example of such a mode is selecting stuff in Photoshop. If you “make a selection” that’s all you’re doing — making a selection. You aren’t actually selecting anything. If you then “lift” part of the underlying image (i.e. selecting that part of the layer underneath your selection) the user interface doesn’t change even though you’re now in a different mode. Understanding this odd behavior was, for me, the big aha moment in learning to use Barneyscan Photoshop. Before I figured that out, Photoshop just seemed perversely difficult to use.

And, in fact, Photoshop is perversely difficult to use. MacPaint didn’t do things the way Photoshop did, and Deluxe Paint (and later Studio/8 and Studio/32) managed to extend MacPaint’s abilities without breaking MacPaint’s paradigm to the extent that they allowed you to do everything Photoshop managed with its “selections as entities in and of themselves” without requiring users to unlearn their existing habits. No-one cares any more because every graphics pro knows Photoshop and has committed all the shortcuts for manipulating selections to muscle memory, but it’s easy to forget how perverse Photoshop seemed to people who knew how to use other graphics programs back in 1990.

Blender Revealed

To my mind, figuring out Blender requires at least two major realizations. Perhaps by documenting them I may help someone else “get over the hump” faster than I have.

The first realization is that Blender is built around the concept of a 3d cursor. You need to learn how to work with the cursor. (Shift-C snaps the cursor back to the origin, and learn to use the Shift-S menu — it’s wonderful.) The 3d cursor is a very powerful concept — analogous to a text cursor — but other 3d programs make do without such a concept, so realizing that Blender has this concept and is to a considerable extent built around it is analogous to understanding Photoshop’s concept of a selection as an entity of itself — once you realize that Photoshop is all about selections and learn how to work with them everything becomes second nature.

Aside: one thing I tried early with Blender was switching its mouse behavior over so that left-click selects and right-click sets the cursor. Unfortunately, Blender becomes somewhat broken with this option. In my opinion Blender would be a much easier program to use (and master) if left-click selected, and if — indeed — major thought were put into making more common actions left-clicks and less common actions right-clicks. This may be addressed (at least by preferences) in 2.50, but don’t hold your breath.

The second realization is that Blender is full of modes, that most of these modes are hidden, some modes stick to specific objects while others affect the entire program, and that in some cases which mode you can enter is itself a modality. This isn’t as easy to wrap in a nutshell — but it’s probably helpful to know that if Blender is acting in a weird or apparently unpredictable way, you’ve probably managed to trip over a hidden mode.

Blender is difficult, but most of that difficulty is necessary

When I say Blender is full of modes, these are modes in every sense — menus change, the way things are displayed changes, what you can select and do changes, etc. etc. etc.

And when I say hidden, I mean that how the user interface behaves can be completely changed by a setting on a panel you can’t see, or by the mode you previously got into when you had something else selected.

Here’s a particularly hairy example: there are two distinct animation modes in Blender, “Actions” and “NLA” (Non-Linear Animation).

The idea is that you animate a figure’s basic reusable behaviors (e.g. walking, jumping, waving) as individual “Actions” and then you build longer animations using the NLA window which treats actions as layers (much like video layers in After Effects or Final Cut Pro).

Whether you’re in NLA mode (where what you see happening and what you are modifying is happening in the non-linear animation context) or Action mode (where what you see and do affect a specific action) is not necessarily visible or apparent at any time. Oh, and, each action you’ve created is, itself, a different mode (and which you’re in is not apparent unless you happen to have the right display visible and the right hierarchy disclosed and scrolled into view).

Now, let’s suppose you’re editing vertex weights in the course of “rigging” a model.

What does this mean? Well, you’re trying to choose how the vertices in a mesh are affected by the movement of the bones in its animation rig — a virtual “skeleton” made of “bones”; the model is the mesh, the rig is the skeleton, and to say a model is rigged is essentially to say that it has had a skeleton built for it and has been attached to that skeleton using vertex weights).

Sounds pretty complicated, right? Well it is, and so it’s kind of stupid to expect the user interface for this to be simple or particularly straightforward. I think it’s fair to say that no similarly conceptually complex task is explicitly supported in, say, Photoshop or Word or Excel, each of which has a pretty complex user interface in its own right.

The usual way of showing bone weights is to show a “heat map” indicating how tightly bound vertices in a mesh are to a given (selected) bone. This is how the mind-bogglingly complex Blender does it. This is how the beautifully simple Cheetah 3d does it. But in Blender, to select a bone you … select the bone. In other words, you right-click (because selection is done by right-clicking) on the bone and voila. Pretty neat, huh? In Cheetah 3d you look for the skeleton deformer modifier tag in the hierarchy view, click on it, and then find the bone in a scrolling list in the properties browser.

Now, in Blender it’s important to make sure that the armature (or “skeleton” of the model you’re working on is in “Pose mode” — armatures can be in one of three modes) and then select the mesh and set it to “Weight Paint Mode”. If the armature is in the wrong mode, the mesh won’t be posted while you’re finessing vertex weights, which means you won’t be able to see whether what you’re doing is working. Also, you may not be able to directly select the bones you’re interested in. This is all horribly complex, involves hidden modes, and is utterly counter-intuitive. But the benefits (you can paint weights on a posed model and see the changes in real time, and you can select bones directly) are absolutely huge.

[ Javascript required to view QuickTime movie, please turn it on and refresh this page ]


My first successful character animation in Blender. (Rendered in Cheetah 3d.) Getting there was much harder than in Cheetah 3d, but I can actually reuse and make tweaks to the rigging and the animation itself which are impossible or very difficult in Cheetah 3d. Flaws vs. Missing Features.

Eating My Own Words?

I’ve ridiculed Blender’s lack of usability in the past, and probably will in the future. Even some of my praise for Blender in this post probably seems close to ridicule. It’s a ridiculously — and often unnecessarily — difficult program to get into. Almost all of my complaints (and then some) are as true now as ever. There are so many simple things that could easily be fixed in Blender to make it easier for new users that it’s not even funny. The same was true for Photoshop when it came out, and — over time — Adobe changed some things to be less non-standard while others eventually asserted their dominance. Even today I’m pretty sure any Deluxe Paint or Studio/32 thinks that the keyboard shortcuts for Photoshop are idiotic compared to those for their cherished bitmap editors. I know I do.

The fact is that Blender is an incredibly capable, rock-solid piece of software (I can’t remember when it last crashed on me). Its user interface foibles are stupid and ugly, but you can get past them, and in the great scheme of things it’s certainly worth never having to pay for another 3D Studio Max upgrade or figure out how to replace that burned out ElectricImage dongle.

Who knows? Maybe in five years I’ll be writing a similar article about my newfound love of GIMP.

Addendum: Blender Hints

Simple things that may make Blender easier to use.

  1. Oddly enough Preferences are accessed by “dragging down the menu bar”. WTF? Well, that’s how it works.
  2. Having opened up preferences, you probably want to go to Edit Methods and go to Add new objects: (on the left) and turn off Switch to Edit Mode and Aligned to View which may be on by default (because they used not to be options). Aligning new objects to your view is hardly ever what you want, and many users have the shortcut for (a) switching out of edit mode, (b) clearing a newly created object’s rotation, and (optionally) (c) returning to edit mode burned into muscle memory.
  3. You’ll also probably want to change your default directories to minimize the amount of navigation you have to do in Blender’s (horrible) file requester.
  4. Once you’ve learned how to create a nice setup in Blender you may want to build a good default scene and File > Save Default Settings.
  5. Often, especially when going through tutorials, there’ll be reference to a command that I just can’t locate in a menu. If the command has a hotkey you can find it using the Hotkey and Mouse Action Reference (Help menu) — which has a search command. Then you can at least find out the keyboard shortcut, even if you still won’t know where the heck to find it in the menus.
  6. The Essential Blender (book) is really very good, although it does contain quite a few errors (so if something just isn’t working, maybe the command’s name or the keyboard shortcut is incorrect).
  7. If a bunch of things suddenly disappear or become uneditable you may have inadvertently messed with the scene layer settings (which the standard number keys are shortcuts for, so it’s easy to do). If you don’t use layers deliberately the chances are pressing 1 (above the Q, not on the numeric keypad) will restore everything. If you do then you’ll already know how to deal with this.
  8. Armatures and bones have their own independent layer system, so be prepared for completely orthogonal confusion when working with rigs.
  9. In many cases, Blender reuses key commands in different contexts. E.g. G (grab) is used to move objects in 3d, keyframes in the Action editor, and action layers in the NLA window. N (transform properties) brings up a numeric transform floater in 3d views, and similarly useful floaters in (some) other views. A (select all/nothing) selects all or nothing where appropriate, in the hierarchy view it collapses/expands everything.
  10. It’s well worth learning “root” shortcuts which bring up menus. E.g. Shift-S (“snap”) brings up a menu — usually the next number you type selects the commands (in order) in that menu. In some cases (e.g. G and R) you can press X, Y, or Z to constrain your action to an axis.
  11. Keyboard commands in Blender apply to the panel the mouse is over, which can be very confusing (especially since each pane has its own menu bar and hence its own keyboard shortcuts).
  12. Selecting things is an action (which you can undo). Changing a view is not an action (and you can’t undo it) — unless you moved a camera.
  13. Blender’s camera controls are pretty annoying (absent?), but if you manipulate a camera object in a 3d view with the transform orientation set to “Normal”  or “Local” you can dolly the camera around in a relatively intuitive fashion. (If there’s a command to, for example, create a camera from a current user view, I haven’t found it. Shifty-F lets you fly a camera around, but when you leave Fly mode your camera is back where it started.) Edit: a reader notes that Ctrl + Alt + 0 snaps a selected camera to the current view, which is very handy.
  14. I use Blender on a (Mac) laptop quite a bit, so it’s worth knowing the view navigation controls for folks with no MMB (middle mouse button). Option-drag to orbit, option-shift drag to pan, and scroll-wheel (which Mac laptops do just great) zooms.
  15. Blender supports “virtual screens” internally — three complete viewport layouts (more if you want) that can be accessed via control-left and control-right. Very handy given how cluttered things can get.
  16. The render buffer (F11) can be zoomed and panned using the usual keyboard shortcuts. There are actually two render buffers (containing the current render and the previous render) and you can toggle between them with the J key (very useful for checking what effect that last tiny change had). Click and hold in a render view for an RGBA value.
  17. Note especially for Unity developers: the FBX exporter “bakes” subdiv modifiers (at “render” level) into meshes on export, so beware!
  18. And there’s a ridiculous number of useful tips and gotchas here.

Typing on the iPhone

Daringfireball posted this link today. It’s a challenge to type “the quick brown fox jumps over the lazy dog” while riding shotgun in a rally car going full tilt, using either an iPhone or an ASUS netbook. Rather than expect you to go watch the video (which is fairly long), let me just tell you the outcome — the iPhone won so easily it flabbergasted me. Basically, because the guy was typing correctly spelled words, the iPhone autocorrected everything to perfection, and the only mistake was the guy typed the words in the wrong order. On the netbook he couldn’t type a single recognisable word.

Now, I don’t particularly enjoy typing text on my iPhone (if you get a four word email from me, you know where I typed it), but I will say that in landscape mode I find the keyboard actually very good (it pretty much sucks in portrait mode, and I struggle constantly with the autocorrect to type in names, etc.). What this really points to is the advantage, in this particular situation, of (a) having autocorrect, and (b) being able to use a device single-handed. If the finger you’re typing with is on the same hand you’re holding the device inwhen in a rally car, I suspect that’s a huge proportion of the advantage.

But this is post-hoc rationalization. I fully expected the netbook to win easily.

Photoshop Alternatives Revisited

Background

As you know, the Mac software market is enjoying something of a deluge of wannabe Photoshop alternatives, generally aimed at the casual user. Adobe has left this market wide open by (a) not lowering its prices, (b) not catering for non-professional image originators (i.e. the “lite” version of Photoshop is aimed squarely at photographers rather than artists), and (c) treating Mac pros as second-class citizens — something they don’t like and aren’t used to in the world of graphics.

Contenders

Acorn's biggest improvement is a really beautiful new icon. Photoline and Pixelmator have actually improved in a lot of actually useful ways... although sadly not in the icon department.
Acorn's biggest improvement is a really beautiful new icon. (I wish I were joking.) Photoline and Pixelmator have actually improved in a lot of actually useful ways... although sadly not in the icon department.

Pixelmator has the highest profile, Photoline probably has the lowest, and Acorn got in early and received a lot of recognition (awards, etc.). There’s always The GIMP and Adobe’s Photoshop Elements (if you really enjoy being treated like a second-class citizen by Adobe), of course. There’s also Pixel. And then there’s the lamentable Iris (which seems to be going nowhere — it’s still at “1.0” and Nolobe’s forums are still MIA: nothing says crap like an indie developer with no forums, except perhaps an indie developer who used to have forums and then took them down when they filled up with posts about how bad his software sucks).

I reviewed Photoline for MacApper more than a year ago (when it was at version 14.10 or so — it’s since received a major free upgrade (to 14.5x) and a major paid for upgrade (to 15.x). Since then the other major changes are that Pixelmator has received numerous significant (free) updates and become a pretty serious contendor for basic image editing and Photoshop CS4 has been released with little new functionality and no 64-bit support for Mac OS X. Oh, and Pixel 1.0 is — we are told — rapidly approaching its supposed 1.0 release (don’t hold your breath, the last 1.0 beta was in 2006 and was PowerPC only).

A Simple Head-to-Head Comparison

Here’s a simple example of using a single feature in Pixelmator, Photoline, and Acorn which — I think — pretty much underscores everything that I like and dislike about each program in a nutshell. The “zoom blur” function simulates the motion blur effect you see when staring straight ahead at high speed or zooming in really fast. It’s a neat looking effect that brings the centre of the blur effect to fore (since it’s the only thing in focus) and makes even a pretty boring image look quite spiffy. It’s also a feature Photoshop has had (unchanged!) since forever.

picture-3
Acorn requires me to type the coordinates for the focus of the zoom blur by trial and error (mostly error). I simply gave up.

In Acorn you get a really neat mechanism for compositing filters (which is of no use at all) but no method of actually setting the center of the blur effect except numerically entering coordinates (which is actually worse than Photoshop’s early 90’s dialog box). Correction: Acorn allows you to disclose a pane which lets you (somewhat clumsily, and in low resolution) drag the effect center graphically. It’s still clearly inferior to Photoline or Pixelmator in this respect, but it’s actually better than Photoshop. (End Correction.) Also since Acorn’s way of previewing the effect is to render the whole image (and zoom blur is not much accelerated by using CoreImage) it’s really painful to fine-tune. (This is still true.)

Pixelmator's UI is unintrusive and easy to use, but the slider's useful range is ill-considered and you can't type in a precise value. The full screen preview leads to poor interactivity for slower filters.
Pixelmator's UI is unintrusive and easy to use, but the slider's useful range is ill-considered and you can't type in a precise value. The full screen preview leads to poor interactivity for slower filters (but not as bad as for Acorn).

In Pixelmator you get a really cute method for picking the centre of the effect, but the slider for controlling “how much” of the effect is insanely biased to the “too much” end of things (basically about 15% of the way to the right is more than you’d ever need to use) and there’s no way to type in exactly how much you want. Cleverly, Pixelmator generates its preview by using Core Image, but only at screen resolution so it’s more responsive than Acorn. Unfortunately, when you actually apply the effect you get a beach ball because Pixelmator’s UI isn’t designed to handle slower filters gracefully.

Pixelmator's dialog does everything. You can preview in a pane or full-screen or both. Everything is resizable. And you can set the focus point in both the preview and the main view, and set the level of blur with a slider or by typing a precise value.
Photoline's dialog does everything. You can preview in a pane or full-screen (the pane is collapsible) or both. Everything is resizable. And you can set the focus point in both the preview and the main view, and set the level of blur with a slider or by typing a precise value. But the dialog is kind of huge and the icons are ugly.

In Photoline you get a big ugly dialog box which lets you preview with a small but scrollable and zoomable window with a draggable “before/after splitter”. You can also preview on the whole screen, click where you want the centre of the effect (in the preview pane or the view behind it). And you can set the intensity with a slider or type it in.

So in summary, Acorn has a really elegant UI for stuff you probably don’t need and a lousy one for stuff you do need, almost as if it’s never really been used all that much by anyone except to dick around, Pixelmator has a pretty UI that works well if you’re not editing a high resolution image and/or using filters that don’t benefit much from CoreImage acceleration, and Photoline has a butt-ugly UI that does the job really well and has obviously been thought out and tested.

A More Detailed Comparison

Category Pixelmator 1.4 Acorn 1.52 Photoline 15.03
Simple Painting Tools Basic but servicable Rudimentary You name it, it’s there
Text Cocoa text with nice drop shadows Cocoa text with nice drop shadows Fully styled and formatted text with both character and paragraph stylesheets and layer effects like emboss and drop shadow
Layer Support Blend Mode and Opacity, Text Layers Blend Mode and Opacity, Text Layers, Simple Vector Layers Blend Mode, Opacity, Layer Effects, Filter Layers, Vector Layers, Text Layers, Layers can be different modes (e.g. you can have 16-bit color, 8-bit color, Layer Masks, and monochome layers in a single document)
Filters Excellent Core Image support Uneven Core Image support (really nice compositing features but marred by lack of weaker (see correction, above) interactivity for things like setting points) Comprehensive set of filters (including some marked improvements over Photoshop) but no Core Image support. Stuff that Core Image doesn’t give you like comprehensive noise reduction tools, and fractal clouds. Oh and you can create and reuse named presets for almost everything.
Vector Layers None Rudimentary Full vector support with strong bezier tools and SVG import/export
Non-destructive editing Not supported You can composite filters interactively in interesting (non-destructive) ways, but ultimately the operation is destructive Non-destructive effects layers for most image adjustments (e.g. curves, levels, hue/saturation)
Image Format Support 8-bits per channel RGBA 8-bits per channel RGBA 16-bits per channel support, Greyscale, Monochrome, Lab color, CMYK
Digital Photography Support You can import photos in 24-bit color You can import photos in 24-bit color Direct RAW import to 24-bit or 48-bit (16 bits per channel)
Architecture Some clever optimizations (e.g. filter previews appear to be at screen resolution) but chokes on large files. Chokes on large images and slower filters. Clever and flexible preview system allows you to keep the program responsive when working with huge files, 64-bit support, heterogeneous layer support
Workflow and Automation Some Automator actions (but no AppleScript dictionary) Python script support Recordable macros and batch conversion, Save named presets for almost anything, enter expressions for numerical inputs
Plugin Support You can probably build your own using the Quartz Compositor tools from Apple. You can probably build your own using the Quartz Compositor tools from Apple, and there’s extensive support for creating extensions using Python. Supports Photoshop plugins.
File Format Support Pixelmator, Photoshop, PNG, GIF, JPEG, JPEG2000, TIFF, BMP, SGI, TGA, PICT, PDF, and a dizzying number of export options Acorn, PNG, GIF, JPEG, JPEG2000, TIFF, BMP Pixelmator, Photoshop, PNG, TIFF, JPEG, JPEG2000, BMP, PCX, TGA, Mac Icon, Windows Icon, Windows Cursor, and a bunch more, and can import and export to an even larger number of options, notably including export to SWF and import RAW
Cute Stuff Live gradients, the “dangling rope” that joins position widgets to filter control floaters Gorgeous Icon, Filter Compositor, Elegant Minimalist UI Amazing gradient tool, full-featured yet it still launches amazingly fast, 64-bit support
Ugly Stuff Beach ball for slower filters Filter position controls require you to type in coordinates, (see correction, above) Minimalist Functionality (for a $50 app) and half-assed features (like vector layers with rectangles, ovals, and lines (only). OMG the icon … it burns! (Sadly, Pixelmator 15 introduced a new icon that’s just as ugly as the old one), half-assed web export and page layout features clutter UI without being useful
If I could add one thing from Photoshop Vector support Pretty much everything Layer management functions such as organizing layers into folders (and set folder compositing properties) and being able to use one layer as a mask for layers adjacent to it.
Online Community Active Forum None Active Forum
Price $59.00 $49.95 €59.00

As you can see, Photoline also wins, hands down, on the functionality front, offering much of the functionality of Photoshop* and then some, along with live editable gradients (not quite as “cute” as Pixelmator’s live preview, but more useful), formula support (type arithmetic expressions pretty much anywhere), variable blur (a gaussian blur where radius is controlled by masking — allowing you to simulate depth of field properly), an image browser that doesn’t suck, 64-bit support, and cross-platform licensing (oddly enough, it’s actually more attractive on the Mac than Windows though). And it still launches in less than a second — as do Acorn and Pixelmator.

Summing Up

Pixelmator has come a long way in the year-or-so since it entered with a big splash. Acorn has languished since it  won a bunch of awards and rave reviews, and Photoline has lengthened its considerable lead in robustness and functionality over pretty much everything except the gold standard.

Unfortunately for Photoline it has to compete with Paintshop Pro on Windows, and its lack of Mac-hip-allure on the Mac. Pixelmator is great for people who really aren’t doing anything very challenging — it looks cool and hey, you’re supporting indie Mac-only developers. On the other side of the equation Photoline is good but unglamorous — the question remains whether its few notable deficiencies (e.g. rudimentary layer management) outweigh its technical strongpoints (64-bit support, general snappiness, heterogeneous layer support). There’s no question that for actual professional users, Photoshop is unbeatable (except on 64-bit support — but who really needs that yet?) and well worth the money.

And finally, Acorn has become something of a joke. Its biggest new feature since I last compared these programs has been a new icon. I mean, really.

So… what is Photoline missing?

OK. Photoline sounds pretty great… so why use Photoshop at all? Photoshop has amazingly strong layer management tools (folders — which can have their own compositing settings and can be moved and scaled as one, and the amazingly useful layer-as-mask feature) which are vital to many users (if you’re prototyping UIs with Photoshop and have 500 layers in a document, then Photoline is going to be useless for you).

Photoshop also has pretty strong features for 3D texture painting and compositing (especially as of CS4) which none of these programs even attempt.

Edit: perhaps most important of all, Photoline takes some ugly shortcuts in bezier rendering that will definitely matter to professional designers. If you stroke an arbitrary object in Photoshop, the program infers a border path and then strokes it with a uniform width path. Photoline in essence uses a simple matrix transformation to build the outline leading to the stroke varying in width as it changes angle. Since this algorithm is used in many, many places (e.g. many layer effects), a lot of graphic design work, especially text layout, will look wrong and unprofessonal if executed in Photoline.

And finally, Photoshop has some “rocket science math” features such as the bleeding edge “selective scaling” function (which creates or throws out irrelevant content rather than stretching or squashing everything), panorama stitching (which is very hard to get right), a very good — some consider it the best — RAW importer, supports both scripting and a huge number of plugins — but even here I should note (thanks to an alert reader) that Photoline supports third-party Photoshop plugins and has better built-in noise reduction tools than Photoshop.

If none of this matters to you, then get Photoline and save a ton of money (and probably quite a bit of time). It’s not like Photoshop has that great a UI either. (Edit: and CS4’s UI is remarkably horrible.)

Final Note

You might also find this article on the Top 5 Alternatives to Photoshop helpful. I did.

Tabbed Titlebars

Technically speaking, Safari 4 is probably the best browser you can get. No big surprise, of course, since in my opinion Safari 3.x (especially if you use Webkit Nightly Builds) was already the best browser I could find. But Safari 4 has an interesting UI decision in it: tabbed window titlebars.

Safari’s implementation is conceptually very similar to Google’s Chrome browser, but Apple being Apple it’s far more polished, although not perfect.

Logically speaking, tabbed browsers make no sense, and of the different approaches taken, Safari 3.x’s made the least sense (the tabs appeared to be selecting the area above the tab panel, not below).

The fundamental problem is simple: the tab metaphor is supposed to represent selecting from among sections of a set of files or pages using the tabs as reference points. Selecting a tab brings that section to the front and puts the others behind (which isn’t how the real world works, but more convenient). Based on the metaphor, anything not “contained” in the tab is “global” while anything not “contained” in the tab is part of the set of stuff contained “in that tab”.

This basic rule is often violated, but usually its in the forgivable direction of including global stuff in the tab area — this usually simplifies layouts. In browsers, however, the rules are hopelessly bizarre. E.g. the address bar in Firefox is above (outside) the tab selector, but changes when you change tabs.

As I said, Safari 3.x has the silliest tab interface. The tabs are above the web page you’re looking at but visually appear to contain the stuff above the tabs (i.e. bookmarks and the address and search fields), so when you click a tab to select the page it’s related to, it appears that you’re selecting a different set of bookmarks, not a different web page.

Safari 4 has made the window titlebar into a tab selector. One obvious reason not to do this is exemplified by Google’s Chrome — it could look really ugly. But aesthetically Apple has pulled off this design about as well as you could possibly hope. Because the title bar is ordinarily used to move windows around, this is now the default behavior of tabs when clicked and dragged. To move a tab around you use the resize affordance in its top-right — this is a horrible kludge, violating the “if it looks the same it should work the same; it it works different it should look different”. In my opinion Apple needs a new affordance to serve this row, perhaps a two-way or four-way arrow. The tabs now correctly sit above the address field and web page content, but also above the search field and bookmarks.

The new design has some obvious wins: a Safari window now wastes less vertical real estate, and the containment hierarchy is logical.

I believe I’ve said this before, but in my opinion the way tabs work in Google’s Chrome (and now in Safari 4) — modulo fixing the affordance for moving tabs — should be implemented at OS level as a way of handling multiple, docked windows gracefully. Ideally, I could link a Pages document together with Photoshop, say, and tab between them when I needed to find a photo to drag into my document.