Learning from Crashes

I came up with a neat and compact little definition of a crash as a result of the recent ongoing obsession with the idea we’ve had around here. A crash is an unexpected subjective reaction to an unexpected real-world outcome.

Both parts are important. If you have an unexpected outcome to an activity, but are able to just roll with it without experiencing any mental states you haven’t encountered before, it isn’t a crash. Having a flight canceled isn’t a crash. It’s simply a contingency that you deal with by replanning your travel. Annoying, but hardly a case of unexplored emotional reaction territory.

Equally, having an invisible and private emotional meltdown with no visible external trigger events is not a crash (though it might lead to one).

A crash is something like a failure, but more general and less loaded with negative connotations (think “crash a party”). You can generally predict the kind of emotional reaction in a failure, but not the degree. A crash generalizes this idea: with a crash, both kind and degree of emotional reaction are unexpected. So unlike failures, crashes can be both positive and negative, and are invariably interesting, which to me is a more interesting feature of a situation than its emotional quality.

Failures

A failure is a special case of a crash. By narrowing the definition of a crash, we can define a failure as an unexpectedly severe and negative subjective reaction to an unexpected real-world  loss.

If you’d anticipated and planned for it in enough detail that your own emotional reaction does not surprise you, it wouldn’t be a failure so much as a contingency. So that bit is similar to a crash.

The subjective reaction to a failure is partly predictable. People react to failure with fear, shock and a collapse of self-esteem. That whole Kubler-Ross grieving process. They shrink away from the realities of the situation. They begin to act dead if the shock is severe enough, sometimes retreating fearfully into a shell for the rest of their lives.

It is the severity of your own reaction that you usually don’t expect. Until you’ve failed sufficiently often at a given level, you’re generally unprepared for the severity.

This is not something you can learn once and for all. Failing 10 times at a certain activity, and enduring a certain level of consequences, does not prepare you for your own reactions to unexpected outcomes in other kinds of activities.

For example, if you are a beginner programmer, the first time your program fails to run, the message “Syntax Error” is almost a mild, traumatic shock. By the tenth time, it is barely a pinprick. By the hundredth time, you don’t even emotionally register most code execution failures as failures in the sense of emotional trauma. They are simply data to learn from.

But learning to roll with Syntax Error punches does not necessarily prepare you for rolling with (say) failures of blog posts to get traction on Twitter or failure to fill a new restaurant for an evening service.

With the right kind of metacognitive awareness, some of the emotion management capacity does carry over, but if you expect to handle everything life throws at you with stoic equanimity, and it actually works out, chances are you are acting dead and in denial about it.  This is one of my problems with Taleb’s idea of antifragility. It is not easy to tell antifragile behavior apart from acting-dead behavior easily.

Life simply isn’t that deterministic, simple or convex. If you choose to engage only the parts that are, you’re turning away from much that is interesting and worthwhile in life, in the guise of seeking only that which “gains from uncertainty”.

Learning from Failure is Unnatural

 

I recently realized that treating failures as data to learn from is not a natural instinct. It is in fact a very unnatural behavior. The phrase trial-and-error does not denote a process anybody can undertake. Only children under safe-play conditions and adults in real-world conditions who have learned to cope with certain classes of failure.

I realized this watching a  beginner programmer try the hour of code exercise (a simple tutorial based on drawing various geometric figures on the screen).

When a program failed to execute, she’d ignore the incorrect output and simply try to re-read the instructions and tweak things randomly, in the hope of getting it to work. This surprised me. I am not a particularly experienced programmer myself, but I’ve done enough programming that my first instinct is to look at the incorrect output of a program, not at the documentation or instructions. Even an unhelpful error message is better than nothing.

As anyone who has written programs of even a moderate complexity knows, ignoring incorrect output is not a very effective strategy for debugging. Looking for clues to what went wrong and what to try next is the essence of troubleshooting.  Why would you not do that?

Because even something as trivial as the output of a failed toy program is traumatic to look at if you’re not used to it.

Our instinct is to look away from the remains of failure and look at more pleasant things. Forensic pathologists, accident investigators and detectives can afford to look unsentimentally at crash sites and crime scenes. In part because they are not experiencing a compromising emotional reaction. But also because they’ve seen a lot of similar cases.

But you don’t have to be emotionally uninvolved to be capable of managing your emotional responses. You don’t need to meditate or get therapy in order to become capable of learning from failure.

You just have to have failed at a given level enough times to have become well-calibrated to the severity of your own responses, and effective at managing those responses. You are adapted to a domain at an advanced beginner level when you can keep trying indefinitely despite failing. You are at an intermediate level when you can look at failure data to learn, instead of being so traumatized you look away in aversion. You’re advanced when you begin failing in ways nobody has failed before.

Failure never really gets any easier to deal with, but patterns of failure do get more familiar with exposure. And the severity of your own reaction does gradually go down. Eventually it begins matching your expectations and you need no longer call the outcome a failure. Just a trial in a statistical sense.

Of course, if you fail in a very different domain with very different consequences, your emotion management skills may not carry over as completely as you hoped or expected.

But the skills do carry over far more than people think. The power of sheer frequency of failure is quite astounding.

Frequent, Cheap Failures

Fail fast and failures are cheap are now well-established heuristics in software, in part because bits are cheap things to fail with, compared to atoms. The reason programmers get far better at emotionally dealing with program execution failures, compared to say pilots learning to deal with plane crashes, is that you can fail hundreds and thousands of times, and not just in simulations.

All activities of consequence produce failures. Programming is special because it is an activity that naturally trains you to handle the emotional cost of the failures it produces, and generally leaves you undamaged enough to keep trying indefinitely till you get it right.

I don’t know if this is true, but I am told Rovio, the makers of Angry Birds, had released 56 unsuccessful games before they had their big hit. The Internet is the land of endless second chances. No pilot is likely to even physically survive 56 plane crashes, even if the laws in some country allow him or her to keep flying that long.

Blogging and tweeting are the same way, compared to writing novels for years in isolation. By the time I had my first true hit on this blog (the Gervais Principle), I had written almost 150 posts and had had 150 chances to learn to deal with my own reactions to posts performing in unexpected ways with my then-miniscule audience. Now, north of 400 posts, the sheer accumulation of quantity of trials has put me into a mental state that even a very talented new blogger, far better than me in terms of writing skill, cannot truly emulate.  It’s the school of not-very-hard knocks that just takes time and trials to progress through.

Fail fast and release early, release often (RERO) are as much, if not more, about training your emotions down from “this is a failure” to “this is yet another statistical trial-and-error event” than about agility in the external world. The emotional learning is vastly more important than the technical learning.

One consequence of the early high-frequency posting was that I stopped obsessively checking my traffic and feed stats somewhere around the end of Year 1. That early obsession was really emotion training and had very little to do with making “agile” decisions about what to write next. Just watching those graphs bounce around and comparing them to my own post-publication state of mind in relation to a given post was a kind of relentless emotional conditioning. Every week I had a chance to either compare a happy post-writing mental state to a sad-looking graph of external events, or the other way around. When my own reactions subsided into a very familiar zone, I stopped checking.

When the Gervais Principle happened, it was my first experience of a crash that was not also failure. The unexpected level of success, thanks to the Slashdotting, threw me into a reaction state I hadn’t experienced before. But the exhilaration soon gave way to simply another level of trained emotional reactions. I’ve had big hits since, but not the same big emotional responses. The aftermath was, in retrospect, not that different from reacting to a “failure.”

Like blog posts, programs too can “fail” in ways that lead to very unexpected positive subjective reactions and external outcomes. Marvin Minsky, for example, discovered the Minsky circle algorithm through “failure” — he was trying to write a program to draw a spiral, and a bug turned it into a very good circle-drawing algorithm.

The person I watched do the hour of code exercise had a similar interesting failure: her bug turned what was supposed to be a drawing of a snowflake into a drawing of a five-point star. I was tempted to tell her to explore that, but then I realized the learning environment wasn’t actually built to take advantage of that kind of positive failure. The somewhat annoying digital tutor-bot insisted on sticking to the original lesson plan of drawing a snowflake over encouraging play and tinkering.

Something for future designers of learn-to-program environments to think about: you do want students to go chasing after serendipitous bugs that create interesting positive outcomes. That’s what makes dealing with the 9/10 annoying bugs so worthwhile. This is what turns drudgery into the deliberate practice of disruption.

It seems silly to call such things “failures” but at the same time, there are elements of chaos and tumultuous emotions that has a very unplanned and Kubler-Ross-ian quality to it. Such serendipitous things do knock you off course and off-plan as surely as failures do.  It is quite possible to react with fear to success as much as failure. The same emotional buttons are being pushed.

You can’t just call such an event an “opportunity” in the sense of being offered an unexpected promotion. It is a crash.

Crashing into Serendipity

Failure is a very loaded term, especially in America where success is fetishized to the point that any life event or outcome that wanders off script is heavily punished and penalized by what is perhaps the most class and status-obsessed society in the world. I almost feel sorry for Americans because of that. It is a heavy burden to bear in an otherwise very privileged society.

Crash however, is a term that has neutral connotations of chaos, confusion, wild emotions (and smooth over striated actions for you Deleuze and Guattari fans). You can certainly crash a plane or a car. But you can also crash a party or wedding for stimulating fun and unexpected new journeys. Stock car racing is partly about turning crashes into a dangerous kind of fun.

Many holiday movies that manage to elevate themselves above ordinary schmalz rely on precisely such plot devices to work: an unexpected “crash” in a life script that turns out to be the best thing that could have happened to the person. It’s a different matter that the hero or heroine usually (and rather unfortunately) “discovers” that the “best thing” is some sort of moronic pastoral acting-dead script of 1950s small-town family life, instead of a true open-ended adventure. But well, Hollywood can’t get everything right.

When both the kind and degree of your own reaction to an unexpected outcome are unexpected, there are rich possibilities. That’s what crashing into serendipity is about.

Of course, whether or not you spot these possibilities depends on two things: whether your unpredictable emotional response is positive rather than negative, and whether you choose to actually look at the crash-site from that mental state and find interesting things to learn. If you look away, you’ll either celebrate or grieve. If you look at the crash-site, you’ll grow and learn.

Happy holidays! I’ll post the annual roundup next week, for those of you who plan to sit around doing some catching up.