People and Code

We have bugs and sometimes we fail

I started reading some books on coaching, and this idea started to grow in my mind that people and code are similar. Like:

1. People also have code installed in their brains and bodies
2. There are some traits about ourselves which we think about as being bugs which are actually features
3. We have strong, core beliefs about ourselves and the world we live in, which are hard to change
4. We have typical responses to people: 2xx — you’re OK I guess, 4xx — it’s you, not me, 5xx — it’s me, not you
5. We sometimes fail sometimes

1. We Run on Code (and Coffee)

The new year comes. And with it, the New Year’s resolutions. Another year, another chance to lose that extra weight, work on your dream, enroll in that creative class. And, of course, another chance to not do any of that and marinate in disappointment. Do you realise how hard it is to actually change? Even though you might understand some concepts in theory, your gut just can’t get it. And your gut needs to understand.

Why is it so hard? Because we run programs. To become more efficient in our day to day lives and in some cases (drama queen alert!) to survive, we’ve pre-learned how to behave and react to the world when some things happen. So when someone acts strangely one day, remember, they have their own code running; it has nothing to do with you. We are reactive systems. And the fact that it is bothering you → that’s your own program response.

The code is legacy. It’s from your great-great-great-great-grandparents. You don’t go in there because it works as it is. When you tried to change it, it felt uncomfortable as hell and nothing worked anymore. So you put in there a line of comment:

// @aprav 12.12.2019 never change this!

Which will soon become the new legacy.

2. It’s a Feature, Not a Bug!

We focus on bugs. I don’t know why; maybe it’s the world, maybe it’s the society we live in, maybe we learned to be this way. And the truth is, it doesn’t really matter why. We are so focused on what doesn’t work. And we continually try to change. To be better. Which is awesome!

We grow, develop, evolve. The thing is, in this restless growth, we forget one important thing. Everything ‘bad’ also has a good side. Until you ‘change’ it, ‘solve’ it, ‘fix’ it, why not enjoy the benefits? Most bugs are also features! And most bugs started from something beautiful, like a skill or a quality. For example, a great helper could become a meddler when going too far.

Change if you really want to. And if you do, the first step is making peace with the fact that you are as you are. The next steps are mostly about enjoying the process. Maybe you’ll get there, maybe you won’t. Does it matter? It’s a feature, not a bug! Enjoy it while it lasts!

3. You Try to Change, Things Might Crash

And now you’re saying: “Andra, everyone can change. I saw it in a meme, so it must be true”. Indeed. You can change your habits, move to another country, change your friends, get another husband. Do you really change? I see these things like apps on the phone. You install a better taxi app, new ones, change the old ones, remove some of them. In the meanwhile, your operating system stays the same. You are the same, untouched. Your life changes, you don’t. Your environment changes, you don’t.

Maybe you liked your core beliefs, your core values and skills. You’ve also seen some things that you didn’t particularly like, and thought they could use a touch of sparkle. Changed a bit, and everything started crashing. You freaked out, never going back, you promised yourself. The room got locked, and the key was thrown to the dogs.

We have strong beliefs about ourselves and the world we live in which are hard to change.

Yes, we do. Even though we think we are flexible and agile, we’re not.

Maybe you have some yourself. Try and question them. Just question. For one second, pretend they aren’t true. How does that feel? Aha! See what I mean?

We are like code, hard to maintain, have questionable architectures, need electricity to run, have failures.

4. We Respond to the World in Status Codes

Every website has a client (the browser for example) and a server (where all the semantic processing is made). They communicate with each other by requests. In order to understand each other, they need a protocol. That protocol is HTTP. In HTTP, we have status codes for responses from the server. We, as humans, also have responses to the world. And to other people. When something happens, I’ll do this:

1xx: Informational, in order to understand each other we need to do this (use English, have a call, meet).

2xx: Success, I see what you mean → these are people/things we might actually like. Or, at least sometimes.

3xx: Redirection, we’re not on the same page, will talk when you have some more details, I don’t know, I need more time.

4xx: Client Error, people we don’t really like. Also, it’s you, not me. Some examples:

• 400 Bad request
• 402 Payment required 😂
• 403 Forbidden
• 406 Not acceptable
• 409 Conflict
• 418 I’m a teapot
• 429 Too many requests

5xx: Server Error, people we don’t really like. Also, it’s me, it’s not you.

• 500 Internal Server Error
• 503 Service Unavailable — I am.
• 505 HTTP Version Not Supported 🙂
• 507 Insufficient Storage

The funny thing is that we treat the world like there are all 4xxs. When, in reality, if we are honest to ourselves, there are 5xxs. From our legacy code and internal operating system. It’s hard to admit you have a problem and not the world. Because then, two things happen:

1. You take full responsibility for your responses and try to make them into 2xxs. You realise that no one is coming to fix your code.
2. You have no one to blame. You will either complain for the rest of your life or start admitting that it’s you, not them.

You can try to return a 4xx every time it’s actually a 5xx. No one is stopping you; it’s your internal chemistry. You can tell people: “I don’t like this, stop it please”. Even if they do, the bug is still there on your side, and will always remain like that, no matter what you return to the world.

5. We Fail Sometimes

Yes, we do. Like systems, nothing is predictable, even though the code is there. The input is unreliable and the result mostly nondeterministic. One thing is certain: failure will come. What do great systems do? They are failure resilient. So instead of fearing failure, make sure you integrate it in your life. Make sure when it will happen, you have the tools to deal with it.

Ok, so what now? What is there to do? And more precisely HOW? That, my friend, only you can know.

I’ll leave here the books that inspired me to write this article:

1. The Coaching Habit by Michael Bungay Stanier → a quick hands-on book on how to develop your coaching attitude in your daily tasks. You can find a 3-minute, cutely illustrated summary on YouTube. Also, the author has some workshops where he applies the concepts, which are also freely available on youtube and quite awesome. Yes, I watched them all.
2. Mindful Leadership Coaching by Manfred Kets de Vries → this has a more in-depth approach to coaching and often refers to clinical approaches to understand better the reasons behind our leadership actions. I personally enjoyed this book more, particularly in chapter four, which exposes how great transformational leaders based their ruling on forgiveness.