Panic and Recover

Today was my first day back at work, and I was reminded that something I often do is panic. My panicking was particularly noticeable today after returning from a long vacation, and unexpectedly found myself being pulled into executive meetings and conversations. I had forgotten how terrifying these interactions can be for me.

My panic often comes up when I'm in new situations, especially those involving authority figures. The fear of authority figures, according to the internet, comes from feeling less worthy in comparison to others, particularly those with power. This feeling usually starts with tightness in my chest and throat, making it feel like I can't breathe. To regain composure, I need to take several deep breaths to slow down and refocus on my surroundings. I also experience cognitive overload, where everything seems to go blank, making it difficult to grasp even basic concepts I'm usually comfortable with.

I used to cope with my panic by seeking immediate reassurance from my friends. I depended on this external validation to affirm my self-worth, and lift me out of feeling small and insignificance.

Over time, I've adopted a new approach to managing my panic. Similar to how I try to find internal validation with my accomplishments, I've also learned to recover from panicking by incorporating breaks into my day. Most of the time, these breaks serve as moments of relief amidst the chaos of a typical workday. When I'm panicking, they also give me the space to reassure myself that I'm safe, so that I can return to normal functioning.

This approach reminds me of the panic and recover mechanism in the Go programming language. In the Go blog post, "Defer, Panic, and Recover," the panic and recover functions are described as follows:

Panic is a built-in function that stops the ordinary flow of control and begins panicking.

Recover is a built-in function that regains control of a panicking goroutine. Recover is only useful inside deferred functions. During normal execution, a call to recover will return nil and have no other effect. If the current goroutine is panicking, a call to recover will capture the value given to panic and resume normal execution.

Implementing breaks throughout my day mirrors this concept by "deferring" a space for me to recover from panic. As a Go program, checking my email would look something like this:

package main

import "fmt"

func main() {
	workday()
	fmt.Println("Returned to normal work day.")
}

func workday() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("Recovering: taking a break and several deep breathes, then replying to %v\n", r)
		}
	}()
	fmt.Println("Checking email...")
	reademail(1)
	fmt.Println("Returned from a normal work day.")
}

func reademail(i int) {
	if i > 2 {
		fmt.Printf("Opening email #%d from a big, scary executive\n", i)
		fmt.Println("Panicking!!!")
		panic(fmt.Sprintf("email #%d", i))
	}
	defer fmt.Printf("Replied to email #%d\n", i)
	fmt.Printf("Opening email #%d\n", i)
	reademail(i + 1)
}

This program outputs:

Checking email...
Opening email #1
Opening email #2
Opening email #3 from a big, scary executive
Panicking!!!
Replied to email #2
Replied to email #1
Recovering: taking a break and several deep breathes, then replying to email #3
Returned to normal work day.

Taking breaks allows me to pause, collect myself, and acknowledge that my ego sometimes undermines my confidence in an effort to protect me. By understanding that my tendency is to doubt myself and my capabilities, I can reset and approach problems with a more open and curious mindset. This lets me feel confident in my ability to tackle whatever challenges the corporate world throws my way, one panic, recover, and email reply at a time.