Monthly Archives: June 2008

iPod Classic Usability and Quality Concerns

In 2004, I became the proud owner of a third-generation iPod. It changed the way I listened to music. I had every MP3 from my computer at my finger tips. The user interface (both hardware and software) was simple and easy to use. The iPod was the first Apple product that I enjoyed. It probably played a big part in why I’m a Mac user today.

I’m a big fan of waiting to upgrade a product until there’s a good reason to do so. I definitely won’t buy a new cell phone every year, and I’m generally only an early-adopter when a product is particularly revolutionary. At the time, the iPod had already gone though a couple revisions, but this was the first one that really caught my eye (and it was around this time that it was starting to pick up real steam in the market). It wasn’t a brick, it had more hard drive space, and the controls had improved some. Some may remember the battery-life troubles of those early versions too. I actually had to replace the battery twice and get a new hard drive too. Certainly, the iPod wasn’t without its flaws back then, but this version had the polish to keep me satisfied for several years.

After witnessing some of my co-workers marvel at this piece of ancient technology (which was still running strong a couple years after the previously-mentioned repairs), and finding myself unable to find a decent set of speakers compatible with the older dock connector, I decided it was finally time to get a newer model. Of course, I had always been excited to get some of the features added to the newer generations. I saw the color screens on my friends’ iPods and felt a bit of jealously. My own iPod’s screen was smaller and only one color. I liked the new wheel design without the separate buttons for play/pause, menu, and next/previous. The longer battery life was going to be great. In short, I was making a mental laundry list of features that would someday add up to a convincing argument to get a newer version.

During a visit to the Apple Store a couple months ago, I knew it was finally time, and I bought the Sixth-generation iPod “Classic”. While I dig the smaller Nano, it still doesn’t provide the hard drive size I need. I was tempted to try out the iPod Touch, but I didn’t like the higher price. I’ve been using it quite a bit since I bought it, maybe even more than my old iPod. I discovered some very obvious changes to this newer model that just feel wrong and leave me thinking it’s a partial downgrade.

The Wheel

The first thing that felt a little off to me was the sensitivity of the wheel. At times, it’s just too fast. It takes only the tiniest touch to go from one band to the very next on the Artist menu. I frequently find myself having to scroll back and forth several times to ensure that it picks the correct artist when I’m scrolling. My hands are smaller than those the average guy, so you can’t argue that I have fat fingers. It happened on very rare occasions with my old iPod, but I keep noticing this again and again with my new one. Slow down!

There’s a new scrolling feature that seems cool at first, but fails to be usable very quickly. As you scroll through the list, it may suddenly show a letter of the alphabet in the middle of the screen. At that point, you stop scrolling artist by artist (or album by album, whatever the menu may be), and it will begin jumping to the next letter rather than individual items on the list. The first thought that ran through my head was “Cool! That’ll save tons of time.” I imagine everyone else thinks the same thing. Unfortunately, it doesn’t save any time for me.

Much like with the previous sensitivity issue, I discovered myself scrolling way too far. Then I needed to scroll back the other direction. In other words, it’s probably great if you’re going from C to W, but not so much with smaller jumps. In many cases, I’ve had it suddenly change to letter scrolling when I’m only a few items away from my intended choice. Ugh. What’s interesting about this one is that I remember my old iPod scrolled faster depending on how fast I spun my finger on the wheel. That felt intuitive. The sudden appearance of a letter and a completely different scrolling speed means that my brain can’t switch contexts fast enough and I always need to correct myself when it scrolls too far.

Oddly enough, sometimes scrolling can be completely unresponsive too. I’ll spin the wheel half a dozen times to change the volume before it reacts. My old iPod didn’t have that problem. To me, this is a major decline in product quality, and its absolutely the worst of the problems I’ve encountered with the newer model. It seems to happen mostly when I first start playing a song. I’ve considered what might cause this behavior, and I have three possible explanations.

  • The iPod may have some software or hardware that is still being initialized in the background, so the CPU is overworked. I’m very likely to tweak my volume setting immediately when I begin listening to the iPod. I listen to the iPod in two main locations: in my car or with headphones. Both require very different volume levels. Seeing as I’ve just started using the iPod when this happens, it has my entire metal focus, so it needs to work well. I don’t care if it takes longer to get everything running, don’t degrade my experience once I can interact with a device.

  • Compared to my old iPod, more data appears on screen when a song is playing. I suspect that it’s working very hard to display the album artwork. The main evidence is that the image doesn’t appear right away when the song changes. It’s just the standard placeholder graphic for a moment. For a small device, I wouldn’t be surprised if decoding a JPG were a little difficult.

  • On my MacBook Pro, there’s a setting for the touch pad to ignore “accidental” presses. I’d be willing to bet that Apple uses the same technology for both devices. There is no such setting for the iPod. If this is the cause of the unresponsive interface, I can’t do anything to correct it like I’d be able to on my laptop.

Regardless of the reason for unresponsive scrolling, whether it be technical or by design, the device shouldn’t feel like it is lagging so far behind my input.

The Screen

I remember hearing that a certain generation of iPods had especially poor screens. They were prone to scratches and Apple almost immediately released an updated design with special protrusions mean to protect the screen. My new iPod already has two very noticeable scratches on the screen and no special protected protrusions to prevent such damage. They’re ugly, and now I’m annoyed every time I look at my iPod.

My old iPod had many superficial scratches, sure, but it felt more like standard wear and tear than this nasty multi-colored scar. Personally, I refuse to buy a special case for any of my devices. Some scuffs or nicks are okay with me. All the cell phones I’ve owned, my old iPod, the old portable CD players I used to use, and everything other portable device that comes to mind has survived my daily life with nothing I’d call “damage”. Sure, my iPod is still usable, but it clearly isn’t as durable as my old one. I accidently dropped my old iPod a couple times, including on pavement once. It looks a little worn, but like I said, that’s fine. My new iPod has been set down gently in the same place every day, and it goes into the same otherwise-empty pockets as the old one. I haven’t dropped it. I can’t even explain what caused the scratches.

Random Stuff

When I don’t interact with the iPod for a minute or so, the screen changes. Rather than showing me the currently playing song like it did a moment ago, it provides me with the current time. Now, I might be strange, but I listen to a lot of new music on my iPod. Sometimes, if I buy a new album or download a new promo song, I might not recognize what’s playing. Before, with my old iPod, I could generally just peek down at the screen to see what’s playing. If it was too dark, I could touch the wheel and the backlight would pop on.

Now, as I mentioned, there’s a clock. I’m required to touch the wheel to see the song information. When I do, it still shows the clock for a moment once the backlight turns on. That’s two short moments where I could have already gotten the information I needed with my old iPod. To go a step further with my annoyance at this feature, I’d like to point out that I own a watch and a cell phone. They both tell me the time already. I don’t need three clocks on me at all times. With my old iPod, Apple provided a setting to let the iPod track the time or not. This time around, I get the time no matter what. It’s a minor annoyance, these are really starting to add up.

One last thing. I can’t turn the volume down to zero. Every audio device I’ve owned could be turned down all the way. Now, one might argue that turning it all the way down rather than just pausing it is silly. I agree. However, twice now, I’ve turned it all the way down and I wanted it to be quieter. I had to turn it off because the volume was distracting rather than providing the subtle ambiance that I desired.

Conclusion

For years, I was a happy iPod owner. Even when I had trouble with my old iPod, I felt more worried about not having music to listen to at work than feeling like I could have purchased a better device. Unfortunately for me (and maybe Apple too), the problems I described above don’t make me want to go out and buy a new music player today. I can live with them. However, when the time comes again to buy a new device, I’m far more likely to look at the competition than I was before. Last time, I knew I was getting another iPod. There was no question about it. Next time, I’ll be spending a little extra time checking out what else is available.

My problems with the iPod can be partially attributed to one problem that exists throughout the world of computers and electronics. You can start out by inventing an amazing product, but over time, as you add more features that weren’t needed immediately, the product can become bloated. Worse, in my opinion, the existing features might be change in a bad way. This problem can sometimes happen when users stubbornly refuse to accept changes. Other times, it could be that you’re just adding or changing features because you need to create a new version to sell. Personally, I think the standard “classic” iPod has reached this point. There’s little that can be done to improve it now, but Apple keeps churning out new features or changing features without improving them much, if at all. It adds up, and only with a major upgrade skipping several versions (like mine), do some of these problems become obvious.

Style system bug in Flash CS3 UIComponents

The following bug requires a bit of explanation. I’ll start by describing how Flash CS3’s UIComponent framework handles styles. The style system is pretty complex, so it helps to review this functionality first. Then I will describe what’s wrong with the implementation and how it leads to a particularly annoying bug that affects custom component developers. Finally, I’ll include a specific use-case for why this bug needs to be fixed.

I’m posting this to my blog so that other developers can find it. I spent a couple hours trying to figure out why I couldn’t redefine the textFormat style in my custom component. Hopefully this will help anyone facing the same problem. For the record, I’ve also submitted this bug to Adobe.

Flash CS3’s UIComponent framework defines styles using three levels of importance:

  • Instance styles apply to a single, specific instance of a component. If you call setStyle() on a component, an instance style will be defined or changed.

  • Shared styles apply to all components of the same class. If you call StyleManager.setComponentStyle(), a shared style will be defined or changed. Components use shared styles to define their default style values.

  • Global styles apply to all components controlled by the style system. If you call StyleManager.setStyle(), a global style will be defined or changed.

The order of importance for these style levels is as follows:

  1. Instance styles are the most important. If a component has an instance style defined, it will take precedence over both shared styles and global styles.

  2. Global styles are less important than instance styles, but more important than shared styles.

  3. Shared styles are the least important.

You can see how this works by looking at the getSharedStyle() method of StyleManager. It first checks to see if an instance style is defined and uses that value if it isn’t null. Next, it checks for a global style. Finally, it checks for a shared style.

private static function getSharedStyle(instance:UIComponent,name:String):Object {
	var classDef:Class = getClassDef(instance);
	var inst:StyleManager = getInstance();
	// first check component styles:
	var style:Object = inst.classToStylesDict[classDef][name];
	if (style != null) { return style; }
	// then check global styles:
	style = inst.globalStyles[name];

	if (style != null) { return style; }
	// finally return the default component style:
	return inst.classToDefaultStylesDict[classDef][name];
}

Overall, this makes sense. It allows each component class to include default style values through shared styles. If a developer wants to universally change a style that is defined by many components, such as changing the font used by all controls in an application, a global style may be set. This will override the defaults set in shared styles. Finally, a single instance of a component can be made to look slightly different than everything by setting an instance style.

The Bug

Notice the very last line of the constructor defined for StyleManager. Some global styles are defined immediately when StyleManager is initialized.

public function StyleManager() {
	styleToClassesHash = {};
	classToInstancesDict = new Dictionary(true);
	classToStylesDict = new Dictionary(true);
	classToDefaultStylesDict = new Dictionary(true)
	globalStyles = UIComponent.getStyleDefinition();
}

Remember the order of style precendence?

  1. Instance

  2. Global

  3. Shared

These global styles will always take precedence over shared styles. To review, shared styles are the mechanism for setting default style values. As a custom component developer, when I want a different default value than one of these forced global styles, I’m can’t do it properly.

There are actually three workarounds. The very last one is probably best because it doesn’t change the existing behavior.

  • Use StyleManager.setStyle() to replace the global style with your own value. This is just plain bad because it changes the defaults for every component in the application and not just your custom component.

  • Create a new style with a different name. This leaves the original style in place, though, so it’s will make the API and documentation messy unless you hide the original somehow.

  • In the custom component’s constructor, use setStyle() to define the default value as an instance style. It will be more important than the global styles. However, StyleManager.setComponentStyle() won’t work because the instance style will take precedence. That function didn’t work with a global style defined either, though, so it’s not really a problem.

The fix is simple. In the StyleManager constructor, just set global styles to an empty object.

globalStyles = {};

There’s simply no reason to have any global values pre-defined in the framework. They should all be shared styles so that developers have more flexibility. Technically, they already are shared! All implementations of getStyleDefinition() use the inheritance chain to set up their default styles values. Button adds to LabelButton’s shared styles, which adds to BaseButton’s shared styles, and finally to UIComponent’s shared styles. In other words, most component implementations already access UIComponent.getStyleDefinition() to define defaults, so these styles will be shared from the start.

A quick, and obvious, use case

One of the global styles created by this bug is textFormat, which defines the default TextFormat object to be applied to text that appears in a control. I cannot override the default formatting of text in my custom components. If I want my component’s defaults to define a text format with a larger font size (or make it bold, italic, or even a different color!), I can’t do it without one of the workarounds I mentioned above.

Adobe’s own Flex framework actually has this same use case and implements it as well. The Button component in Flex has bold text by default. Most other components (TextInput, for example) do not use bold text. It’s an important customization option that the core Flash CS3 components don’t use, which is why the developers probably didn’t notice it. However, a look at the other major AS3 component architecture shows that it’s a valid need.