Amazon's tiny target areas

Click to confirm shipment. Don't miss!

Single-Line Calculators: Math Through Blinders

Ever since my first time using a TI-82 calculator in middle school, I've despised single-line calculators and the usual limitations that come with them.
The TI-82, TI-83, and many other graphing calculators made by Texas Instruments, Casio, and Hewlett Packard, sported large square screens out of necessity to accommodate the graphing functionality.  As a side benefit, this provided room for arithmetic expressions in a multi-line input.
Multi-line inputs are particularly useful for viewing the history - the last few lines of expressions and values.  With this visual feedback, it was much easier to reference the answer to the last expression, as well as the expressions themselves (seeing the latest assignment of values to variables, reusing parts of the last expression, etc.)  This was much better than a single or dual memory slot under the MEM/recall approach on most typical calculators. And working with single lines (or at most, dual lines on scientific calculators) was like performing computations through blinders.
The graphing calculator was a godsend.

What vexed me was why I could only enjoy this in the tangible world.  Personal computers are even far more powerful computational devices, and yet, bundled calculators on just about every operating system mimicked the feel of the real world (that's fine), but chose the limited calculators as their models (not good).  As a result, they were a pain to use for anything more than a single calculation.
They were workarounds across the years - spreadsheet programs like Excel, full-blown software like MATLAB and Mathematica, online search bar calculators like Google's, offline search bar calculators like Spotlight in Mac OS X - but none of these quite fit the use case.
It had me scrambling for third party calculators, none of which were remotely famous in the mainstream and therefore niches that most people couldn't enjoy.  The Power Calculator from the Windows XP PowerToys was my first good find.  SpeedCrunch was the my first find for other platforms, if you don't count the partially usable paper tape feature for history on Calculator.app in Mac OS X.
But the first one that truly comes close something light and powerful like the TI-8x series was Soulver for Mac OS X.

Like those aforementioned graphing calculators, this provides the multi-line input to display all variables set, expressions written, and answer values resulting.  There are plenty of other useful things it can perform on these beyond the physical limitations of those calculators, ranging from referring to more than one stored answer value (ANS on the TI) with its ability to reference any line, to going into previous lines and editing.
It is well-suited to perform the tasks without the extra weight of larger applications that would be overkill for this situation.
This is how I believe a standard calculator application should be done in personal computing.  We could still strive to implement visual and interactive elements for the real-world analogy, but if they keep in mind the advantages in usability a computer can offer over the physical calculators, we can have the best of both worlds.

Relocating.

I'm moving Bleuprints from Blogger to Tumblr. The Blogger platform is not very appealing to me anymore. Find all of the original archives, and every post after today at bleuprints.tumblr.com or http://bleuprints.monstercyb.org once the DNS changes propagate.

Of Widgets and Apps

One of the primary advantages of Apple's approach to widget engine implementation was that their engine (Dashboard) was based on HTML, CSS, and Javascript, which appeals to a wider spectrum of web developers out there.

Widgets - the idea itself - is nothing new. They were thought up long ago as mini applications with very specific purposes. For example, one such widget might deal with displaying a typical six-day weather forecast. Dashboard's offerings included widgets such as Weather, Stocks, Clock, and Calculator.

A couple years later, when the iPhone debuted, there was apparently news that these same aforementioned widgets' iPhone app counterparts were originally written in a manner similar to the HTML/CSS/Javascript-based Dashboard widgets, but that within the six months between announcement and release, they were redone natively in Objective-C for performance.

But Javascript performance has improved remarkably in the few years since then, with the improvements in Javascript engines from Safari to Chrome to Firefox, and while Apple's stance on native webapps was put aside for the timebeing with the release of the SDK, the webapp idea still lives on in various online and offline forms in Palm webOS apps, Chrome OS apps, and even iPhone MobileSafari's webapps. And it will be interesting to see how further performance improvements increase the viability of the webapp, and by extension, expand development opportunities to a massive number of eager web developers out there.

One Step Backward

It vexes me that some browsers today still assign the "back one page" function to the backspace/delete key. Even in the auto-draft-save era, accidental page backs are still an issue as partially-filled form fields are often out of focus. There are ways to disable it in some browsers, though it's debatable whether such a crucial key should be dual-purpose.

Backspace back-deletes text when form fields in the page are in focus, but goes back a page otherwise. These fields frequently come in and out of focus, which just increases the likelihood of the mishap of losing unsaved form data that much more. (Not every browser remembers unsaved form data when returning forward one page.)

Did someone think it was a good idea to use "backspace" because it reminded them of "back"? Backspace/delete keys suggest something destructive - it doesn't just move the cursor in a text context, but removes characters along its way too. Navigating back one page is not a destructive act. It's navigation, much like moving a cursor with the left arrow key.

All we have now are website-implemented safeguards - your auto-drafts, or perhaps JS detection of the "back" key to prompt the user when forms are on the page. But these aren't solutions because you can't depend on every site to be designed well to begin with.

There has to be a better way.

Managed vs Unmanaged Libraries

In the olden days, our music libraries were primarily unmanaged. It was essentially the only option. If you wanted to listen to a song, you had "Eagle Eye Cherry - Save Tonight.mp3" or "01 - save tonight - eagle eye cherry - [desireless].wav" or something along those lines. You interacted with the file within the file explorer, such as Windows Explorer, and kept track largely by file name. Some people used meta data in one form or another, such as MP3 ID3 tags, but just as many of us ignored or actively removed those tags to force it to organize by carefully renamed filenames. Even more people just took the files as is, creating messes like "~ALLSTAR1.mp3" or alike.

Programs like Winamp, Windows Media Player, and RealPlayer provided the features necessary to organize libraries heavily on metadata, but they generally didn't create much of an abstraction layer between the file system and the music library. Your audio files were linked, and its tags read, but the files were otherwise left alone where they were.

The Music Library: iTunes and Winamp

iTunes took a different default approach, and it made it a polarizing music library application. Unless settings were set otherwise, it organized your files for you by creating folders for each artists under a single parent directory, and sorting each song within appropriate nested folders named by album name. The song files themselves were renamed by track number, a comma separator, and the song name.

So on Windows, you might get:
C:\Documents and Settings\Gordon\My Documents\My Music\iTunes Library\Eagle Eye Cherry\Desireless\01 - Save Tonight.mp3

People either hated it or loved it.

This was managed music.

When the Windows port of iTunes came out in 2003, I began using it in parallel with Winamp, my incumbent music player of choice at the time. It was light, simple, and unmanaged. I had also stripped my entire library of all ID2/ID3 tags over the years, so it wasn't optimized for iTunes.

I was a hater of managed music.

I wanted to organize these files myself. I had my own folder structure and naming conventions. Yet over time, I grew to like iTunes managing my music for me. With every new file, I could drag it into the library, and it would take care of the rest (making a copy, renaming the file based on the metadata, and creating appropriate folders). Then I could delete that original copy or what ever I wanted.

The thing was that, as much fun as it may be to have full control and say over how to manage your own music, it just wasn't scalable to me past a thousand songs, much less several thousand. If the computer is so much better at automation than a human, I figured we should be offloading this tedious work to these machines.

The Photo Library: iPhoto and Picasa

If iTunes is to managed as Winamp is to unmanaged, then iPhoto and Picasa are the respective analogies for the photo library.

Like iTunes, iPhoto by default created copies of any photo you dragged into the application, but also like iTunes, you had the option of disabling copying to the photo library.

With the latter, iPhoto would simply link to wherever that file sat, and wouldn't make a renamed copy. With the former, it would place a copy in a bundle "iPhoto Library" in the user Pictures directory, like this:

/Users/gordon/Pictures/iPhoto Library/Originals/2007/October 22, 2007/IMG_0001.jpg

This is nearly identical to iTunes behavior, with the one distinction that iTunes still involves folders that can be navigated through via UI the traditional way, instead of bundles that require "Show Package Contents" or a terminal.

/Users/gordon/Music/iTunes/iTunes Music/Coldplay/Viva La Vida - Prospekt's March Edition/1-07 Viva La Vida.mp3

Picasa, on the other hand, offers iPhoto's link-to-file option as the only offering, but differs beyond that for monitoring those watched locations for changes to the files (renamed, deleted, etc.).

As a Picasa user, I haven't embraced iPhoto in the same way that I had with iTunes. I tried to determine why that might be, considering that I have a much more overwhelming number of photos than audio files to manage. It could be that the metadata in music files played a much bigger role in determining how to organize them. Many of us were already manually organizing by artist or album, perfect for metadata. Sorting and filtering by genre, beats per minute, length, and other attributes were perks, but the point was that a lot of us were already manually managing the same way auto-managing worked.

Whereas with photos, my guess would be that there is more fragmentation in the way these files are organized from person to person. Some might group by events (Graduation 2003, Italy 2002, Birthday 2008). Some might group by year, or month, or months nested within years. Or some might group by year, with the photos within each grouped by events. Some might not group at all.

iPhoto does allow you to create smart playlists a la iTunes based on criteria, so that you can do anything from creating playlist/labels filtering out all photos taken with a specific type of camera, or more usual things like grouping by year.

But these are folders. These are like, again, smart playlists in iTunes or IMAP labels in Gmail. And this may not work for everyone.

Ultimately though, I would venture to conclude that perhaps not as many people see a need for managed photo libraries, as useful as it is, because photos are much more visual by nature, and can be spotted in a grid of thumbnails. In time, with the ongoing release of new tools like facial recognition and geotagging maps, perhaps managed photo libraries will be compelling enough for more of us to alter our ways.

Keyboard-based File Renaming

There are subtle differences in how a file navigator handles keyboard-based file manipulation that are easy to overlook. They appear minor or trivial at a glance, but can be detrimental to usability with the sum of all nuisances, or with batch file manipulation tasks by hand.

There is a lot to focus on, so I will keep this one about file renaming.

Renaming in the Early Days

Back in the days up until and including Windows XP, if a user renamed a file (F2 by keyboard shortcut, or by "Rename" via right-click contextual menu), it would highlight the entire file name and its file extension. (This is, of course, unless known file extensions were hidden.)

This was a problem for a couple reasons. If you didn't know what a file extension was, you would likely accidentally rename a file extension. If you did, it was an extra three or four keyboard strokes for each file to place the cursor to the end of the actual file name. It doesn't sound like much, but you pride yourself on using keyboard shortcuts for the purpose of being fast.

Mom and Dad skiing.jpg

Fortunately, some years back, I noticed on Debian and Mac OS X that triggering a file rename highlights the file name only, with the option to move the cursor to the right into the file extension area.

Mom and Dad skiing.jpg

It was a huge improvement, but considering that most of the world was on Windows, it was important that this make it over to the Windows side.

Renaming Today: Cursor Placement

Starting with Windows Vista, this behavior was available in Windows Explorer. The only issue is that if you rename (F2 or by mouse) to highlight the file name only, and realize you want to append or delete characters from the end of the file name, you hit the right-arrow instinctively. That should place the cursor at the end of the name and before the dot of the file extension, right? This is the case in Linux and OS X, but not so in Vista or 7.

Before:
Mom and Dad skiing.jpg

After (Linux, OS X): Right-arrow places cursor before the dot:
Mom and Dad skiing|.jpg

After (Windows Vista, 7): Right-arrow places cursor after the dot:
Mom and Dad skiing.|jpg

What are the implications in this difference in behavior? Let's compare this to the way you would normally rename a file with the file extension hidden.

Before:
Mom and Dad skiing

After (All OS's): Right-arrow places cursor at the end of the file name:
Mom and Dad skiing|
Mom and Dad skiin|
Mom and Dad skii|

Without file extensions, the keys are F2, arrow-right, and then delete or append right away, in the case of Windows. So if we apply this with the incorrect behavior of placing the cursor right of the dot, we get this.

Before:
Mom and Dad skiing.jpg

After (All OS's): Right-arrow places cursor at the end of the file name:
Mom and Dad skiing.|jpg
Mom and Dad skiing|jpg
Mom and Dad skiin|jpg
Mom and Dad skii|jpg

Screenshots after the break (note the text cursor placement):

Renaming Today: Cursor Jumps

What if I want to jump the text cursor to the beginning of the name? In OS X, hitting the "up" and "down" keys moves the cursor to the start and end of the file name, respectively. In Windows, it simply doesn't register at all, so there's some further improvement that could be made there.

DOWN ARROW ↓: Mom and Dad skiing|
UP ARROW ↑: |Mom and Dad skiing

Renaming Today: Shift-Selection

If there's anything everyone seems to have implemented, it's holding the "shift" key as you add or subtract characters from a selection of text.

Mom and Dad ski|ing.jpg

Batch Renaming

Unless you know what regular expressions are, batch renaming options leave a bit to be desired. On the one hand, you have nothing really built into OS X in Finder, and leaves this work to AppleScript in the form of a handful of pre-written automator scripts. On the other hand, Windows does provide a basic sequential batch renaming solution by appending numbers in parenthesis to an otherwise identical base name. This was available since Windows XP.

Ski trip.jpg
Ski trip (1).jpg
Ski trip (2).jpg
Ski trip (3).jpg

Otherwise, not much interesting is going on in the built-in UI file navigators.

Improvement and Progress

But OS parity aside, honestly, there have been some interesting solutions in third party file renamers such as batch renamer utilities. It pains me that there have been so few improvements implemented into the UI side for this tedious task. It could be something a little more inventive like predictive text entry or something as simple as the live spell check that exists everywhere else. It's all in the details, folks.