Author Archives: aaron

Aspects of Love

Programming languages come and go at a frightening clip. Less often but still with some regularity, frameworks appear and disappear as well.

But it’s more infrequent that entire approaches to coding come along. Functional programming has been around forever. Object-oriented programming has been around nearly as long. But it’s only been a little more than a decade that the idea of <em>aspect-oriented programming</em>, or AOP, has been on the scene.

If you’re not familiar with AOP, some background might be helpful. A key idea behind AOP is that there are functions that your code needs to do which go across (or cross-cut) the entire application. In other paradigms, you then need to code bits of those functions all over the place. But in AOP, you do it only once.

One prototypical example is logging. If you’re writing an application that does anything significant, you probably write out to some kind of log when it happens. In a user-based application, for instance, you probably want to log every time you add a new user or delete a user.

Under other approaches, you need to call some kind of logging hook in your addUser and deleteUser functions (or methods). But with AOP, you can define a separate logging function, and tell it to attach to the deleteUser and addUser functions. The parts of the code that actually do the work with users aren’t touched at all.

Why is this helpful? Well, suppose you want to change how logging works or how you call the logging piece. You’d need to touch every place it’s called. With AOP, you just change the logging piece once, and you’re done.

Or suppose you decide well after the design stage that you want to add a layer of security to every user routine to make sure the person trying to make a change has permissions to do so. You could go find all of the functions and add calls to them, or you could just create a security-check routine and attach it to the relevant functions.

Compiled languages like Java and C++ have had this idea for a while now, but it has been slow to come to interpreted languages. With the Flow framework, for instance, PHP now has AOP capabilities. There’s still some roughness around the edges, but it’s a big step toward widespread adoption of this approach.

Watch this space…

Ballmer’s On The Way Out

So the news came down today that Steve Ballmer is retiring from Microsoft within the next year. And within moments of that news getting out, Microsoft’s stock rose nearly ten percent, coming close to its highest level in a year. That must be a real ego boost for Mr. Ballmer (although from all apparent signs, his ego is quite healthy, thank you).

The departure (and its aftermath) raises some interesting questions about where Microsoft has been and where it’s going, and about the tech industry as a whole.

First, a data point: Ballmer’s departure announcement was covered as an urgent, breaking-news story by financial publications (e.g., Wall Street Journal) and by general-news publications (e.g., New York Times). Some of that is probably expected, given the size and scope of Microsoft as a company, but I suspect that if the head of Nestle decided to step down over the next year, there would be articles but not breathless and speculative reportage. Clearly there’s something about Microsoft and about Ballmer that rates more amped-up coverage.

Most notably, the departure was also covered in a similarly urgent manner by Variety, a trade publication for the entertainment industry. And this is where we start to see one of the impacts of Ballmer’s tenure as head of Microsoft, and, really, of Steve Jobs’ leadership a decade ago: the worlds of tech and entertainment are separate no more.

Through his embrace of the creative community (and his extreme leveraging of it through interrelationships between Apple, Pixar, and others), Jobs educated both camps about the value of partnering with the other. But Ballmer oversaw some significant motion there, too. MSNBC, the Xbox (and subsequent iterations), and the various music initiatives (Zune, anyone? Anyone?) all had thumbprints from Ballmer on them.

His tenure at Microsoft was rocky, to be sure, and his on-stage performances that were once likened to a “humanized baboon” remain of legend. But Ballmer’s stewardship of Microsoft has resulted in some pretty great stuff, too. So maybe the tech community could keep the gleefulness down to a dull roar?

Designing With Audio: It’s Doesn’t Have To Be Annoying

We’ve been working on a project around here that is very audio-focused, and that’s a little unusual for us. Most of the time, the visual is the primary medium, and if there’s audio at all, it’s an ornament. Flipping the script, if you will, has been eye- and ear- opening. Some of what we’ve learned we will be able to use back on our more traditional projects.

The first pre-conception that some of us had was that audio was annoying, or a nuisance, or something that was frivolous. Surely, when it’s used poorly, it can be all of those things.

But as I type this blog post, I’m listening to the sound that the keys make as I strike them. It’s a feedback mechanism — in addition to the tactile one, of course, but an important one nonetheless. I still long for (and keep threatening my workmates that I’ll get) the old, heavy, metal IBM-style keyboards that really made a ruckus when you typed on them. The deeper tactile feedback was useful (and it really built finger strength!), but the more solid tapping/thunking sound was a key part of it.

If you’re an iPhone/iPad user, think of the beeping sound you get when you invoke Siri. You don’t have to be looking at the device to know what you did — it’s immediately obvious. How do you know? The sound. It becomes an interface-navigation feedback piece.

Then there’s the more traditional navigation feedback — where audio *is* the interface. The clearest example of this is hands-free interfaces in cars, but they exist on all kinds of other devices, too. Navigation systems that read out turn-by-turn directions, for instance. The audio is so important that it’s a selling-point, a key feature.

As we delved further into this audio project, we realized that by being mindful of the audio design as much as (or more than) the visual design, we could achieve a similar combination of functionality and beauty. We just had to toss our preconceptions at the door – and open our ears.

Unix Dying? Ha!

Julie Sartain over at Network World published a piece today called “The last days of Unix.” In, largely citing Gartner analysis, she posits that Unix is slowly dying.

To that, I say, “fat chance.” Reading the article, the numbers are reasonably compelling, but I think they tell a different story than what Gartner and Sartain are saying.

The article appears to be measuring pervasiveness through expenditure, and particularly server expenditures. By that measure, Gartner’s data is showing the levels have peaked and will slowly be declining over time. And generally, that measure is probably accurate.

But that’s a little like saying carbohydrates are going out of fashion because some Panera Bread franchises are closing. Measuring Unix’s staying power through people purchasing specific servers is probably not the best way to do it.

If you are trying to get a true measure of Unix’s pervasiveness over time, it would seem to be far better to look at shipments of…Unix. And it’s variants, of course (although the article differentiates between Unix and Linux, et al, it seems a bit of a spurious distinction). So look at the dedicated server shipments, sure, but also at Mac OS X (hello, Unix kernel), and RedHat/Fedora and CentOS and Debian and Solaris and …well, you get the idea.

Looking only at the sales of big iron itself says more, I think, about the decline in purchasing of big iron. Recent articles in mass media have talked about the slowness in tech spending, driven in part by companies’ move into the cloud for computing power. Well, that’s one example (of several) where previous orders for big iron just aren’t happening anymore, unless you’re someone like Amazon or Google – and they both build their own custom boxes.

So for those denizens of bash, the wizards of tcsh and the valiant vi users, fear not. Rumors of the death of Unix appear, to me, to be greatly exaggerated.