Reimagining the Airport Experience with Binary Search

Welcome to Reinvent the Wheel. In short, the Wheel is a #100day project during which I rethink, redesign, or reimagine a product or experience every day. Along the way, I will challenge conventions, explode preconceived notions, and illuminate awesome new insights in one fell swoop (or so I hope.) My rationale for embarking on this journey is threefold:

1. I wish to hone my skills in design thinking, especially human-centered and interaction design.
2. I want to critically analyze and dissect my everyday experiences to gain some ideas of why they are the way they are.
3. I hope to attack problems outside the set of “student problems” I most often attempt to solve. I.e. to design solutions that people other than college students might want to use.

Please join me on this experiment. It should be fun.

Airport Design

For today’s post, I want to focus on two aspects of what can be roughly and somewhat naively be described as the “airport experience.” I chose this topic for my first post for two reasons: it’s applicable (I am, in fact, writing this in San Francisco International Airport), and it’s available since I’ve listened to two podcast episodes about airport design within the last few months. (Thanks, Roman Mars.)

I’ll start by summarizing what I learned from the aforementioned podcast episodes about airport design. For one, the design of American airports has interestingly and unsurprisingly been influenced by the events of September 11, 2001. The changes in security measures as a result of the tragedy reflect strongly in the way travelers experience the airport. Whereas airports previously were a place to pass through, travelers now increasingly expect to spend several hours there. As a result, architects designing airports have begun offering shopping and dining options at unprecedented levels. Designers have also accounted for changes in user flow — exciting food courts and shopping centers that were once built on the land side of security have migrated to the air side in newer airport terminals.

A later episode of 99 Percent Invisible also brought up the subject of airports when discussing subtle wayfinding cues in our environment. As an example, features of the International Terminal at Hartsfield-Jackson International Airport in Atlanta, Georgian were highlighted as well designed. These features included a “yellow brick road” in the flooring tile to indicate a path to security from the ticketing area, sloping elements on the floor to guide foot traffic, and an emphasis on elongating “sight-line.”

From left, Credit: Gresham, Smith, and Partners, Credit: Sam Greenspan, Image © Chris Cunningham Photograph. Courtesy of Gresham, Smith, and Partners

In today’s post, I want to tackle two questions related to the “airport experience”:

1. How might we design departure terminals to direct foot traffic without signage?
2. How might we configure an airport wing to minimize the distance from security to departure gates?

Navigating the Airport

Sloping ticket counters toward security means you’d always see security from your point in line.

My solution to the first question expands on the idea of sightline and centers around the principle that if you can see your destination you don’t need a sign directing you to it. I propose an arrangement of ticket counters such that they are all sloped toward security. A design like this acknowledges that travelers want to get through ticketing and security right away and minimizes the cognitive load associated with finding their way.

Binary Search Optimizes Airport Walking Distance

The second question afforded a more creative solution. It occurred to me as I was walking to my gate earlier today that getting from security to a gate at the end of the long corridor that is the SFO International terminal can take more than 15 minutes. For someone running late for their flight, this can be a stressful 15 minutes indeed. There must be a better way.

To offer a solution to this problem, I borrowed concepts from my Data Structures class. Before I continue, I want to preface the below proposal by stating some necessary assumptions.

• It is assumed there exists some constant distance d between two connected gates (and consequently some constant time t it takes to walk distance d.)
• It is assumed that within reason, airport terminals can be constructed in any shape provided there is enough space for an airplane to dock at each gate.

My hypothesis: Organizing departure gates as a sorted binary tree will on average reduce the distance of each gate from security.

As an illustrative example, let’s examine the case where an airport terminal has 15 gates:

When n=15, a binary tree has an advantage over a conventional arrangement.

By conventional arrangement schemes, a passenger would have to walk an average of 4.27d to their gate. By contrast, organizing gates in a binary search tree would have passengers traveling an average of 3.27d to their gate. If this difference seems negligible, that’s because it can be. But in the case where t = 3 minutes, that’s the difference between a 10 and 13 minute walk.

My instinct after testing n=15 was that this inequality probably does not hold true for all n. To confirm this hunch, I examined the case where n=5:

When n=5, a conventional arrangement has a small advantage over a binary tree.

As you can see, the conventional arrangement actually has a small advantage over the binary tree such that the former requires an average 1.8d travel distance and the latter requires 2.2d.

I did some more digging and found that the two conventions are equivalent at n=9, and binary search only shows a clear advantage when n>9.

When n=9, the arrangement of the gates has no effect on the average distance.

This advantage grows dramatically as n increases. To further investigate the relationship between the two arrangements, I quickly coded some functions in python that return the average distance a passenger has to travel under the conventional arrangement:

def conventional(n):
    count = n//2
    total = (n%2) * (count+1)
    while count > 0:
        total += 2*count
        count -= 1
    return total/n

and the binary search tree arrangement:

def binary(n):
    total = binaryHelper(n, 0, 0)
    return rtn/n
def binaryHelper(n, total, count):
    if n < 2**count:
        total += (count+1)*n
        return total
    else:
        return binaryHelper(
        n-2**count, total + (count+1)*(2**count), count + 1)

At n=50, binary search had a roughly two-fold advantage over the conventional arrangement. At n=200, this advantage is roughly 10-fold. At n=2000, it’s about 50-fold.

Obviously, there are some limitations to this model that prevent n from approaching high numbers like 50, let alone 2000. The fact of the matter is that the more nodes there are on a tree like the ones depicted above, the harder it is to keep them spread far apart. Insofar as it is physically impossible to park two planes in the same space, there is probably a reasonable maximum of how many gates can be built in a binary tree arrangement (which I can’t be bothered to calculate given my limited knowledge of the relevant parameters.) Another concern is navigability. Binary search is easy to maneuver by computers but might be too different from conventional numbering to digest by humans.

Nonetheless, this thought experiment has demonstrated that within a reasonable range of n, binary search can save passengers a whole lot of time and energy when traveling from security to their gate. For n=20 and t=3, it could save an average of 6 minutes walking time. The implications are not only an increase in efficiency but also that airport designers might anticipate more time spent in the post-security-pre-gate part of the airport terminal.

(1/100)