Vox

Leitura de 18 min

Accepting The Unexpected

Summary

In this episode of Developer Tea, host Jonathan Cottrell explores how to handle unexpected events that inevitably occur in both life and software development. He shares a personal story about his family’s house move that didn’t go as planned, leaving them temporarily displaced in a hotel, and uses this experience to discuss broader principles of preparation and flexibility.

Cottrell emphasizes that we shouldn’t be surprised when unexpected things happen, as they are a natural part of life and work. He explains that the problem arises when we treat low-probability events as impossibilities rather than preparing for them appropriately. The key insight is that even when the probability of something going wrong is small, the potential cost may justify some level of preparation.

The host introduces a practical risk assessment framework involving multiplying the probability of an event by its potential cost to determine an appropriate response. He suggests creating simple decision trees and backup plans to handle unexpected situations when they arise, noting that flexibility often comes at a relatively low cost compared to the potential benefits.

Cottrell also reminds listeners that not all unexpected events are negative - sometimes pleasant surprises occur alongside the challenges. He encourages developers to think through potential unexpected scenarios in their work and personal lives, creating systems that allow for adaptability when plans inevitably change.

Recommendations

Tools

  • Linode cloud hosting — Cloud hosting service mentioned as the episode sponsor, offering Linux servers starting at $5/month with various plans including high-memory options for different development needs.

Topic Timeline

  • 00:00:00 — Introduction to unexpected events — Jonathan introduces the topic of unexpected events and how they happen frequently to everyone. He explains that the goal of the episode is to discuss ways of dealing with unexpected situations that occur throughout one’s career, particularly in software development where unknowns are common.
  • 00:01:58 — Personal story of disrupted house move — Jonathan shares his personal experience of a house move that didn’t go as planned, leaving his family displaced in a hotel. He explains how he failed to prepare for the low-probability scenario of their moving dates not aligning perfectly, despite applying his software development knowledge to evaluate the risks.
  • 00:05:51 — Analyzing preparation mistakes — Jonathan analyzes the mistakes he made in his house move planning, particularly the lack of flexibility in his approach. He discusses how flexibility often comes with a cost, but that cost must be weighed against the potential cost of failure when unexpected events occur.
  • 00:09:30 — Risk assessment framework — Jonathan presents a practical risk assessment tool involving assigning probability scores (1-10 or percentages) and cost scores (low/medium/high or 1-3) to potential unexpected events. He explains how multiplying probability by cost creates a risk score that can guide preparation decisions.
  • 00:12:22 — Creating decision trees and backup plans — The host discusses creating simple decision trees and backup plans for unexpected events. He emphasizes that since we can’t predict every variable, we need systems that allow for flexibility and adaptability when things don’t go according to plan.
  • 00:14:05 — Positive unexpected events and conclusion — Jonathan reminds listeners that not all unexpected events are negative, and sometimes good surprises occur alongside challenges. He shares that in his housing situation, they ended up having some moving costs covered as compensation for their troubles. He concludes by encouraging proactive thinking about potential unexpected scenarios.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-02-28T10:00:00Z
  • Duration: 00:16:15

References

Podcast Info

Transcript

[00:00:00] I want you to think about the last time that you had something unexpected happen to you.

[00:00:09] If you’re like most people, and perhaps all people, your answer should be within the last

[00:00:16] 24 hours. And this is kind of a weird phenomenon that unexpected things seem to happen all the

[00:00:22] time. So how do we prepare for that? That’s what we’re talking about in today’s episode of

[00:00:28] Developer Tea. My name is Jonathan Cottrell, and the goal of this show is to help driven developers

[00:00:34] like you connect to your career purpose. The reality is, you know, a lot of the time this

[00:00:40] show will end up talking about ways of dealing with life, ways of dealing with things that are

[00:00:46] going to happen to you throughout your career, no matter what field you’re in, which is why this

[00:00:52] show really is not just for developers, but it really happens to developers quite a lot that

[00:00:58] you run into.

[00:00:58] Unexpected things. And this happens especially with your code. It’s going to happen especially

[00:01:04] when you start working on features that have a lot of unknowns, for example. And we shouldn’t

[00:01:11] be surprised. This is really the first point of today’s episode. We really shouldn’t be surprised

[00:01:17] when unexpected things happen. Because what makes them unexpected isn’t that we are caught off guard.

[00:01:25] What makes them unexpected is that we’re not caught off guard. We’re not caught off guard.

[00:01:28] That usually those things don’t happen. So we shouldn’t be surprised because we know that

[00:01:35] unexpected things happen. We know that within the realm of possibility, there is a long list

[00:01:42] of outcomes, and a lot of those are considered unexpected. Those are considered unexpected

[00:01:49] outcomes, things that likely are not going to happen. So you may be able to hear a slight

[00:01:54] difference in the audio for today’s episode. And the reason for that is because I’m actually going to be

[00:01:58] recording from a hotel room. And this was an unexpected reality that we had to face.

[00:02:05] My wife and I are moving to a different house, staying here in Chattanooga, Tennessee. But we’re

[00:02:11] moving to a different house. And the date that we were closing on our old house or selling our old

[00:02:16] house and moving out was supposed to perfectly coincide with the date that we’re moving into

[00:02:23] the new house. And this relied on a lot of variables lining up. And being the

[00:02:28] responsible homeowner and father and husband and human that I am, I applied as much of my learning

[00:02:36] from software development as I could to this situation. Evaluating what are the odds that

[00:02:42] this is going to go sideways? What are the odds that we’re going to be delayed and not be able

[00:02:48] to move into our house? We need to be able to prepare for these situations. And the response

[00:02:53] was that the odds were relatively low. And this is where my laps

[00:02:58] of judgment came in. Because of the very low risk of this issue occurring, that ended up

[00:03:07] occurring, I was not prepared. We did not prepare. And ultimately, we ended up being displaced into

[00:03:15] a hotel and I don’t have my normal recording gear with me. So how could I have done better

[00:03:21] in this scenario? And more importantly, how can we apply this to our work every day? We’ll talk

[00:03:27] about that later.

[00:03:28] Right after we talk about today’s sponsor, Linode. With Linode, you can get up and running

[00:03:33] with Linux in the cloud on plans starting at just $5 a month. This is one of the best

[00:03:40] investments, especially for beginner developers. This $5 a month plan, it’s one of the best

[00:03:46] investments you can make into your career. Because once you start learning about networking and

[00:03:51] the true power of having an internet connected server, you’re ultimately you’re probably going

[00:03:58] to be able to do a lot more. And I think that’s what we’re going to be talking about today.

[00:03:58] become addicted like so many of us to building things that are connected to the internet. And

[00:04:03] this allows you to do so many things with your programming knowledge. And it allows you to build

[00:04:09] products. For example, you can actually start in that $5 server with Linode and build your startup

[00:04:15] one piece at a time and scale as you need to. Of course, Linode is not only entry level machines.

[00:04:23] In fact, they also serve high memory plans. We’re talking lots,

[00:04:28] lots of memory here. Imagine having a computer that has access to 200 gigabytes of memory.

[00:04:35] Most of your database driven applications that many people who are listening to show

[00:04:41] don’t even use 200 gigabytes for the persistent disk storage, much less 200 gigabytes of memory.

[00:04:49] So the point is, Linode can cover this wide variety of needs from high memory,

[00:04:56] all the way to entry.

[00:04:58] And I highly recommend them not just because they have plans that will suit everyone,

[00:05:05] but also because they have excellent customer service and they care about the development

[00:05:09] community. It’s a company with developers in it, and they contribute back to the development

[00:05:15] community and they continuously are updating their internal knowledge base, which they share

[00:05:19] wide open with you. So you can learn how to do things with your Linode node on Linode’s website.

[00:05:27] You can learn how to do things with your Linode node on Linode’s website.

[00:05:28] You can get up and running with Linode incredibly fast.

[00:05:31] Head over to spec.fm slash Linode to learn more today.

[00:05:34] If you use the code developer T 2018, you’ll get $20 worth of credit at checkout.

[00:05:39] Head over to spec.fm slash Linode.

[00:05:42] Use the code developer T 2018 at checkout for that $20 credit.

[00:05:47] Thank you again to Linode for sponsoring today’s episode of developer T.

[00:05:51] So how could we prepare better for uncertainty?

[00:05:55] Well, one of the fatal mistakes that I made,

[00:05:58] in my particular case, where we’re left displaced in a hotel, a little bit underprepared,

[00:06:04] is that I didn’t allow for any flexibility in my plan.

[00:06:09] That was the first mistake that I made, that our plan was truly kind of built with a rigid

[00:06:17] transition in mind. Now, the reality is that flexibility almost always costs.

[00:06:22] And this is one of the main reasons that we chose not to build our plan flexibly,

[00:06:28] but having the ability to flex with your situation.

[00:06:33] That really is kind of the definition of adaptability.

[00:06:36] So if you’re in a situation where, you know, your inflexibility is going to cost you a lot,

[00:06:43] then building inflexibility to your plan is more important, right?

[00:06:48] So you have to evaluate the cost of failure, evaluating the cost of that inflexibility.

[00:06:55] If something were to, you know,

[00:06:57] cause you to need the flexibility and you don’t have it, what is the cost that you incur?

[00:07:03] And now you can make a more informed decision,

[00:07:06] a better equitable decision on how much you’re willing to invest in flexibility.

[00:07:11] But another more nuanced mistake that I made when evaluating the likelihood of something going wrong

[00:07:18] is that I used the small chance as a way of saying that there was no chance.

[00:07:24] In other words, I allowed my biased thinking,

[00:07:27] to see the small chance as nearly an impossibility.

[00:07:33] And this is the problem with seeing those small chances as an impossibility.

[00:07:39] When you have nothing to prepare for,

[00:07:43] then you’re not really evaluating the potential outcomes

[00:07:47] and the implications of those potential outcomes.

[00:07:52] For example, in this scenario, even though the chance was very low,

[00:07:57] that we would end up having a different closing date on one house than the other,

[00:08:04] the chance was very low of that happening, even though that’s the reality,

[00:08:08] the cost, if that were to happen, justifies a little bit of preparation.

[00:08:14] Because the preparation may have included, you know, carrying a little bit more in our cars.

[00:08:20] It may have included not packing so many things on the moving truck,

[00:08:24] but instead, you know, maybe we take a load,

[00:08:27] load over to a friend’s house,

[00:08:29] so that we have access to more things,

[00:08:31] so we’re a little bit more flexible with what we can do,

[00:08:34] and how long we can go in this transition state

[00:08:39] of being out of our own home and in a hotel.

[00:08:42] So this kind of flexible thinking and evaluating is important

[00:08:46] because even though it’s a statistically small chance that something will happen,

[00:08:51] we dramatically improve our flexibility with really what comes down to

[00:08:57] a very small input, right?

[00:08:59] A very cheap decision.

[00:09:02] It’s not very expensive to have made some of those changes,

[00:09:05] and that flexibility would have been dramatically increased.

[00:09:09] So it’s important when we are preparing for unknowns,

[00:09:13] when we’re preparing for unexpected circumstances,

[00:09:17] unexpected events, that we identify as many of those unexpected events as we can,

[00:09:24] and especially focus on those,

[00:09:27] high-cost events, right?

[00:09:30] So what you can do is some very simple math.

[00:09:33] Maybe you do something like assign a cost of, you know, low, medium, or high, right?

[00:09:39] Or maybe you can even give it a number of 1, 2, or 3,

[00:09:43] and then assign a probability score to this same event occurring.

[00:09:50] So you may have a 1 out of 10 or even a percentage score,

[00:09:55] and you apply these,

[00:09:57] these percentages, you kind of multiply the probability of it happening

[00:10:01] by the cost of it happening.

[00:10:03] This is a very common thing that is done when evaluating risk, right?

[00:10:07] And what you come out with is a score that gives you, you know, an action plan.

[00:10:13] So let’s say, for example, we go with our 1 through 3 for the cost of the risk,

[00:10:18] if this thing were to happen, the cost of that.

[00:10:20] So it’s like a low, medium, high.

[00:10:22] And then we have a probability number,

[00:10:25] and let’s say that we have,

[00:10:27] let’s say we have something that is a 95% probability that it will happen and a low risk,

[00:10:32] or let’s make the math a little bit easier.

[00:10:34] Let’s say we have a 80% probability that it will happen and a low risk.

[00:10:39] Well, then we can say, you know, a 1 times a 0.8 or a 1 times 80% gives us a 0.8.

[00:10:47] But on the flip side, we could also have something that is a much lower probability of happening,

[00:10:53] even half the probability of a 0.8.

[00:10:56] So we have a 0.4, but twice the cost, right?

[00:11:00] So we have a 0.4 and a 2.

[00:11:03] Well, we end up with the same risk score.

[00:11:05] And hopefully you saw that coming.

[00:11:07] Those of you who have taken any kind of statistics class,

[00:11:11] you probably know this very simple risk assessment tool.

[00:11:15] But what we don’t do is embed this into our everyday thinking.

[00:11:19] We very rarely recognize the kind of the utility score here.

[00:11:26] We very rarely recognize the utility score here.

[00:11:26] We rarely recognize both factors coincidentally.

[00:11:31] Barely ever do we consider just how likely this thing is or just how costly it is.

[00:11:37] We only consider one factor or the other very often when making a decision.

[00:11:42] So what we end up doing is for those very small likelihoods,

[00:11:47] we kind of round them down to zero.

[00:11:49] And then for the very high likelihoods, we might even overprepare, right?

[00:11:54] We might round it up to a 0.8.

[00:11:56] We might round it up to a surety.

[00:11:57] So recognizing your entire risk pool, where are your risks coming from?

[00:12:02] What kinds of things are creating those risks for you?

[00:12:07] How can you mitigate those risks?

[00:12:09] How costly is it to mitigate those risks?

[00:12:12] Identifying all of those things can help you be more prepared

[00:12:16] and be less caught off guard when something happens that is unexpected.

[00:12:22] Now, it’s also important to recognize that very often,

[00:12:25] unexpected things occur that you can have an automatic response to.

[00:12:30] Very simple backup plans, right?

[00:12:32] And it may not even necessarily need to be extremely detailed

[00:12:36] or all that different from your original plan.

[00:12:39] Creating these very simple manual decision trees, right?

[00:12:45] If this particular thing happens, then we’re going to go down this road.

[00:12:48] If it happens another way, then we’re going to go down a slightly different road.

[00:12:53] And those two roads may look very similar,

[00:12:55] but,

[00:12:55] they have different characteristics.

[00:12:58] And this decision tree is going to help you

[00:13:00] kind of progress through that decision-making process

[00:13:04] when something unexpected occurs.

[00:13:06] Because the truth of the matter is that you’re hardly ever going to be right

[00:13:11] all of the time when it comes to multiple decisions.

[00:13:15] The likelihood of you predicting the exact path,

[00:13:18] the exact likely path of decisions and external variables,

[00:13:23] and a lot of things that ultimately are not even

[00:13:25] within your control.

[00:13:27] The likelihood of you being able to predict every point along that path

[00:13:32] is extremely low.

[00:13:34] The likelihood that you need to be flexible then becomes very high.

[00:13:40] It’s important to recognize these simple realities as it relates to unexpected events.

[00:13:46] They’re going to happen and we need ways of making decisions when they do.

[00:13:50] So the most important thing you can do is to start thinking about what those unexpected events are.

[00:13:55] So the most important thing you can do is to start thinking about what those unexpected events are.

[00:13:56] Imagine even the most wildly outrageous things that you can think of as unexpected events.

[00:14:05] Now, it’s important to recognize that

[00:14:08] it’s very different to think about the possible outcomes

[00:14:12] than it is to kind of allow these things to cause anxiety

[00:14:17] or to cause inappropriate preparation.

[00:14:20] Remember that with all of the unexpected things that could happen that are bad,

[00:14:24] Remember that with all of the unexpected things that could happen that are bad,

[00:14:25] Remember that with all of the unexpected things that could happen that are bad,

[00:14:25] to recognize that a lot of unexpected good things can happen as well. Very often the unexpected bad

[00:14:31] comes along with unexpected good. This is true in our scenario here at the hotel

[00:14:36] because in the process of all of this displacement and these strange unexpected things happening in

[00:14:44] paperwork and filing, we ended up having a large portion of our moving costs covered to kind of

[00:14:51] compensate us for all of the small headaches that we’ve had to endure in this process. So it’s

[00:14:58] important to recognize that even though unexpected events do happen, that the unexpected nature of it

[00:15:04] doesn’t necessarily carry with it bad consequence. Instead, you can be pleasantly surprised

[00:15:12] sometimes. You can expect that every once in a while you’re going to also have good unexpected

[00:15:20] things occur.

[00:15:21] Thank you so much for listening to today’s episode of Developer Tea. Once again, my name is Jonathan

[00:15:26] Cottrell. You can find me on Twitter at jcottrell. You can also find the podcast’s Twitter account

[00:15:32] at developertea. You can tweet questions there. You can also send me an email at developertea

[00:15:38] at gmail.com. Thank you so much for listening. Thank you again to Linode for sponsoring today’s

[00:15:43] episode. If you are a new developer or if you’re a seasoned developer, if you are a DevOps wizard,

[00:15:50] or if you’re a product,

[00:15:51] owner, everybody has something that they can gain from Linode. Head over to spec.fm

[00:15:58] slash Linode and get started today. You’ll get $20 worth of credit if you use the code

[00:16:02] developertea2018 at checkout. Thank you so much for listening to today’s episode. And until next

[00:16:08] time, enjoy your tea.

Visão de gráfico