Vox

Leitura de 15 min

We Become What We Get Used To

Summary

The episode begins with an analogy from audio engineering: the signal-to-noise ratio. The host explains that if noise becomes too high, the signal (his voice) becomes difficult to hear. He then applies this concept to human behavior, introducing the core idea that we become what we get used to. Our brains are highly adaptive, and what is initially strange or abnormal eventually becomes our new normal, whether it’s a high-income lifestyle, a low-income situation, or the emotional response to lying.

The discussion then turns to why this matters for software developers. For junior developers or those writing their first lines of code, the initial feeling of being overwhelmed, constantly seeing errors, and feeling like an imposter is a common spike of “abnormality.” The host offers encouragement: as you continue down the path, these challenges will become normal, and you will adapt and overcome them. This psychological resilience is a fundamental part of growth in the field.

However, the host warns of a downside to this adaptability: we can also become accustomed to bad practices. If not testing your code becomes your normal, then introducing testing will feel like an abnormal, energy-taxing chore. The key insight is that normalization is inevitable; our brains will establish a baseline or “normal” to save energy and create predictability.

The solution, therefore, is to be intentional about what we allow to become normal. Developers should proactively set their “ideal state” as the default behavior. Instead of fighting against a low bar, we should “trudge through the abnormality” of high standards until they become our new normal. By setting the bar where we want it to be from the start, we make excellence our average, avoiding the trap of spending most of our time below our potential. The episode concludes with a challenge to listeners to raise the bar for what they accept as regular practice in their development work.

Recommendations

People

  • Dan Ariely — A behavioral economist referenced by the host. His team’s research at Duke University is cited as evidence for the normalization phenomenon, specifically showing how the emotional response to lying decreases as lying becomes more frequent and normalized.

Tools

  • Datadog — A SaaS-based monitoring platform that provides a unified view of systems, apps, and logs. The host mentions it offers a free trial and a free t-shirt for listeners who sign up, highlighting its integrations with Docker, Go, Azure, AWS, and Chef.

Topic Timeline

  • 00:00:00 — Introduction: Signal-to-Noise Ratio Analogy — The host introduces the episode’s theme using an audio engineering metaphor. He explains that a high signal-to-noise ratio is crucial for clear audio, just as clarity is important in our personal and professional lives. This sets the stage for discussing how we adapt to and normalize our circumstances.
  • 00:01:35 — Defining ‘Normal’ and Human Adaptability — The concept of ‘normal’ is explored as a relative term, differing from person to person and culture to culture. The host highlights human adaptability, noting that people can normalize vastly different situations, from low income to high income, without daily recognition of their circumstances. This adaptability is the core psychological phenomenon of the episode.
  • 00:06:57 — Application to Junior Developers and Career Growth — The discussion shifts to why normalization matters for developers. For those starting out, writing code, applying for jobs, and facing constant errors feels abnormal and overwhelming. The host offers encouragement: this feeling is temporary. Through repetition and persistence, these challenges become normal, and developers adapt, learn, and grow, demonstrating their inherent resilience.
  • 00:08:48 — The Danger of Normalizing Bad Practices — The host presents the flip side of adaptability: the risk of normalizing poor habits, like not writing tests. When a bad practice becomes the default, changing it requires significant energy to overcome the established ‘normal.’ This highlights the passive danger of not being intentional about our standards.
  • 00:09:11 — The Solution: Intentionally Setting the Ideal as Normal — The host provides the actionable takeaway. Since normalization is inevitable, developers must consciously decide what their ‘normal’ will be. The goal is to set the ‘ideal state’—practicing quality code, testing, etc.—as the default behavior from the beginning. By trudging through the initial abnormality of high standards, you make excellence your average, preventing your potential from being limited by a low baseline.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-06-20T09:00:00Z
  • Duration: 00:12:54

References

Podcast Info

Transcript

[00:00:00] What does it mean to get used to something?

[00:00:07] When I’m recording this podcast, I’m very aware of something called the signal-to-noise ratio.

[00:00:15] The signal, in this case, is the sound of my voice.

[00:00:19] You can hear the words that I’m saying, and you can hear the enunciation,

[00:00:23] and then the tone going up, or the tone coming down.

[00:00:27] And so I’m very aware because if we have a bad signal-to-noise ratio,

[00:00:35] in other words, if the noise becomes too high, then it becomes very difficult to hear my voice.

[00:00:42] And there’s a lot of things that can contribute to the noise.

[00:00:45] You can have background noise in the room, and you can also have background noise like static

[00:00:50] that can come from some kind of source in the line from the microphone to the interface.

[00:00:57] And so it’s very important that we’re paying attention to this,

[00:01:00] because if we have a high noise ratio, then it’s very likely that we’re going to lose you as listeners.

[00:01:07] Now, why is this relevant to today’s episode?

[00:01:09] Well, we’re talking about a phenomenon today that has to do with this signal-to-noise ratio,

[00:01:16] and not specifically with audio engineering, instead with our behavior as humans.

[00:01:21] My name is Jonathan Cottrell, and you’re listening to Developer Tea.

[00:01:24] And my goal in this show is to help driven developers like you

[00:01:27] connect to your career purpose, and help you do better work

[00:01:32] so you can have a positive influence on the people around you.

[00:01:35] And so in today’s episode, we’re talking about this idea of getting used to something.

[00:01:40] And more specifically, we’re talking about how we get used to the normal.

[00:01:46] Now, what do we mean when we say that something is normal?

[00:01:51] If you meet somebody, let’s say your neighbor,

[00:01:54] their normal is very likely to be,

[00:01:57] somewhat similar to yours.

[00:01:59] You have the same type of weather,

[00:02:01] very likely you live in a very similar living situation,

[00:02:06] whether you’re in an apartment or a house,

[00:02:08] if they’re next door to each other, then they’re most likely quite similar to each other.

[00:02:13] In most areas of the country,

[00:02:15] the people who are your neighbors are probably kind of like you,

[00:02:19] for other reasons that you can’t quite put your finger on.

[00:02:22] For whatever reason, you ended up in a similar location,

[00:02:25] because you have similar backgrounds.

[00:02:27] You have similar life stories.

[00:02:29] Very often, this is the case.

[00:02:31] And so what is normal for you seems to be normal for your neighbor as well.

[00:02:36] However, if you compare yourself to someone, let’s say in a different state,

[00:02:41] and even more in a different country,

[00:02:44] then normal becomes a relative term.

[00:02:47] What’s normal for you is not necessarily normal for them.

[00:02:51] Here’s the amazing thing about getting used to something

[00:02:54] and what becomes normal.

[00:02:57] We’re very adaptive creatures.

[00:03:01] We understand our situation and we adapt to it.

[00:03:06] And this adaptability can go to pretty far reaching lengths.

[00:03:11] Of course, it doesn’t necessarily come without consequences,

[00:03:14] but some people can adapt to very low income conditions

[00:03:20] and still live relatively, to them, normal lives.

[00:03:25] They don’t feel they’re low income.

[00:03:27] They don’t feel they’re living with a high income every single day.

[00:03:29] And similarly, on the other end of the scale,

[00:03:32] people can adapt to very high income situations

[00:03:35] and not really recognize on a day-to-day basis

[00:03:39] that they’re living with a high income.

[00:03:41] Things become normal.

[00:03:44] Now, why does this matter to you as a developer?

[00:03:47] We’re going to talk about that right after we talk about today’s sponsor, Datadog.

[00:03:51] Datadog is a new sponsor for DeveloperTee.

[00:03:55] It is a SaaS-based monitoring platform,

[00:03:57] that provides dev and ops teams with a unified view

[00:04:01] of all of their systems, their apps, and their logs.

[00:04:05] With thousands of organizations relying on Datadog to collect,

[00:04:09] visualize, and alert on out-of-the-box and custom metrics

[00:04:14] to gain full stack observability

[00:04:16] with a unified view of all their systems, apps, and services at a cloud scale,

[00:04:21] Datadog is combining infrastructure monitoring,

[00:04:24] applications, performance management,

[00:04:27] and log management into one platform

[00:04:29] to let you navigate and correlate them seamlessly.

[00:04:33] Datadog has over 200 turnkey integrations,

[00:04:36] including things like Docker and Go,

[00:04:40] Microsoft Azure,

[00:04:41] Amazon Web Services, Chef,

[00:04:44] tons of things that you can look at.

[00:04:46] And it’s all in this really rather nice back-end graphing,

[00:04:50] kind of chart visualization that you can see.

[00:04:54] You can get started with a free trial of Datadog, too.

[00:04:56] So go ahead and sign up for a free trial of Datadog today,

[00:04:59] and they’re going to send you a t-shirt for free.

[00:05:02] Datadog, this is actually the first time, I believe,

[00:05:04] that we’ve had free t-shirts sent out

[00:05:06] as a result of signing up for a free trial.

[00:05:09] So go and check it out.

[00:05:10] Datadog.com slash developer T.

[00:05:13] That’s all one word.

[00:05:14] Datadog.com slash developer T.

[00:05:17] Thank you so much to Datadog for sponsoring today’s episode

[00:05:21] and future episodes of Developer T.

[00:05:24] So we’re talking about the baseline.

[00:05:25] When things become normal.

[00:05:28] And this is a psychological phenomenon

[00:05:31] that we have seen over and over in studies.

[00:05:34] I haven’t done the research,

[00:05:36] but the research has been done to show that this happens,

[00:05:39] that we become used to the norm.

[00:05:42] For example, Dan Ariely’s team at Duke

[00:05:45] has shown that as people lie,

[00:05:48] when they lie the first time,

[00:05:51] they have a very strong response.

[00:05:54] It’s a very strong emotional response.

[00:05:57] But as they continue to lie,

[00:05:58] that emotional response is lowered.

[00:06:01] Now that’s because what was normal

[00:06:04] before the first lie was honesty.

[00:06:07] And so that first lie is out of the norm.

[00:06:10] However, as a person continues to lie,

[00:06:13] it becomes less out of the norm.

[00:06:16] And in fact, it becomes normal.

[00:06:18] And so what we normally would experience

[00:06:21] as a high signal-to-noise ratio,

[00:06:23] in other words, whatever the baseline is,

[00:06:26] whenever we experience a new event,

[00:06:28] an abnormal event,

[00:06:30] that’s going to have kind of a spike.

[00:06:33] And we actually will think about these things more.

[00:06:37] This is the basis of previous episodes.

[00:06:40] We’ve talked about,

[00:06:41] if you want to remember your day,

[00:06:43] then take a new way home.

[00:06:45] Forcing your brain to kind of adjust

[00:06:49] to abnormal circumstances,

[00:06:51] this is a good way to lie.

[00:06:52] This is a good way to learn new things as well.

[00:06:55] But why does this matter so much to developers?

[00:06:57] Well, it starts with junior developers.

[00:07:00] It starts with entry-level developers,

[00:07:02] people who are writing their very first line of code.

[00:07:05] It’s important to realize

[00:07:07] that it’s going to feel strange.

[00:07:10] And it may feel strange for a while.

[00:07:12] It may not feel normal for a while

[00:07:14] for you to write code.

[00:07:16] And if you’re applying to an internship

[00:07:18] or to a job,

[00:07:20] it may feel quite abnormal.

[00:07:22] You may be reading a job description

[00:07:25] and feeling like you don’t measure up.

[00:07:27] And this is a very common problem with developers.

[00:07:30] We’ve talked about it a hundred times on this show.

[00:07:33] But here’s the reality.

[00:07:35] As you continue walking down that path,

[00:07:38] it will become normal.

[00:07:40] And there’s a little bit of

[00:07:43] kind of encouragement in this reality,

[00:07:46] in this psychological phenomena,

[00:07:48] that we’re resilient.

[00:07:49] We start to learn how to adapt

[00:07:52] to our new circumstances.

[00:07:54] As a developer,

[00:07:55] in the early days of development,

[00:07:57] you may feel totally swamped.

[00:08:00] You’re constantly seeing errors.

[00:08:02] You don’t know what’s going on.

[00:08:04] And eventually,

[00:08:05] eventually, this becomes normal.

[00:08:08] And you start to learn and overcome those errors.

[00:08:11] And you’ll have new challenges

[00:08:13] that shake up your perspective of normal.

[00:08:16] But remember,

[00:08:18] eventually, things become normal.

[00:08:20] And as you

[00:08:22] experience these same things over and over,

[00:08:24] as you have these spikes of abnormality,

[00:08:27] remind yourself,

[00:08:29] you will adapt.

[00:08:31] You are built for adaptability.

[00:08:34] Of course, with every good thing,

[00:08:36] you also have kind of a bad version

[00:08:39] of the same good thing.

[00:08:41] So you may, for example,

[00:08:43] have become accustomed

[00:08:45] to bad practices.

[00:08:48] For example,

[00:08:49] if you have become accustomed

[00:08:51] to not testing your code,

[00:08:53] that has become the normal.

[00:08:55] It’s become the way that you think

[00:08:57] and the way that you operate.

[00:08:59] And so in order to test your code,

[00:09:02] you’re going to have to trudge through

[00:09:04] the abnormality of testing the code

[00:09:07] until you become used to it.

[00:09:09] So how can we become better developers

[00:09:11] with this knowledge in mind?

[00:09:13] Well, first of all,

[00:09:14] we should set up the ideal state

[00:09:17] as our normal.

[00:09:19] In other words,

[00:09:20] we should practice quality code

[00:09:23] as the default behavior.

[00:09:26] If we don’t have standards developed,

[00:09:29] then eventually,

[00:09:30] we will find a default behavior.

[00:09:32] There will be a normal.

[00:09:34] There will be a normal.

[00:09:35] There’s no way to avoid normalization.

[00:09:38] This is kind of the way

[00:09:39] that our brains naturally work

[00:09:41] to save energy and to protect us

[00:09:44] so that we have predictability.

[00:09:46] If we don’t intentionally craft

[00:09:48] that normality,

[00:09:50] if we don’t choose what will be normal,

[00:09:53] that normality is very likely

[00:09:55] to fall to kind of a lowest common denominator.

[00:09:59] In other words,

[00:10:00] you’re going to skip some of the things

[00:10:02] that are difficult,

[00:10:03] that are taxing,

[00:10:05] that take a certain amount of energy.

[00:10:09] We’ve talked about this

[00:10:10] somewhat extensively on the show.

[00:10:12] We’ve referred back to this episode

[00:10:13] many different times.

[00:10:15] But we talk about having useful defaults,

[00:10:18] not only in our code,

[00:10:20] but as human beings.

[00:10:22] Having good defaults,

[00:10:24] healthy defaults.

[00:10:26] That means setting up your normal

[00:10:28] to be the ideal scenario.

[00:10:32] Don’t allow the ideal scenario

[00:10:34] to be abnormal.

[00:10:36] If you have to add extra energy

[00:10:39] in every scenario

[00:10:41] in order to reach a good state,

[00:10:44] in order to overcome the bad normal,

[00:10:48] then much of your time

[00:10:49] will be spent below the bar.

[00:10:52] You won’t learn,

[00:10:53] you won’t grow,

[00:10:54] and very often,

[00:10:56] you’ll end up limiting your potential

[00:10:58] as a developer.

[00:11:00] So I encourage you,

[00:11:01] when you’re setting the bar,

[00:11:03] remember the bar is the normal.

[00:11:06] Set the bar where you want it to be.

[00:11:09] Trudge through that abnormality.

[00:11:12] Decide in advance

[00:11:14] how you want your work to look.

[00:11:17] Make your average

[00:11:18] excellent.

[00:11:21] Thank you so much

[00:11:22] for listening to today’s episode

[00:11:23] of Developer Tea.

[00:11:24] And thank you again to Datadog

[00:11:26] for sponsoring today’s episode.

[00:11:27] Remember, you can get your free T-shirt

[00:11:29] by heading over to datadog.com

[00:11:31] slash developer tea.

[00:11:33] You can start a free trial,

[00:11:35] and that’s how you’ll get

[00:11:36] that free T-shirt.

[00:11:37] An excellent product

[00:11:39] for keeping tabs

[00:11:40] on all of your apps and services.

[00:11:43] Again, datadog.com

[00:11:44] slash developer tea.

[00:11:45] Thank you so much for listening

[00:11:46] to today’s episode.

[00:11:47] I hope you were encouraged,

[00:11:49] first of all,

[00:11:50] and then also challenged,

[00:11:51] challenged to raise the bar

[00:11:53] for what is normal,

[00:11:55] what you’re willing to accept

[00:11:57] as a regular practice

[00:11:59] as a developer.

[00:12:00] Thank you so much for listening.

[00:12:01] Thank you again for subscribing,

[00:12:04] for those of you who have subscribed,

[00:12:06] and especially for those of you

[00:12:08] who have taken the time

[00:12:09] to leave a review.

[00:12:10] I read every single review

[00:12:12] that is left in iTunes,

[00:12:13] and I appreciate all of the advice

[00:12:16] and all of the kind words

[00:12:18] that you all have said to me

[00:12:19] in those reviews.

[00:12:20] I’m going to share some of those

[00:12:21] in future episodes,

[00:12:23] so I encourage you

[00:12:24] to leave a review

[00:12:25] if you would like to contribute

[00:12:27] to Developer Tea,

[00:12:28] but also help other developers

[00:12:30] find the show.

[00:12:31] Lastly, if you have not yet subscribed,

[00:12:33] before this podcast is over,

[00:12:35] I encourage you to subscribe

[00:12:37] in whatever podcasting app you use

[00:12:38] so you don’t miss out

[00:12:39] on future episodes

[00:12:40] just like this one.

[00:12:42] Thank you so much for listening,

[00:12:43] and until next time,

[00:12:44] enjoy your tea.

[00:12:46] Thank you.

Visão de gráfico