Language Flamewars and the Blub Paradox

Try this little exercise sometime.  In Google, enter your favorite language, followed by the word “sucks”.  And then do the same with a language that you just despise.  If you can stomach the results for the first page in both cases, you’ll notice:

  • Each language always has its strong Fan Boys (or Girls I suppose, but this seems to be primarily male dominated)
  • No resolution ever comes of ANY flame war

…despite the fact there are no end to the results that are relevant to the war at hand.  We all know flame wars are pointless, and yet we get some perverse satisfaction watching them in the same way people slow down on the highway when they see an accident with an ambulance present.  Why is it you can’t seem to get away from them?

That would be the Blub Paradox.  First posited by Paul Graham close to a decade ago, I came across it for the first time (yes, I live under a rock sometimes) recently and had an “Aha!” moment with it. Maybe you’ve known about it for years because you crawled out from the rock ages ago.  I don’t think it’s all that well known, considering just how many flame wars continue to pop up on blogs, discussion threads and forums.

The Blub Paradox

If you’ve never heard of it before, here’s a brief summary:

(Paul) argues that some languages are more powerful than others and posits a hypothetical middle of the road language called Blub. He describes the gist of the paradox thus:

As long as our hypothetical Blub programmer is looking down the power continuum, he knows he’s looking down. Languages less powerful than Blub are obviously less powerful, because they’re missing some feature he’s used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn’t realize he’s looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub.

Most people without the experience of them can’t see language features as really useful things. I know an otherwise extremely talented programmer who can’t see the value of garbage collection and thinks it simply encourages “lazy programming” even as he struggles to find the right location to delete objects shared and referenced by many others. Are you claiming to be such a renaissance person as to be able instantly to recognize the value and worth of every new programming feature to which you are exposed?

Furthermore, I posit that the language developers spend the most time in becomes their Blub.  Meaning that, after some magical point in your development career, switching languages becomes more difficult because you’re trapped in the Blub Paradox.

Flame On, When You’re Stuck with Blub

If you’re stuck on your Blub, you’re going to have that same cynic view of newer programming languages.  And there are plenty around today that are getting press that, depending on your perspective, you may have that same “well, they’re probably powerful but they have all that hairy stuff in there I don’t understand” reaction.  That’s Blub at work.

I’ve become painfully aware that Java is my Blub.  You can see evidence of me stuck in the Blub Paradox in my posts about Google Go.  The continuum viewing paradigm above is absolutely bang-on:  Spotting a more powerful language is incredibly difficult once you have a long series of programming habits in a particular language.  Maybe it’s just a consequence of a long programming career.  Could be mental inertia.  It doesn’t really matter where it comes from, as long as you are aware of the effect.

You can probably spot any programmer’s Blub, just by asking what he or she works in daily.  Jeff Atwood’s is probably C# or ASP by now.  Larry Wall’s is perl.  Bjarne’s is C++.*  The list goes on and on.  If you’ve been programming more than 5-7 years in a language, you’ve probably got a Blub too.

What makes this even harder is that your day-to-day work totally absorbs your programming time, particularly as you get older with a family.  Finding time for new programming projects on the side gets squeezed and you find yourself falling back on things you already know instead of digging into something you view as weird, but potentially useful.  That squeeze may ultimately turn into, “Well, why bother with X when I already have Blub?”  That’s the danger of Blub.

It’s OK to have a blind spot.  But, you should be aware that it exists and avoid the prejudice filter that comes with it.

The next time you’re tempted to look down on a language because it’s weird, as opposed to just inferior, remember the Blub Paradox and maybe spend some time in it before you strike the match and grab the gasoline.  You can bet that I will.

* I am completely guessing on these, based solely on the fact of what I read about their current exploits.  I reserve the right to be wrong about any particular programmer’s Blub, while still retaining the right to assert that Blub Paradox is still in effect.

How I Learned to Stop Worrying and Love the New Axis of Evil (Oracle)

There’s a wide sense of lament since Oracle has taken over Sun and their intellectual property, including MySQL, Java, Solaris and their hardware sales business.  I’d say the average observer of this process might use the terms “slow moving train wreck”.  I doubt they are far off on this one.

You know what?  I think Oracle taking over Sun and acting stupid is actually a GOOD THING.

No, really I do.  Let me explain.

Sun has a long history of innovation with Java.  They also have a long history of missteps (take your pick, but I personally like the layoffs that happened biannually but basically culled the best folks who took packages to get out of the toxic environment)  and flat out screw ups (Hello?  Selling off your $1B/year professional services business because you’re not a “software company”?  Wish I had those kind of problems).  I have a number of personal friends who worked there (mostly past tense, but there are still a few stragglers left) and I don’t wish their employer to crater.  No, not at all.

So why is Oracle’s behavior regarding the death of Open Solaris or suing the crap out of Google for the use of Java in Android a good thing?  Easy:  We now have an opportunity to spur the development world into action.

The Empire Formerly Known As Evil

Flashback to 1995:  Microsoft (the former and still ranking Evil Empire) was king of the developer world.  Open source was a twinkle in the eyes of a few idealists.  Developers paid handsomely to Attack of the Clippy Zombiesbuy into the Visual Studio paradigm.  Or they bought from a competitor (Borland).  C++ and C were the de rigeur choices of language at the time.  Enter Java and the entire development world was turned upside down.  No one saw Sun as the disruptive innovator at the time.

Of course, other factors played into it over the years:  the rise of the internet, the Dot Com boom and server sales tied into Java usage, the rise of open source and the overwhelming support from the community regarding Java, driving huge amounts of frameworks still in use today.  But there was always a motive:  fight the evil empire.  We fight them because the evil empire doesn’t “get it”.  Remember Microsoft’s internet strategy in the late 90s? (From a blog post regarding the missteps of Microsoft, particularly Project Blackbird)

Adobe’s Mark Anders about his time at Microsoft. Anders is well known as one of the inventors of ASP.NET, along with his colleague Scott Guthrie. However, when he joined Microsoft in the mid nineties he worked initially on the project codenamed Blackbird. This was a kind of Windows-specific internet, and was surfaced to some extent as the MSN client in Windows 95. Although the World Wide Web was already beginning to take off, Blackbird’s advocates within Microsoft considered that its superior layout capabilities would ensure its success versus HTTP-based web browsing. It was also a way to keep users hooked on Windows. Anders told me that he never believed in Blackbird and argued that Microsoft should support HTTP instead. According to him, the executives at the time did not want to listen at first, but Blackbird had severe performance problems

Darth Ellison and the EmpireStuff like this always pisses off the right people. Microsoft didn’t get it, and people got mad.  Microsoft’s stupidity in thinking they could control the internet spurred lots of innovation from other companies to make the *real* internet even more valuable.  Eventually Microsoft capitulated and followed suit with everyone else. 

And that’s precisely what I’m counting on here for the Oracle debacle. Because Oracle isn’t getting it either (at least for developers). Tim Bray’s article today has a great quote from the Empire itself:

“You don’t get it. The central relationship between Oracle and its customers is a business relationship, between an Oracle business expert and a customer business leader. The issues that come up in their conversations are business issues.

“The concerns of developers are just not material at the level of that conversation; in fact, they’re apt to be dangerous distractions. ‘Developer mindshare’… what’s that, and why would Oracle care?

Let’s Shake Things Up

Java not good enough for Android?  Fine, let’s make a new language that finally innovates on the mobile device, unlocking us from the collective disasters of Objective C, mobile Windows, and bloated Java ME.  If Java 7 is going to die at the hands of Oracle, maybe that will motivate some development group to actively fork it in a meaningful way.  Or finally develop the successor language to Java that revolutionizes the software community the way Java did in the mid-90s.

This complacency about Java, MySQL, and the state of Sun products has got to stop.  It’s time to shake things up.  And the last time that happened, exciting times were had by all.

I can’t wait.

Why Does Simplicity Escape Programmers?

An experiment, posted on that led to a further diatribe on rationality and rational thinking traps got me thinking too.  Here’s the problem:

Once upon a time, there was an instructor who taught physics students.  One day she called them into her class, and showed them a wide, square plate of metal, next to a hot radiator.  The students each put their hand on the plate, and found the side next to the radiator cool, and the distant side warm.  And the instructor said, Why do you think this happens? Some students guessed convection of air currents, and others guessed strange metals in the plate.  They devised many creative explanations, none stooping so low as to say “I don’t know” or “This seems impossible.

And the answer was that before the students entered the room, the instructor turned the plate around.

This is Occam’s Razor at its finest.  But these unwitting physics students are no different than the average programmer out there when confronted with a bug report.  Take this example of a guy who had a strange logic error in a core Linux package:

A few weeks ago, though, I encountered some bizarre behavior on my desktop, that honestly just didn’t make sense. I spent about half an hour digging to discover what had gone wrong, and eventually determined, conclusively, that my problem was a single undetected flipped bit in RAM.

This guy admirably spent a long, painful session tracking his error to a faulty location in RAM.  But his most likely rationale for why?

For me, bitflips due to cosmic rays are one of those problems I always assumed happen to “other people”. I also assumed that even if I saw random cosmic-ray bitflips, my computer would probably just crash, and I’d never really be able to tell the difference from some random kernel bug.

Cosmic rays!  Now, the possibility exists, that’s true.  But is it the most likely explanation?  No, not by a long shot. More likely:  faulty RAM due to manufacturing defects.  More RAM failures are documented as problems than cosmic ray defects.

Why do we have some perverse belief that all our problems are exotic, unusual and outside of normal?

When you discover a bug in your code, is your response:

  1. Hmmm, I wonder what simple thing I did wrong here?
  2. I wonder if there’s a kernel bug in Linux causing that?

Simplicity isn’t just a goal in optimization, but in finding the source of bugs too.  Never let the truth interfere with a good story, I always say.

How to Avoid Being the Asshole Architect

Recently, I was the happy recipient of some very condescending “advice” from the architecture group of a client.  The tone, quality and delivery of the information completely overwhelmed the actual message (some of which was actually relevant, and some was off in left field).  This pleasant experience reminding me why the term “software architect” has come to be synonymous in some circles with “arrogant jerk who forgot what it’s like to code on a real project”.

Someone's having a case of the MondaysI realized that I’ve had that exact same attitude at times and it just didn’t pay off at all.  My message was probably lost in the same manner I discarded this guy’s advice in favor of sticking it to The Man and doing whatever I was going to do anyway.

All of this is counterproductive in any development project.  Reflecting on the situation a bit more, I realized that there are a handful of key points that all software architects ought to remember.  Dispelling the “Ivory Tower” mentality can’t be anything but positive for everyone involved.  With that in mind, I bring you the

Five Minute Guide to Avoid Being the Asshole Architect (FMGTABAA):

1)  Eat your own dog food

Nothing screams “Ivory Tower” like handing down some code you cobbled together to a group of developers to “figure it all out”.  If you write a library to perform common validations, write up a standard test page and post it for all to use.  Consider this your uber-test case.  Or better yet, write an application that uses that same library and see how it works out.  Find out the pain points your consumers will actually feel by becoming one of them.  Anyone who hands you code they just put together in a manner they thought “would be useful” shouldn’t be trusted.

2)  Standards apply to you too

It’s fun (well, maybe to some people) to put together standards documents that lay out the coding conventions, code organization, source code nomenclature, build structures, and so on.  But to publish those standards and fail to hold yourself to them is the highest form of hypocrisy imaginable.  If you can’t follow a standard, why would you expect anyone else to follow it too?

By applying the standards to your work, you’re also eating your own dog food in another sense.  You see what will be painful for others.

3)  Communicate like you are a Teacher, not a Preacher

Architects are supposed to exist as a font of knowledge and experience.  Failing to share that information is pretty much against Son, you're gonna burn for using tabs instead of spaces...your core job description.  But how you communicate that experience is just as important as the information itself.  Think of your best teachers in school—did they ever strut at the front of the classroom and tell you how damned smart they were?  Doubtful.  They found ways to express their knowledge that encouraged your learning and questioning.

That condescending tone I received on the architect’s email was the ultimate turn off.  Whatever valid information was being delivered in the message was completely lost because there was no mutual respect.

Power politics kills development projects quicker than baby rattlesnake poison will take out your dog.

4)  Lead by example in Documentation

What’s the Number One complaint about open source projects?  Lack of, or poorly written documentation.  Why is that?  Documentation isn’t exactly the Crystal Meth of programming.  More like Sominex.  No one likes doing it.  Especially those that are good at writing code.

Instead of whipping development teams saying, “You need to produce better documentation”, give them a concrete example of your work.  That also helps with point #3 (Communication), as well as demonstrating point #2 (Standards Apply to You) and point #1 (Eat Your Dog Food).  Push development teams to achieve the standard set by your team for quality.

5)  Command from the trenches, not the Ivory Tower

If one idea generated the majority of contempt for software architects, I think this was it.  Somewhere along the way, the notion of architecture outside of mainstream development took hold and the notion of the Architecture Group was born.

Not once, in any company I’ve ever worked with or for, did this idea bear positive fruit for the development teams involved.  Instead, these segregated groups have generated one or more of the following:

  • Contempt for the architecture because the developers had no say in it
  • Rejection of the framework because it was impractical to apply to the project at hand
  • Blatant disregard for the standards set by architects because the architects did not have to adhere to business needs and company deadlines as a result of the delays introduced by their work

Architects should be a member of the platoon, never a visiting dignitary to the army base.  Teams respect the opinion of someone who lives their daily reality side-by-side with them, not someone who hands them the Ten Commandments and walks back to their posh tent.

6)  Throwing your prototype/framework/design/UML documentation into the hands of the unwashed masses is not the end of your involvement

Throw it over the wall!No sane building architect would throw their blueprints over to the foreman and expect it to be built in their vision.  Related to point #5, architecture teams that believe their involvement is limited to the design phase don’t really understand what it means to be architects.  When a building is being built, the architect is on site during the majority of the project, overseeing the effort at a high level, ensuring that little changes are not impacting the big picture.  All the while, the architect assists in solving minor problems that arise from his or her design from a practical standpoint.

In short, the architect’s involvement is continuous, not discrete.

7)  Attitude may work in the military for commanding respect, but it rarely succeeds in IT

Finally, acting superior, like a know-it-all, or someone who is above listening to others, is just asking to be ignored.  Don’t do it.  Ever.  Not even on a bad hair day.

Friends don’t let friends act like asshole architects.  The respect you save may be your own.

The Problem With ‘Above Average Programmers’

Quick!  Answer the following question without thinking about it:

How would you rate your programming skills?  (Below Average, Average, or Above Average)

Based on psychological studies across many different groups, about 90% of all programmers will answer “Above Average”.

Of course, that can’t possible be true.  In a group of 100 people, 50 are above average, 50 are below average.  This effect is known as Illusory Superiority.  It’s been documented in many domains and even if you’re aware of it, you’ll probably still answer the question above as “Above Average”.

For even more fun, try asking that question to every programmer you know.  Don’t ask them in a group, ask them one-on-one to get more ‘honest’ answers.  You’ll get similar results, even from people who you know can’t program their way out of a wet paper bag (this is the Dunning-Kruger effect, but it’s related).  It’s an epidemic in our profession.

Now, let’s suppose for a second that you’re right–you are actually above average.  You are da man.  A rock star.  God like capacities amongst mere mortals.  Keyboards bow in reverence to you as you approach.  Trumpets sound on high when you commit on GitHub.

If you’re above average, then chances are you’re an expert at what you do.  Calling yourself an expert sounds quite compelling–you get respect, deference, and prestige by being one.

Being an expert means you know it all about your subject. Unfortunately, it also means you’re going to get lazy.  It means you’re going to eventually rest on your laurels and sit around thinking you’re better than everyone else instead of actually working to get there.  Your expertise will become a liability because you stop trying to learn.  Maybe not today, but soon enough.

Instead, why not consider the more likely possibility?  You’re average, or heaven forbid, below average. Aside from the personal stigma you might suffer here, think for a second about the real benefits of doing this:

  • By assuming you’re not at the top of the pack, you now have incentive to get there
  • By assuming you’re not the smartest person in the group, you now have the opportunity to learn something
  • By assuming you’re not the best at what you do, you’re going to work harder to improve yourself

Perhaps you’ve heard of beginner’s mind?  Summed up by a zen master in classic koan-brevity:

In the beginner’s mind there are many possibilities, in the expert’s mind there are few.

The trap of calling yourself ‘expert’ at software development means that you pigeonhole yourself into some language (Java, Ruby, PHP), some industry (medical devices, social networking, games), or some specialty (embedded programming, enterprise software).  Once you establish that expertise, fear of failure arises when you consider going outside that comfort sphere.  With your golden hammer of experience, everything appears to you a nail.  You stop thinking about screwdrivers and all other possible relevant tools because they’re no longer inside your ‘expertise’.

This is why starting out in software you wonder why “experienced programmers” can’t get X, when you just learned X in a matter of days.  X could be anything:  closures, object-oriented programming, Ruby on Rails framework, Haskell programming.  It doesn’t matter in the end, the expert’s mind is cluttered with old knowledge.  The beginner’s mind is open, free of hindrances.

It’s harder to learn when you’re an expert.  And this is why being the ‘expert programmer’ is dangerous.

So what’s the number one thing you can do to be the best programmer out there?  Start by considering yourself below average. Step out of your comfort zone.  Be the averagest.

A master never stops learning, and neither should you.

The Outsourcing Low Cost Lie

If you walked into a store and asked to have someone make you a suit and you agreed on a price of $100 and week’s sewing time, a week later you’d expect to walk back in and be trying on your new suit after parting with a $100 bill (at least in America).

What if you went into a different store, after that initial price quote and they offered to make it for $25?  You’d think, “Great!  One fourth the cost of that previous guy!  I’ll take it instead.”

How would you feel if a week later you came back and they said it would be another week and $50 instead?  Think you’d be mad?

How much madder would you be after TWO weeks, and now the shop owner is telling your it will be $75 and one more week, but this time he’d definitely get it done.  And after you get it, you notice that the pocket is sewed on slightly funny and the trousers don’t fit quite the way you’d expect.  Would you be steaming mad now?

Yeah, I would too.

This is exactly what happens with outsourcing projects in most software companies.  If you ask companies why they do it, invariably they answer that outsourcing will save money AND time over local resources.  That’s an unbelievably huge lie. It’s time to tear that apart.

Forgetting the cultural problems you’re going to encounter with outsourcing for a minute, let’s say you have a project scoped by an outsourcing firm.  They bill their engineers to you at $25/hour.  Local contractors run you $100/hour, so you’re thinking to yourself, “Wow, 75% cost savings!  Sign this outsource guy up!”

Whoa, not so fast there, cowboy.  Let’s throw out some project statistics from the Aberdeen Group.  Unsurprisingly, reducing IT costs is the primary driver behind outsourcing for 82% of companies in the U.S.  But, as Aberdeen continues,

  • Nearly 50% of outsourced projects fail outright, or fail to meet expectations
  • 76% of companies said that vendor management effort and costs were much higher than expected
  • 30% reported ongoing issues with outsourcer management processes (e.g., inadequate governance and conflict resolution procedures)
  • 51% reported that outsourcer was not performing to expectations

In the end, the average cost savings for projects was a mere 26%.

That might sound like a reasonable number, but consider that first point more closely:  Nearly 50% of all outsourced projects fail outright or fail to meet expectations in the first place. Essentially, you’re taking the same gamble as red vs. black in Roulette about your project’s success right off the bat, and only then if you pass that hurdle, you’ll get on average, 25% savings over having it done locally.

So wait a second, where did my 75% cost savings disappear to? Let’s do the math:

Original project cost (outsourcer estimate): $10,000. (400 engineer-hours @ $25/hour)

Actual project costs: $30,000 (50% overrun on time and 100% overrun on people–longer than expected, 2x as many engineers as originally scoped, which is another finding of Aberdeen’s and other companies’ experience, so 1,200 engineer-hours @ $25/hour)

Unexpected onshore management costs: $6,000 (about 20% of project cost, from spending more time managing expectations, requirements, design reviews, documentation, etc)

Total actual project cost: ($30,000 + $6,000) =  $36,000.

Estimated project cost, if done locally: $40,000 (400 hours @ $100/hour)

Expected cost savings: $30,000

Actual cost savings: $4,000  (($40,000-$36,000)/$36,000) = 11% (for the clients I’ve worked with)

These numbers have been vetted by two recent clients of mine (due to NDA restrictions, I can’t mention either by name but one is a large entertainment conglomerate based in NYC, the other is a worldwide financial clearinghouse firm).  Both have substantial amounts of outsourced projects and both report little actual cost savings shown by front-line managers, huge management issues, and non-trivial project failure rates.  And yet, both continue to outsource because upper management believes they’re saving a lot of money through outsourcing.

Think about this for a minute: If you have 4 projects you outsource (let’s assume they are all the same:  400 hours each, and we’re using an outsource firm at $25/hour), their estimated cost of $10,000 each, and their actual cost $36,000, here’s what you get:   Your budget was for $160,000 and you believed you’d have $120,000 to spend on other projects (foolishly).  Here’s the harsh reality:

  • 2 of your 4 projects have high probability of completely failing (let’s assume that they didn’t expend the same cost above, but perhaps only half before they got canceled, so say you got halfway through each and canceled them, burning $36,000 total between them)
  • Of the remaining two, you get what you asked for but at a cost of $72,000 instead of the promised $20,000.
  • Total budget spent:  $108,000.  Expected budget spend:  $40,000.  (Difference:  +270% over expected costs)
  • Actual remaining budget for other costs:  $52,000.  Expected remaining budget:  $120,000.  (Difference:  -43% less than expected available funds)

Assuming you budgeted all your expected remaining project cash on other things, congratulations, you’re now over budget!  Welcome to every CTO and CIO’s nightmare.  And none of this addresses the other problems:  communication lags of several days to answer questions, lack of face-to-face interaction to solve problems quickly, miscommunication over simple requirements that you consider obvious but were missed in the implementation, and so on.  Are you really saving money here?

Let’s call a spade a spade:  Outsourcing just doesn’t save you the kind of money you think it will.

UPDATE:  Thanks for all the comments about my crappy math.  Yes, it’s fixed now.

Walking Into The Wrong Bathroom: Lack of Affordances

Jakob Nielsen recently published his report on iPad’s usability and application interface consistency.  To no one’s surprise, he discovered a few issues.

What was the main problem Jakob uncovered?  Many iPad applications aren’t obvious to use:  non standard controls, confusing graphics, and counter-intuitive metaphors.  In psychology parlance, it’s because these apps lack constraints and affordances.

Constraints and affordances are nothing new, even in the real world.  You encounter them every day, but you’re only barely aware of them most of the time.  Joseph Hallinan has a great example in “Why We Make Mistakes”:

“One way to reduce errors is by introducing constraints.  Constraints are essentially simple mental aids that keep us on the right track by limiting our alternatives.  Try repeating the Star Spangled Banner if you’re American without singing it.  How much can you remember?  Now let yourself sing it.  I’ll bet you get most, if not all, of the song.  That’s a constraint against forgetting the song because that’s the only way you’ve ever learned it.

Another way to reduce errors is to use affordances.  If constraints tell us what we can’t do, affordances indicate what something can do.  Affordances may appear in many forms:  texture, shape, or size may indicate usage.  For example, a ball’s shape affords bouncing or throwing.  A knob affords turning.  Slots afford the insertion of things.  When we encounter some basic object, affordances help us answer basic questions like, “How does this work?” and “What is this used for”

An everyday affordance you’re familiar with is the pull-handle on a door.  Just by looking at it, you can immediately tell that you’re supposed to grasp on to it and pull the door open.  The opposite affordance would be the push-pad on a door, where there’s nothing to grab, only a metal surface against which to exert force as you pass through it.  Sometimes constraints are added on top of this, such as “Exit” signs on the door you use to go out as well.  These are all the clues we get on how to use a door, but you’re rarely thinking to yourself, “Oh, there’s a PULL handle, I should PULL on it.”  Affordances are subtle, important cues on how to interact with things.

Those cues can go awry.  For example, building architects foul it up occasionally by putting pull handles on the push side of doors.  Or put the “Exit” sign on the “Enter” side with an arrow pointing to the other door.  These confuse us, make us hesitate, and often force us to enjoy the embarrassment of pulling on the door you’re supposed to push (a personal favorite of mine).  Sometimes they’re done on purpose, like at a famous bar I went to in college that has two doors side by side each a large arrow pointing to the other door and a gender.

Courtesy of ldanderson, Flickr
Um, which door?

They are intentionally mislabeled so women walk into the men’s restroom and vice-versa, much to the delight of the inebriated patrons.  While that sort of bad affordance was humorous in college, it’s patently frustrating to encounter when I’m struggling with a new app on the iPhone.

This lack of affordances is why the iPad and iPhone can be so bloody hard to figure out sometimes.  We have no hints–no obvious clues what to do with things mostly because the metaphors are new and the controls are often non-standard.  Consider this interface below, heavily laden with nothing but custom graphics in the UI.  Can you tell which items allow you to interact with them, and which are merely display artifacts?

Yes, I’m confused too.  And to add to the confusion, these devices allow actions we couldn’t possibly take on the desktop, like the accelerometer.  How do you give an affordance for that?  Or the shaking action?  We aren’t used to these metaphors yet, so the affordance isn’t quite obvious.

A Clear iPad Actionable UI

Contrast that with this one from the iPad, where the actions you can take are fairly clear from the interface.  (Courtesy of  Without knowing what the app is all about, you can already tell (if you’ve used touch interfaces, particularly iPhone) what you can touch, what will likely result in an action, and what items are just eye candy.

There are even more great examples on that site, I encourage you to check them out.

User interface design is hard.  Punting to a graphic designer sounds like a good idea, but consider that the difference between adequate and excellent on a user interface isn’t subtle or small.  It’s the difference between usable and frustrating.  The difference between good and beautiful.  And maybe even the difference between viral and doomed to obscurity in the App Store’s bargain bin.  Make sure you don’t just create pretty graphics, put the time in to make a pretty AND usable UI.

Don’t let your users walk into the wrong gender bathroom in your applications:  use affordances to make your UI obvious and intuitive.

Secrets of Successful Consultants Revealed

So, think you’ve got what it takes to be a consultant?  Feeling the itch because your current job isn’t motivating you like it used to?

The independence, prospect of better money and the potential for starting your own business make this idea very seductive. A million others have tread this path before you so you’d think it would be easy, right?

Nope. Not even close.

The path to success is littered with the rotting carcasses of those who went before you and failed. Sort of like the great gold rush of 1849 to San Francisco. If you really want to get into it, even after this stern warning, you have my pity. This is anything but an easy path to success, wealth or fame.

Still not daunted? That’s a decent start. Persistence is part of the key to success here.  So is intelligence.  And confidence.  But those things just get you in the door, past the obnoxious bouncer so-to-speak.  It’s early in the night, you have to order a drink and do karaoke before you can hit the dance floor.  In other words, there’s a lot more to it than you think.

Rather than cover the business aspects of consulting, or even the how to make the jump article, I thought I’d share the secrets of successful consultants I’ve come in contact with over the years. These can make or break your career as an independent contractor. Ignore them at your own peril.

Secret #1: Your reputation is your livelihood. Protect it like your life depends on it.

Your career does actually depend on it. People hire contractors for two reasons: someone said they were worthwhile, or they thought you were the cheapest one available. You get far more jobs from the first recommendation than the second, and the quality of work is higher when they pick you for your reputation rather than your rate.

Secret #2: You are always looking for a new gig. Even when you have a current gig, keep your eyes open at all times.

Unless you’re lucky enough to get two year, iron-clad contracts, you’re always keeping an eye on the end date of your current gig, trying to figure out “What’s next?” If you get a job and think, “Oh, they’ll just keep extending me over and over”, you’re not a consultant, you’re thinking like an employee. You’ll be kicked out as soon as someone realizes it. Pay attention to new opportunities coming around, and have something in your back pocket if your current contract ends or is canceled early.

Secret #3: Assume that if you’re not adding value, you’re overhead and you’ll be fired.  Constantly find ways to add value to a project.

This ought to be a rule for employees in general, but sadly, there are too many companies that allow for this sort of inertia to exist in their ranks indefinitely. Often times, this is why a company hires consultants (to get something done), so make sure you’re the person that “gets things done”. I’m already assuming that you’re smart, now you need to deliver on it.

Secret #4: You’re never an employee at the company you contract for, no matter how long you’re there.  Maintain a certain distance.

Making friends at your contract jobs is good. Acting like you’re an employee and leaning against the water cooler, chatting with the gang mid-morning is not. Contractors are supposed to be billing every hour they’re on site. Managers tend to watch consultants more closely than employees because they pay top dollar for good contractors and are paranoid about wasting their money. Don’t be the reason you get tossed out.

Secret #5: Network constantly. Everyone is a potential new client.

You never know who is going to need a contractor at their company. You never know who will be promoted to a manager or executive and suddenly be looking for that certain person with some mad skillz to come in and take over some failing project. People end up in unexpected places, and making enemies is never a good idea. Leave companies gracefully, never burn bridges, don’t speak badly of others, even if you have some personal problems with them. These things always come back to haunt you at some later point, without exception. Don’t believe me? You won’t be the exception. Trust me.

While I don’t advocate the smarmy salesman approach, handing out business cards in the restroom at the local bar, you should stay connected. Make sure you keep in touch with people. LinkedIn is a great way to do that. Facebook is another. MySpace, maybe not so much.

Secret #6: Finish what you start. Deliver what you promise.  Uphold rigorous ethical standards.

The four fastest ways to end your consulting career:

  • Fail to finish a project you were given.
  • Leave before your project is finished because you wanted a better, more lucrative job.
  • Lack the expertise you claim to have and accept a job based on that premise.
  • Do something unethical.

Did I mention your reputation was everything? Software is a small community wherever you practice it. You’ll run into the same folks again and again. If you make a bad impression because of those items above, you can bet they will be remembered somewhere down the line when you’re interviewing at another company, if those people already work there.

To confirm reputations, many managers will ask if anyone on their staff already knows this person (Yep, Secret #1 again). A negative reputation will give the manager a reason to move on to the next candidate. Don’t give them any ammunition.

You need to be cautious about finding new work while employed with another company.  You want to maintain your reputation while still networking.  It’s a tricky balance, but we’ve already established you’re smart, so this should be no problem.

As far as ethics goes, do I even need to talk about how unethical behavior has screwed pretty much everyone in the world in the last year?  OK, good.  Moving on.

Secret #7: Consultant is generally synonymous with expert. Make sure you qualify.

You shouldn’t just start consulting right out of school or with little experience. (Accenture, I’m looking at you here with your army of under trained and overpriced pretty boys and girls that you send into large companies like a virus where they try to spread all over the place without being able to tie their own shoes) There are notable exceptions, like where your field of study was highly specialized and you acquired expertise in school along the way from your professors, internships or colleagues. But for software development, you need a few solid projects under your belt to really be able to call yourself a serious consultant. If I had to put a number on it, maybe no less than 5 years experience prior to consulting. There’s no hard-and-fast rule to it, but you should actually know something, otherwise you can’t add value (Secret #3).

Secret #8: You can try to fake it before you make it, but you’ll only get so far.  Represent yourself honestly.

There are folks out there that will tell you that a consultant is only 5 pages ahead of the customer in the same book. Sometimes that’s true. Most of the time, it’s not. You need to know your field well enough to be the expert (Secret #7). Not just sound like one, but really walk the walk here.

Secret #9: Consulting in a niche or a general field can be both good and bad. Choose your specialty carefully.

You may get two kinds of advice about entering consulting:

  • Stick with something that is popular, but crowded (like Java, C++, .NET)
  • Stick with something that is specialized, but has less competition (e.g. Delphi, Embedded C development, etc)

There are pluses and minuses in both sets and neither in my opinion really wins out.

  • The popular fields mean you have more work available to you, but competition is much higher which pushes the overall rate for contractors lower in that skill. Java programmers are in this exact situation today.
  • The less popular subject areas command much higher rates because of the skill rarity, but finding new projects is much harder and you might be out of work more often. Google Go programmers are in this situation today.

Ideally, you want to be the early adopter of a new technology that will take over the industry, like learning Java in 1995. Predicting those events is nearly impossible, so I’d suggest sticking with the things that interest you. After all, you’ll spend 30% of your life doing them. No sense in punishing yourself needlessly.

Secret #10: You are a professional. In every situation, make sure you act like one.

New contractors are tempted to act just like those around them in a consulting gig: playing politics, cracking jokes, drinking too much at social events, and the like.

The short answer is: Don’t. Not ever. Even when you’re off the clock, you’re still being judged on your behavior. Remember that reputation thing (Secret #1)? Yeah, it still applies at happy hour, or launch parties, or even casual conversation. What about office politics? Understand them but steer clear of participating as much as you can. You’re not an employee (see Secret #4), so stand above that. You’ve been hired to add value, not noise (Secret #3).

If by now, you’re yelling at the monitor saying, “Dave, these aren’t secrets! Everyone knows them!”, then I applaud you. You’re in the absolute minority and you have what it takes to succeed wildly in this field. So go forth and conquer the consulting world with your intuition.

The rest of us will just have to follow this list.

Top Ten Reasons Babies are better than iPads

The ChallengerTop Ten Reasons Babies are better than the iPad

  1. Babies eventually grow up to be better than their fathers.
  2. Babies get cuter as they get older.  Think those fingerprints on your screen will get any cuter?
  3. Babies don’t have a daily purchase limit.
  4. After you get a baby, most people are satisfied for awhile and don’t want to upgrade for a long time.
  5. Babies make other people smile when they see them.  iPads just make people ask, “What’s that?”
  6. iPads look dorky in strollers.
  7. Putting an iPad on your back makes you look like a Borg.
  8. Babies don’t care if you use Flash, Objective-C, or Lua.  Babies just want you to talk to them in any language.
  9. Babies don’t require you to dress in black turtlenecks, khakis, or attend MacWorld for any reason.
  10. Babies are a LOT more fun to make than standing in line to buy an iPad


Top Ten Reasons iPads are better than BabiesThe Champion!

  1. iPads never require college educations.  The closest you get is $4.99 for the Encyclopedia app.
  2. You can shut the iPad off at 10pm and turn it back on at 7am every day, without social services knocking at your door.
  3. When the iPad is hungry, you can plug it in and leave it alone for two hours.
  4. One word:  Diapers.
  5. The iPad will never go on a first date or drive your car.  Ever.  Not even with iPhoneOS 4.0.
  6. You’ll never hear the iPad asking where it came from.
  7. The iPad will never walk in on you having sex.
  8. Trying to swipe a baby will land you in jail.
  9. Best game with a baby:  Peek-a-boo.  Which gets boring pretty fast.  Solitaire, on the other hand…
  10. You can’t make menstruation jokes about babies.