i used to be paralyzed by indecision at restaurants.

i am the friend you go out with who asks the waiter for his recommendation, only to ask him to give you 2 more minutes, only to choose something completely different. also waiters love recommending chicken and it’s not my fault that all the dry poultry dishes in my past have propelled me into a large pool of skepticism.

anway, i digress.

i’ve been reflecting a lot on how i make big decisions lately, and how that process has changed over the years as i’ve picked a college, a field of study, a city to live in, romantic partners, a second job. i recently went through a career shift, taking a hiatus from the tech industry to work at the intersection of tech and ethics in academia – a pretty big shift for me.

i came to this funny realization that a few of my life philosphies resemble popular algorithms, and thought i’d share some of the ideas:

idea #1: optimize locally, but regularly re-evaluate your heuristic
to my fellow computer scientists, this is known as the greedy algorithm.

the greedy algorithm boils down to one simple tenant: make your best educated guess for your next best move with the information you have, and you’ll have a pretty good shot at efficiently finding the actual capital-B Best thing…but no guarantees. it’s known for being relatively straightforward, computationally fast, and good enough.

i like this one because of life’s expected unexpectedness. uncertainty.

with the rapidly changing job market, a set of priorities that shifts just as quickly, making and executing on a capital-P plan has always seemed impossible to me. instead, my path has been a series of “best” decisions determined by the “best” heuristic i could make, based on the thing i was trying to optimize for at the time of the decision.

for me, the key to this idea is to reguarly re-evaluate my definition of “best,” understanding that it’s ok to readjust priorities, and to trust that present me is indeed setting up future me for success.

idea #2: first mover has the advantage
i am a go-getter at heart. i’ve always been the girl that takes initiative, being more proactive than passive by nature, in both my professional and personal life. yes, i’ve definitely had my fair share of rejections with this strategy – but mathematically, there’s actually a proven advantage for making the first move.

the stable matching algorithm* offers a simple premise: given a set of males and a set of females, where each individual has a ranked list of potential partners, find a matching between males and females where every couple has a match, and are satisfied enough with their partner to not leave each other. the solution presented usually involves the men courting the females, going down their list and proposing in ranked order. the female can turn the man down, or trade up if a more preferable suitor comes along. what we end up with is an optimal solution, and set of stable couples.

but optimal for who?

our first thought might be that because the couple is stable, the solution must be optimal for both parties involved. otherwise, wouldn’t one partner leave the other?

the punchline here is that the solution isn’t actually optimal from everyone’s point of view, but only from the group that acts first. it doesn’t matter if it’s men and women, jobs and candidates, sororities and potential new members – the group of first movers will end up with a solution that is more optimal than the passive group.

despite the very theoretical constraints of this very theoretical set-up, the core insight still really resonates with me. she who makes the first move has the most amount of choice and agency. the worst thing that can happen is “no.”

idea #3: plan for bugs, give yourself time to fix them
ok, so this isn’t an algorithm as much as something i’ve learned from all the time i’ve spent with computers and building products: even the most superhuman of programmers produce buggy software.

machines and humans speak different languages, and it’s not uncommon for something to get lost in translation. i believe what makes a good engineer is not the complete absence of bugs, but her ability to not make the same mistake twice, and to plan for the almost certainty of something going awry. this humility usually leads to dedicated debugging time, leading to higher quality software.

in life, this translates to recognizing that making mistakes should be part of the plan. that mistakes actually look exactly like right choices up until the very last minute. by recognizing this, i give myself space and time to get to the other side.

at the end of the day, i try (albeit poorly at times) to remember that having a perfect track record of decisions isn’t the goal, but rather the growth that comes from accepting, and learning from the wrong ones.

*this algorithm is NOT representative of actual dating/marriage, but merely an anecdote used by professors to illustrate the concepts. for example, this algorithm is framed for heterosexual couples because it only works if the sets are exclusive.