Vox

Leitura de 15 min

Habits of Successful Software Engineers - Seeking Feedback

Summary

This episode introduces a series on the habits of successful software engineers, focusing on the importance of translating skills into consistent daily action through habits. The host, Jonathan Katra, explains that skills alone are insufficient without the ability to apply them regularly, and that habits—supported by personal systems and cultural contexts—are what drive consistent results.

The core habit explored in this episode is seeking feedback. Successful software engineers actively seek feedback from various sources including machines, teammates, stakeholders, and users. The host distinguishes between two main types of feedback: execution feedback, which involves retrospective analysis of work outcomes, and emotional feedback, which relates to interpersonal dynamics and unspoken cues from colleagues and users.

A key insight is that feedback should not be oversimplified into binary ‘good’ or ‘bad’ categories, as reality is often more nuanced. The host emphasizes the importance of recognizing when feedback is ‘noisy’—distorted by incomplete information or communication barriers—and developing the discernment to extract valuable insights despite this noise.

The episode concludes by discussing how to systematically respond to feedback by making specific commitments to change behaviors. This process of constant refinement based on feedback is presented as essential for long-term success and growth as a developer.

Recommendations

Books

  • Atomic Habits by James Clear — Recommended as a resource for understanding how humans build habits, based on research about habit formation. The host encourages developers to become students of habit building.

Tools

  • Linode — Cloud hosting service offering SSD servers, dedicated CPU instances, and worldwide data centers. The host mentions it can be used for video encoding, game servers, busy applications, distributed apps, hosted services, websites, and CI/CD environments.

Topic Timeline

  • 00:00:00 — Introduction to habits of successful software engineers — Jonathan introduces the series, explaining that skills alone are not enough for success—they must be translated into consistent daily action through habits. He discusses how habits are supported by systems and cultural contexts, and mentions the book ‘Atomic Habits’ by James Clear as a resource for understanding habit formation.
  • 00:05:52 — Sponsor message from Linode — The host presents a sponsorship message for Linode, a cloud hosting service. He describes Linode’s features including SSD servers, dedicated CPU instances, and worldwide data centers, and offers a $20 credit for new customers using the code ‘developerT2019’.
  • 00:07:28 — The habit of seeking feedback — Jonathan introduces the main habit for this episode: successful software engineers seek feedback. He explains that feedback can come from machines, coworkers, stakeholders, and users, and emphasizes that the most important feedback comes from people affected by your work.
  • 00:08:28 — Types of feedback: execution and emotional — The host distinguishes between execution feedback (retrospective analysis of work outcomes) and emotional feedback (interpersonal dynamics and unspoken cues). He cautions against oversimplifying feedback into binary ‘good/bad’ categories and discusses the challenges of noisy feedback environments.
  • 00:13:14 — Jonathan discusses how successful engineers not only seek feedback but also respond to it systematically. He explains that making specific commitments to change behaviors based on feedback helps embed new habits, leading to constant refinement and increased likelihood of success as a developer. — Responding to feedback systematically

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2019-03-01T10:00:00Z
  • Duration: 00:15:01

References

Podcast Info

Transcript

[00:00:00] you already know that you need skills to be a developer these are things that you work hard for

[00:00:13] you spend time learning and practicing and failing beyond just the skills that you need and we’re

[00:00:22] including soft skills here too there’s still more to the job than amassing a bunch of skills

[00:00:30] you could be a very talented developer but if you’re not able to translate those skills

[00:00:37] into daily action then the skills don’t really matter so we’re going to spend a few episodes

[00:00:46] of developer tea talking about the habits of successful software

[00:00:52] engineers and this isn’t going to be only one kind of engineer this isn’t just for back end or

[00:00:59] just for front end so we’re going to cover a lot of ground and there’s going to be some abstract

[00:01:04] conversations but we’re going to try to use as many concrete explanations or examples as possible

[00:01:13] so that you can connect to this and start to kind of shape your list of habits

[00:01:20] my name is jonathan

[00:01:22] katra

[00:01:22] you’re listening to developer tea and my goal on this show is to help driven developers find

[00:01:27] clarity perspective and purpose in their careers and if you’ve been listening for very long and

[00:01:33] paying attention to the intros of the show then you might notice that we changed that goal a little

[00:01:39] bit previously the goal was stated as to help driven developers connect to their career purpose

[00:01:45] and do better work so they can have a positive influence on the people around them and we still

[00:01:49] care about that we still want to

[00:01:52] empower developers to find something that they care deeply about and empower them to do better

[00:02:00] work as developers but we’ve added to this goal we’ve added the concept that there’s more to

[00:02:08] being a developer and being a human than constantly seeking after some singular purpose

[00:02:17] sometimes that is too reductive

[00:02:21] it doesn’t matter if you’re a developer or a developer and you’re a developer and you’re a developer

[00:02:22] it doesn’t give us a chance to experience things that are totally different in life and may even

[00:02:28] feel like a rule and that’s not the goal the goal of this show instead is to inspire developers to

[00:02:37] open up not close down so hopefully this new stated message captures that intent and hopefully

[00:02:46] those of you who were listening because you connected with the old goal that old message you

[00:02:52] still feel the same connection so we’re talking about this idea that your talent or your skills

[00:03:00] really realize their value when you put them into action and more importantly not just a single

[00:03:10] action you can’t show off your skills once and then ride on that for the remainder of your career

[00:03:15] wouldn’t really be rewarding for you either so what we’re talking about here is the idea that you’re

[00:03:22] consistent action and the things that are consistent for humans are the things that we do

[00:03:29] almost automatically the things that we do by default our habits and often those habits are

[00:03:37] supported by the systems that we surround ourselves with they are perhaps influenced by

[00:03:45] our small kind of mini cultures the company that we work for or the family

[00:03:52] that we’re a part of and our larger cultures maybe the city or the state or the country

[00:03:58] that we participate in and then the virtual cultures that we’re a part of like an online

[00:04:05] community even the people who listen to this podcast that’s creating a particular type of

[00:04:11] culture but habits are not all imposed on us we have the ability to develop our own habits

[00:04:20] if you want to look into

[00:04:22] the process of developing habits i encourage you to check out the book atomic habits by james clear

[00:04:29] this came out last year and proposes quite a lot of of research that has been done around the

[00:04:38] concept of habit and how we build habits as humans and i encourage you again to to become a student

[00:04:44] of this because whatever you repeat over and over and whatever you repeat regularly as in more often

[00:04:51] than not

[00:04:52] the results of those repeated actions are going to to kind of overtake whatever your other actions

[00:04:59] may be you’re much more likely to design your life based on your habits than on individual actions

[00:05:07] so as developers once we have kind of studied this this building of habits which we can talk

[00:05:14] about in another episode then what habits should we build what habits should we develop

[00:05:22] this is what we’re going to talk about in today’s episode and in a couple of future episodes of the show

[00:05:27] this isn’t going to be a back-to-back series it’s something that we’re going to talk about

[00:05:32] with some breaks in between so we can learn a little bit more about what successful software

[00:05:38] engineers what their habits are so that’s what we’re talking about in today’s episode we’re

[00:05:43] going to cover a couple of habits in today’s episode but first i want to talk to you about

[00:05:49] linode linode is today’s

[00:05:52] sponsor with linode you can instantly deploy and manage an ssd server in the linode cloud you can

[00:05:58] get a server running in just a few seconds with your choice of linux distribution resources and

[00:06:03] node location linode is now offering dedicated cpu instances what would you use this for well

[00:06:11] dedicated cpu instances are designed for consistent high performance computing needs for example if

[00:06:18] you wanted to encode video or maybe

[00:06:22] run a game server or if you have a very busy application this would be an excellent use case

[00:06:28] for a dedicated cpu all new customers right now of linode get a 20 credit and pretty much

[00:06:36] anything you can imagine building you can build it on linode you can have distributed applications

[00:06:42] hosted services websites even your own continuous integration and continuous delivery environments

[00:06:50] linode features

[00:06:52] native ssd storage a 40 gigabit internal network and industry-leading processors you can pick from

[00:06:59] any of linode’s nine worldwide data centers and they have two more data centers opening in canada

[00:07:05] and india this year get started today with a 20 credit by heading over to linode.com developer team

[00:07:12] and use the code developer t 2019 that’s the number developer t2019 at checkout linode.com

[00:07:20] slash developer t

[00:07:22] thanks again to linode for sponsoring today’s episode so we want to talk to you about one very

[00:07:28] important habit today and that’s why we’re only doing one there are some kind of sub habits of

[00:07:35] this particular habit but successful software engineers seek feedback this is the habit that

[00:07:43] i want to focus on today successful software engineers seek feedback now feedback can be

[00:07:52] the machine but the most important feedback that you’re going to get is from the people that you

[00:07:58] work with and the people that you work for pretty much anybody who is influenced in some way by the

[00:08:07] work that you do so it could be the users of your application it could be the other developers on

[00:08:14] your team it could be the stakeholders in whatever the product is that you’re building and anyone who

[00:08:22] is doing that work you can get feedback from them and there’s different types of feedback for example

[00:08:28] the most basic type of feedback is a kind of retrospective look into the past and as you are

[00:08:37] looking into the past you’re describing the things that you did and then trying to understand whether

[00:08:44] those were good things or bad things it’s very important when you do this and by the way this

[00:08:50] is something that a lot of people don’t know about but it’s something that a lot of people don’t know

[00:08:52] do but successful software engineers do have a habit of doing is not applying only good or bad

[00:09:00] labels to things for example a successful software engineer will accept that maybe they don’t know

[00:09:08] if a decision was good or bad or maybe a decision was good and bad to try to categorize things only

[00:09:17] into two different categories is likely an inaccurate representation of a good or bad

[00:09:22] representation of reality but it also may lead you to try to draw conclusions where there’s not

[00:09:30] enough information to draw conclusions from so this is a very basic type of feedback when you

[00:09:37] and the others that you’re working with whoever they are looks at something that was done and

[00:09:42] they provide some kind of information about it some kind of judgment about it typically this

[00:09:49] kind of retrospective feedback is a kind of feedback that you’re trying to draw conclusions from

[00:09:52] is what i would categorize as execution feedback think about execution feedback as feedback on the

[00:10:01] what imagine taking a snapshot of reality before and after the work was done or perhaps before and

[00:10:12] during the work was done the idea here is you’re not a human that is participating in the work but

[00:10:18] instead you’re looking at the results of that work and you’re trying to draw conclusions from

[00:10:22] that work and you’re trying to decide are the results good bad or maybe it’s more complicated

[00:10:27] than that maybe we don’t know yet right this is execution feedback there’s another kind of feedback

[00:10:35] though and successful software engineers especially the very successful software engineers

[00:10:42] focus perhaps as much or more on this type of feedback and that is emotional feedback

[00:10:49] what do you model for your work and what do you model for your work and what do you model for your

[00:10:52] behavior what do you model for your action and you should be performed in reverse you might as well

[00:10:55] explore how to select both things right so let’s say you want to select an outcome a characteristic

[00:11:00] texture and detail make a difference between agency behavior and the a 곤eter caller behavior

[00:11:05] you can find this Everycıbe are a set of spaces within this layer of Bakelburg

[00:11:14] 망 allora how do you

[00:11:18] integrate theseольшa

[00:11:20] premises

[00:11:21] provided to us. That feedback, once again, can come from a machine. This is more execution

[00:11:28] feedback. It can also come from daily interactions with our co-workers and watching users use the

[00:11:35] product. It doesn’t have to be labeled feedback for a successful software engineer to gain value

[00:11:44] from it. Sometimes that feedback is as simple as someone saying thank you, but sometimes the

[00:11:51] feedback is much more complicated. For example, you may have some intuitive sense that there’s

[00:11:58] conflict brewing between your teammates. And this kind of feedback, this unspoken feedback,

[00:12:07] unstructured feedback, is often where we get things wrong. In a previous episode, we talked

[00:12:14] about how we can get things wrong. And in this episode, we talked about how we can get things

[00:12:14] wrong. We talked about communication. We talked about the models of communication. And one of the

[00:12:20] important aspects of any kind of communication is the idea of noise. Noise can distort the feedback

[00:12:28] that we receive. And so when we have unstructured feedback systems, for example, when we’re trying

[00:12:36] to judge each other’s emotional states based on behavior, this is a very noisy environment to

[00:12:42] gather feedback from.

[00:12:44] And so successful software engineers recognize when the feedback they’re receiving is noisy.

[00:12:52] And this is true both for the emotional feedback and the execution feedback. Sometimes we don’t

[00:13:00] have all of the information we need to, for example, solve some kind of problem. Maybe there’s a bug in

[00:13:06] our software and we don’t have everything that we need. And so the report of the bug may have a lot

[00:13:12] of noise along with it.

[00:13:14] Ultimately, successful software engineers develop the habit of seeking feedback and then responding

[00:13:22] to it. Not only do we take feedback, but we decide what to do about that feedback. The more systematic

[00:13:33] you can make this, the more likely you are to embed those new behaviors into your daily habits.

[00:13:42] If you can say,

[00:13:43] Oh, I don’t think about this. I think about things today.

[00:13:43] I think about things today.

[00:13:44] I think about things today.

[00:13:44] I think about things today.

[00:13:44] I think about things today.

[00:13:44] I think about things today.

[00:13:44] I think about things today.

[00:13:44] I will stop doing X and start doing Y.

[00:13:49] This is a commitment that you make.

[00:13:51] When you receive some kind of feedback,

[00:13:53] you can make this commitment either to yourself

[00:13:55] or to the person who’s providing that feedback to you.

[00:14:00] This constant refinement of your habits

[00:14:03] is what will make you more likely to succeed as a developer.

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

[00:14:11] Thank you again to Linode for sponsoring today’s episode.

[00:14:15] You can get $20 worth of credit to go and get started

[00:14:18] with your Linode projects, whatever they are.

[00:14:22] You can build pretty much anything on Linode.

[00:14:24] Head over to linode.com slash developer T.

[00:14:27] Use the code developer T2019.

[00:14:29] That’s developer T2019 at checkout.

[00:14:33] Thanks again for listening to today’s episode.

[00:14:36] If you’ve enjoyed the episode

[00:14:38] and you don’t want to miss out on future episodes like this one,

[00:14:41] including more in this series,

[00:14:43] The Habits of Successful Software Engineers,

[00:14:46] I encourage you to subscribe

[00:14:47] in whatever podcasting app you are currently using.

[00:14:51] Thank you so much for listening.

[00:14:52] And until next time, enjoy your tea.

Visão de gráfico