Vox

Leitura de 15 min

Practicing Non-Attachment as a Developer

Summary

In this episode of Developer Tea, host Jonathan Cottrell delves into the philosophical concept of non-attachment and its critical application in a developer’s professional life. He begins by framing non-attachment as a universal idea present across many religions and philosophies, relevant regardless of one’s personal beliefs, and positions it as a tool for improving work and reducing personal suffering.

Cottrell illustrates the problem of attachment through a relatable story: a junior developer, having invested significant time and emotional effort into a piece of code, reacts defensively to a senior developer’s constructive feedback. The junior’s protest—“you don’t know how much time I’ve spent on this”—is identified as a classic picture of attachment, where the developer’s identity and sense of worth become entangled with their work output, blinding them to objective improvement.

The discussion connects this to the ‘sunk cost fallacy,’ where past investment irrationally inflates the perceived value of current work. Cottrell explains that attachment leads to bias, poor decision-making, an unwillingness to learn, and ultimately unhappiness and professional stagnation. He emphasizes that developers must constantly work to identify and combat these ego-driven attachments.

To practice better detachment, Cottrell suggests several strategies: cultivating mindfulness through meditation or accountability partners; establishing procedural safeguards like structured code review cultures that normalize constructive criticism; and, most importantly, regularly zooming out to gain perspective. This involves reminding oneself that the world does not revolve around you, recognizing the temporary nature of all work and code, and understanding that both failures and successes are fleeting.

He concludes by encouraging listeners to practice active non-attachment as a way to navigate inevitable frustrations and catastrophic failures in a career. By letting go of ego and detaching from both failures and successes, developers can remain open to learning, improvement, and forward movement, ultimately becoming better mentors and more resilient professionals.

Recommendations

Concepts

  • Non-Attachment / Detachment — The central philosophical concept of the episode, presented as a practice to avoid identifying too closely with one’s work, code, successes, or failures to improve decision-making and happiness.
  • Sunk Cost Fallacy — Referenced as a cognitive bias that heavily contributes to attachment issues, where past investments (time, effort) lead us to overvalue current outcomes and resist necessary change.
  • Apatheia — Mentioned as a Greek word used by some religions related to the concept of non-attachment or detachment from passions.

Practices

  • Mindfulness / Meditation — Suggested as a personal practice to create an interruption in automatic, attachment-driven behaviors, allowing for more conscious decision-making.
  • Structured Code Review — Recommended as a procedural way to instill mindful behavior and intentionally normalize constructive, critical feedback within a team’s culture.

Topic Timeline

  • 00:00:00 — Introducing the concept of non-attachment — Host Jonathan Cottrell introduces the episode’s theme: applying the broad philosophical concept of non-attachment or detachment to a developer’s work and life. He frames it as a tool for positive impact regardless of personal beliefs.
  • 00:01:45 — Story of the junior and senior developer — Cottrell shares a story about a junior developer who reacts defensively to a senior developer’s feedback on their code. The junior protests that the senior doesn’t understand the time and effort invested, illustrating a core example of emotional attachment to one’s work.
  • 00:05:02 — Analyzing attachment and the sunk cost fallacy — Returning to the story, Cottrell analyzes the situation. He explains how different perspectives (one aware of the effort, one not) lead to different valuations of the code. This connects to the ‘sunk cost fallacy’ and how attachment can cause pain, bias, poor decisions, and stagnation.
  • 00:08:54 — Strategies for practicing detachment — Cottrell offers practical ways to cultivate detachment. These include practicing mindfulness (meditation, accountability), establishing procedural checks like code review cultures, and most importantly, gaining perspective by reminding oneself that the world doesn’t revolve around you and that all work is temporary.
  • 00:12:01 — The importance of detachment for resilience — The host emphasizes that detachment is crucial for everyone, from developers to managers. He states that everyone will experience frustration and failure, and attaching to those failures prevents moving forward. He encourages practicing active non-attachment to let the ego ‘die’ and remain open to growth.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-11-30T10:00:00Z
  • Duration: 00:14:55

References

Podcast Info

Transcript

[00:00:00] As we often do on the show, in today’s episode, we’re going to discuss a concept

[00:00:10] that extends beyond development, and we’re going to bring it into focus as it relates

[00:00:17] to your life, your job as a developer, the work that you do.

[00:00:25] This concept is present in many different religions and philosophies, whether those

[00:00:32] religions are theistic or not.

[00:00:36] Regardless of your values, regardless of your beliefs, this concept could have a positive

[00:00:42] effect on your work, on your development work.

[00:00:48] My name is Jonathan Cottrell.

[00:00:49] You’re listening to Developer Tea.

[00:00:51] My goal on the show is to help driven developers like you connect to your career purpose and

[00:00:56] do better work so you can have a positive influence on the people around you.

[00:01:02] In today’s episode, we’re discussing the concept of non-attachment, sometimes called

[00:01:08] detachment.

[00:01:10] This word is incomplete because there’s so many other words that describe this.

[00:01:19] One word might be apotheia.

[00:01:22] This was a Greek word that is used by a couple of religions related to this concept, but

[00:01:30] let’s take out any religious background at all for the sake of the discussion.

[00:01:36] What exactly is detachment?

[00:01:38] What is non-attachment?

[00:01:41] First I want to tell you a story that you’re probably familiar with.

[00:01:45] Hopefully you’ll see yourself in this story.

[00:01:48] There was a senior developer that was talking to a junior developer, and the junior developer

[00:01:55] had brought some code to the senior developer, and the senior looks at the junior developer’s

[00:02:01] code and starts to provide some feedback.

[00:02:06] The feedback ultimately has the junior developer thinking that they’re going to need to rewrite

[00:02:12] major portions of this code.

[00:02:16] The code wasn’t very long, 100 lines or maybe 150 lines, something like that, but the junior

[00:02:22] developer had spent quite a long time on this code.

[00:02:28] They’d gone back and forth, tried a bunch of different things, failed a lot along the

[00:02:32] way, and ultimately they arrived where they were through a lot of pain and toil and a

[00:02:39] lot of work, a lot of investment on their part.

[00:02:44] The senior developer didn’t know this, of course, but was looking at the code for essentially

[00:02:50] what it was, providing feedback for what they saw in front of them.

[00:02:55] From the senior developer’s perspective, this code was exactly what it was.

[00:03:03] There was no context of the amount of work that had gone into it, and so the junior developer

[00:03:09] begins to kind of protest against this feedback.

[00:03:13] The junior developer looks at the senior developer and says, well, you don’t know how much time

[00:03:18] I’ve spent on this, how much this means to me, and how long I thought about this code.

[00:03:30] This is a picture of attachment.

[00:03:34] We’ll come back in just a moment and kind of finish out this story and learn how we may

[00:03:38] be able to detach in useful ways.

[00:03:43] First, I want to talk about today’s sponsor, DigitalOcean.

[00:03:47] DigitalOcean is the easiest cloud platform to run and scale your applications.

[00:03:53] This is pain-free development with DigitalOcean.

[00:03:57] From effortless administration tools to robust compute, storage, and networking services,

[00:04:03] DigitalOcean provides an all-in-one cloud platform to help developers like you and your

[00:04:09] teams save time when running and scaling your applications.

[00:04:13] With DigitalOcean, you get predictable and affordable pricing.

[00:04:16] You also get industry-leading price-to-performance ratios.

[00:04:19] So it’s not just about, you know, reducing your pain.

[00:04:23] It’s also incredibly affordable.

[00:04:27] Pricing is consistent from month to month, and it’s consistent across regions at any

[00:04:31] usage volume, and you get these bonuses, like, for example, monitoring and alerting are included

[00:04:38] with DigitalOcean.

[00:04:39] Now, if this wasn’t enough to convince you to go and check it out, then DigitalOcean

[00:04:43] is going to throw down $100 worth of credit on the table for you to pick up.

[00:04:48] That’s totally yours.

[00:04:49] $100 credit by heading over to do.co.tea.

[00:04:57] Thank you again to DigitalOcean for sponsoring today’s episode of Developer Tea.

[00:05:02] So this senior developer is talking to the junior developer and giving them feedback,

[00:05:08] explaining to them how they may make their code better.

[00:05:13] They may improve it towards their common goals.

[00:05:17] And this isn’t the first picture of attachment in human history, certainly not in our time,

[00:05:25] but also over the course of pretty much as long as humans have been able to communicate.

[00:05:31] We are not in control of everything that happens to us.

[00:05:34] That’s true even before we had communicated language.

[00:05:37] We can simply not control everything that happens to us.

[00:05:42] Sometimes we can’t control how long we have to spend on code to produce ultimately something

[00:05:48] that still needs more improvement.

[00:05:51] And so we end up in these scenarios where we want one thing, but reality is producing

[00:06:00] something different.

[00:06:02] Call it whatever you want, use whatever term you want.

[00:06:06] The current situation for this junior developer who’s talking to the senior developer is that

[00:06:11] they don’t have the code that the senior developer would kind of sign off on.

[00:06:19] The code is not yet there.

[00:06:22] And so regardless of what has happened, regardless of what is in the past, the code would still

[00:06:28] need work.

[00:06:29] The code still has room for improvement.

[00:06:33] If you’ve listened to the show for very long, then you may have heard us talk about something

[00:06:38] called the sunk cost fallacy.

[00:06:40] And this plays heavily into our attachment issues.

[00:06:44] This isn’t the only reason we become attached to things, but in this case, if you have two

[00:06:49] different perspectives looking at this code, one that has seen and endured all of the pain

[00:06:56] that it took to produce this code, and another perspective that hasn’t seen that pain, then

[00:07:03] the value placed on that code is likely to be very different.

[00:07:09] Our nature values the experiences that we’ve had, and we keep these mental accounting ledgers.

[00:07:16] The amount of time I’ve invested in something must make it worth more.

[00:07:21] But very often as developers, this is simply not true.

[00:07:25] And so our attachment issues, the things that we kind of put our identities next to,

[00:07:33] our signature, the things that we care about deeply, that we can’t always necessarily

[00:07:40] directly control, those can be sources of pain, of bias, of poor decision making, of

[00:07:49] a unwillingness to learn to improve.

[00:07:54] And ultimately, they can make us deeply unhappy, resentful people.

[00:08:00] This is not where we want to end up.

[00:08:04] And so we have to work all of the time to identify things that we are attached to.

[00:08:10] We have to work all of the time to fight our egos as developers, to avoid situations where

[00:08:19] we’re so married to our own opinions that we end up losing.

[00:08:26] We end up not accomplishing the goals that we want to accomplish.

[00:08:29] We end up not learning the things that we want to learn.

[00:08:33] And very often we end up isolated and stagnated.

[00:08:37] These are things that none of us really want.

[00:08:40] And yet we perpetuate these things by feeding our attachment.

[00:08:45] We allow our attachment to grow rather than consistently trying to detach.

[00:08:51] So how can we detach better?

[00:08:54] Well, we talked about ways that we can check our egos.

[00:08:57] We can constantly practice this.

[00:09:01] Of course, maintaining a mindful outlook on your work, on your own behavior, this is incredibly

[00:09:08] important to being able to detach.

[00:09:12] Attachment is something that kind of happens automatically.

[00:09:15] So for the things that happen automatically, you as the person that is kind of operating

[00:09:21] in this automatic way, you have to put some kind of trip, some kind of interruption into

[00:09:28] that automatic behavior.

[00:09:30] Something that will trigger to allow you to recognize when it’s happening.

[00:09:34] So maybe you can make a conscious decision in that moment rather than making an unconscious

[00:09:41] automatic decision.

[00:09:42] And there are many ways that you can practice mindfulness.

[00:09:45] Some of them are your own practice, like for example, meditation, other things like asking

[00:09:51] someone around you to hold you accountable, to call out behaviors that when you’re thinking

[00:09:57] about it, you don’t really want to participate in, but sometimes you automatically do.

[00:10:02] Establishing procedural ways to instill mindful behavior.

[00:10:09] This would be things like code review and having rules for your code review, having

[00:10:15] a culture that you’ve developed around reviewing code that intentionally kind of forces negative

[00:10:24] feedback to make its way into your normal everyday procedures.

[00:10:30] But ultimately, perhaps the most important thing you can do on a regular basis is remind

[00:10:36] yourself that you’re not the only one.

[00:10:40] The world is not revolving around you.

[00:10:43] The universe is not revolving around you.

[00:10:46] Your job is not simply there to serve you.

[00:10:51] It’s easy to kind of automatically believe this we’re wired to survive and we’re wired

[00:10:56] to make ourselves the most important part of our own stories.

[00:11:00] But if we can climb out of our own heads for a moment and try to zoom out, try to think

[00:11:07] about things that go beyond us.

[00:11:09] For example, take a moment and try to imagine what the world was like before you were here

[00:11:16] and what the world will be like after you’re gone.

[00:11:20] What your workplace will be like when you’ve moved on.

[00:11:24] When you realize that everything is temporary, then attachment kind of melts away, kind of

[00:11:30] dissolves, it becomes dissonant with the way that you see your work because you know that

[00:11:37] your work is temporary.

[00:11:40] And to attach yourself to something that is temporary, that’s not really a good idea.

[00:11:44] That feels more dangerous.

[00:11:47] It feels risky.

[00:11:49] So instead, you can zoom out and recognize the temporal nature of pretty much everything

[00:11:54] that you experience.

[00:11:56] All of the things that you do and detach from that.

[00:12:01] Allow them to be what they are.

[00:12:04] Remind yourself as the junior developer that the code that you write, no matter how good

[00:12:10] or how bad it is, you will move on from it.

[00:12:14] And remind yourself as a senior developer that when you’re providing things like code

[00:12:18] review and really you can provide code review at any stage in your career, but as a senior

[00:12:24] developer, when you’re providing code review, remember that things once again are temporal

[00:12:30] and pass this on.

[00:12:33] Try to remember that there is some active detachment that needs to occur for everyone

[00:12:39] and encouraging junior developers who are looking up to you as the senior developer

[00:12:45] to not put their worth into their code, to not get so attached to it that they’re afraid

[00:12:52] to change it.

[00:12:54] That’s the kind of advice that you can get from a true mentor.

[00:12:59] Someone who cares about you more than they care about your performance.

[00:13:04] They care about you beyond your performance.

[00:13:07] A detachment is important across the board.

[00:13:09] It’s important for us as developers.

[00:13:12] It’s important for people who are managing product, for example, anybody who’s dealing

[00:13:17] with clients, because you will experience frustration, loss.

[00:13:22] You will experience absolute and utter failure.

[00:13:27] Most people will experience some kind of catastrophic failure, things that we may never see coming

[00:13:33] until they’re already passed, until they’ve already happened.

[00:13:37] We will experience these things.

[00:13:39] And if we allow ourselves to attach to those failures, then we unfortunately can’t look

[00:13:45] forward.

[00:13:46] We can’t improve.

[00:13:47] We can’t move on.

[00:13:48] So I encourage you to practice active detachment, active non-attachment, active apathia, whatever

[00:13:56] word you want to use and whatever philosophy you come from, practice this moment of letting

[00:14:03] your ego die.

[00:14:06] Thank you so much for listening to today’s episode of Developer Tea.

[00:14:09] I realize this is a little bit of a heavy episode, but hopefully you were inspired by

[00:14:14] it and hopefully this is helpful for you.

[00:14:17] For those of you who are struggling with, for example, your own failures, this actually

[00:14:21] can be an uplifting thing to allow yourself to detach from those failures and also, by

[00:14:27] the way, detach from your successes as well.

[00:14:31] Thank you so much for listening to today’s episode.

[00:14:33] Thank you again to Digital Ocean for sponsoring today’s episode.

[00:14:36] You can get $100 worth of credit by heading over to do.co.t, that’s do.co.t-e-a.

[00:14:44] Thank you so much for listening and until next time, enjoy your tea.

Visão de gráfico