Home > technical > Uncomfortable With Ambiguity

Uncomfortable With Ambiguity

Uncertain: Not able to be relied on; not known or definite

Ambiguous: Open to more than one interpretation; having a double meaning.

Every spiritual book I’ve ever read advises its readers to learn to become comfortable with “uncertainty”  because “uncertainty is all there is“. BD00 agrees with this sage advice because fighting with reality is not good for the psyche.

pema chodron

Ambiguity, on the other hand, is a related but different animal. It’s not open-ended like its uncertainty parent. Ambiguity is the next step down from uncertainty and it consists of a finite number of choices; one of which is usually the best choice in a given context. The perplexing dilemma is that the best choice in one context may be the worst choice in a different context. D’oh!

Vengeance

Many smart people that I admire say things like “learn to be comfortable with ambiguity“, but BD00 is not onboard with that approach. He’s not comfortable with ambiguity. Whenever he encounters it in his work or (especially) in the work of others that his work depends on for progressing forward, he doggedly tries to resolve it – with whatever means available.

The main reason behind BD00’s antagonistic stance toward ambiguity is that ambiguity doesn’t compile – but the code must compile for progress to occur. Thus, if ambiguity isn’t consciously resolved between the ambiguity creator (ambiguator) and the ambiguity implementer (ambiguatee) before slinging code, it will be unconsciously resolved somehow. To avoid friction and perhaps confrontation between ambiguator and ambiguatee (because of differences in stature on the totem pole?), an arbitrary and “undisclosed” decision will be made by the implementer to get the code to compile and progress to occur- most likely leading to functionally incorrect code and painful downstream debugging.

So, BD00’s stance is to be comfortable with uncertainty but uncomfortable with ambiguity. Whenever you encounter the ambiguity beast, consciously attack it with a vengeance and publicly resolve it ASAP with all applicable stakeholders.

Ambig

  1. charliealfred
    April 30, 2013 at 7:22 am

    Nice post!

    I think your first point is the important one: decisions are context dependent. However, I disagree that ambiguity doesn’t compile. There are several ways to incorporate context into the logic, including:

    1. In a Finite State Machine, the same event (e.g. mouse up) can trigger many different actions

    2. With localization, a particular software program can adapt to multiple locales, fonts, languages, etc.

    3. When multiple classes implement the same abstract interface, and register themselves with a broker, a client can make a preference-based choice (e.g. mouse, trackball, touch pad and keyboard can each be used to move the pointer.

    The point you made that I definitely agree with is that ambiguity needs to be discovered and addressed. Ambiguity, when left to fester becomes like loose rocks in a pile. A climber is afraid to make a step, for fear of a rock slide.

    Uncertainty is a form of complexity, and as Frederick Brooks said, “essential complexity is the complexity that is inherent in the problem, accidental complexity is the complexity we add.” When we leave ambiguity to fester, we increase accidental complexity.

    Personally, I’ve found that an effective way to attack ambiguity is to model contexts and their challenges as first-class concepts. If the SUV manufacturers had done this, we wouldn’t have had to wait 20 years for a suspension that could ride high or low, depending on whether the vehicle was being used off-road or in a city. The lack of context-sensitive ambiguity in this case cost hundreds of thousands of lives in SUV rollover accidents.

    Best Regards,
    Charlie

    • April 30, 2013 at 9:16 am

      Thanks for the great input CA. I thought you had fell off the edge of the earth 🙂

      The type of ambiguity I was shooting for is exemplified by the dorky geek picture in the post. I’ve come across low level ambiguities like that countless times over my un-illustrious career. Nobody’s perfect, but often when I’ve pointed out these types of ambiguities, it’s caused way more friction than I expected.

      Ferreting out low level ambiguities is a challenge in itself – perhaps a greater challenge than resolving them once they are found. The one in the example pic can be an easy one – assuming there’s not a huge distance between Req#1 and Req#114.

      Thanks!

  1. May 15, 2013 at 1:28 pm
  2. June 11, 2013 at 1:10 pm
  3. June 10, 2014 at 10:47 am

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: