DCR: Traits of a Great Developer - Grit of a Scientist

Summary

In this episode of Developer Tea, host Jonathan Cottrell continues his series on the traits of great developers, focusing on ‘the grit of a scientist.’ He begins by acknowledging the recent Hurricane Irma affecting his recording location and encouraging listeners to engage deeply with the show’s content through discussion and application.

Cottrell connects today’s topic to the previous episode’s discussion of ‘rational humility,’ explaining how recognizing one’s fallibility naturally leads to the need for perseverance. He introduces the concept of grit as the ability to stick with something through completion, emphasizing its importance for developers who often face uninteresting tasks, frustrating bugs, and the challenge of continuous learning. He warns against a ‘shotgun approach’ to learning new technologies and advocates for deeper, more focused study.

The core of the episode unpacks the ‘grit of a scientist.’ Cottrell contrasts the common perception of grit as simply ‘sticking to something until it succeeds’ with the developer’s reality of constant, small-scale failures. He argues that developers, like scientists, must develop the grit to not just endure failure, but to systematically observe, learn from it, and iterate. The antithesis—ignoring failures or pushing problems forward—leads to neglected, poor-quality codebases.

To cultivate this trait, Cottrell recommends a practical, iterative process mirroring the scientific method: setting hypotheses when approaching a problem, executing solutions, and crucially, evaluating the outcomes. He stresses that the evaluation step is most often missed but is essential for recognizing failure patterns and improving. The episode concludes by framing this gritty, scientific approach as a fundamental characteristic that separates good developers from great ones.

Recommendations

Books

Grit: The Power of Passion and Perseverance — Referenced by Angela Duckworth as the definitive book on the subject of grit, which is discussed as a core component of the developer trait.

Podcasts

Freakonomics — Mentioned as having an excellent episode on the subject of grit, providing another resource to learn about the concept.

Tools

Fuse — Sponsored tool described as an all-in-one platform for iOS and Android development that allows building apps with less code and better collaboration, similar to Unity for game dev.

Topic Timeline

00:00:00 — Introduction and Context from Hurricane Irma — Jonathan Cottrell opens the episode with an apology for potential rain sounds in the background, explaining he is recording in Tennessee after Hurricane Irma passed through. He sends thoughts to listeners in affected areas and introduces the show’s purpose: to help developers improve through short, focused episodes that require active engagement, discussion, and application.
00:01:50 — Introducing the Series on Traits of Great Developers — Cottrell states the episode’s topic: the traits that make a great developer. He references the previous episode’s trait, ‘rational humility,’ which is the foundation for learning—avoiding both false humility and arrogance. He explains that today’s trait, ‘the grit of a scientist,’ builds directly on this understanding of fallibility and the constant potential for error in development work.
00:04:03 — Defining Grit and Its Importance for Developers — Cottrell breaks down the trait into two parts: grit and scientist. He defines grit simply as the ability to stick with something and see it through, referencing Angela Duckworth’s work. For developers, this is crucial because work often involves uninteresting tasks, frustrating bugs, and the long-term commitment required for deep learning. He advises against a shallow ‘shotgun’ learning approach in favor of gritty, focused study on a few technologies.
00:09:02 — The Reality of Failure and the Scientist’s Grit — After a sponsor break for Fuse, Cottrell delves into the ‘scientist’ component. He challenges the idea that grit means sticking to something until it succeeds. Instead, developers face perpetual failure—most of a project’s life is moving from a failing to a non-failing state. The grit of a scientist means having the perseverance to recognize failure, learn from its components, and start a new experiment (iteration). Ignoring failure leads to poor, neglected codebases.
00:13:01 — How to Develop the Grit of a Scientist — Cottrell offers practical advice for cultivating this trait. He recommends an iterative process: set hypotheses when starting a problem, execute, and—most importantly—evaluate the results before reiterating. He emphasizes that the evaluation step is most commonly skipped but is vital for learning from failure and recognizing patterns. The key takeaway is to evaluate and reiterate upon encountering failure, not to blindly push forward.

Episode Info

Podcast: Developer Tea
Author: Jonathan Cutrell
Category: Technology Business Careers Society & Culture
Published: 2017-09-15T09:00:00Z
Duration: 00:14:52

References

URL PocketCasts: https://podcast-api.pocketcasts.com/podcast/full/cbe9b6c0-7da4-0132-e6ef-5f4c86fd3263/963ba28e-2c55-45ac-9374-a2f06ce95142
Episode UUID: 963ba28e-2c55-45ac-9374-a2f06ce95142

Podcast Info

Name: Developer Tea
Type: episodic
Site: http://www.developertea.com
UUID: cbe9b6c0-7da4-0132-e6ef-5f4c86fd3263

Transcript

[00:00:00] I’m going to start off this episode by giving you a quick heads up.

[00:00:06] You may hear rain sounds in the background, and typically I would avoid recording during

[00:00:12] rain sounds if possible, but as it turns out, Hurricane Irma has just left Florida and has

[00:00:18] gone through Georgia and Alabama, and now it’s in Tennessee where I am currently recording

[00:00:24] this episode.

[00:00:25] So you’re going to hear a little bit of that in the background.

[00:00:28] Of course, our thoughts are definitely with those of you who are listening from South

[00:00:33] Florida.

[00:00:33] I hope that you have stayed safe as this massive, massive storm has come through your area.

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

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

[00:00:44] My goal on this show, Developer Tea, is to help you become a better developer.

[00:00:49] We have these short, focused episodes, typically covering one or two topics, unless it’s a

[00:00:55] longer interview.

[00:00:56] We try to keep these episodes as short as possible.

[00:00:57] We try to keep these monologue-style episodes as short as possible so that we deliver as

[00:01:02] much value in the least amount of time as possible, because time is precious to me and

[00:01:07] to you.

[00:01:08] But just because these episodes are short does not mean that they are easy to digest.

[00:01:13] So I encourage you to take time to think about what we discuss on this episode.

[00:01:19] Have discussions with other developers in person.

[00:01:22] Have discussions with people who are non-developers about the ideas that are presented on this

[00:01:26] show.

[00:01:26] You know, this really only…

[00:01:27] works if you take it out of your headphones and put it into conversation.

[00:01:33] Take action on it.

[00:01:35] Take some time to journal your ideas.

[00:01:37] Maybe you have disagreements or maybe you have refinements on the ideas that are presented

[00:01:40] on this show.

[00:01:42] I highly encourage you to take the stuff we talk about into your own work.

[00:01:47] And that certainly applies to today’s episode.

[00:01:50] We’re talking about the traits that make a great developer.

[00:01:54] And perhaps the other way of saying it is,

[00:01:57] what traits every great developer exhibits.

[00:02:01] And these are traits that every developer, every great developer, if you were to sit

[00:02:05] down and interview them, you could find that they have relied on these traits throughout

[00:02:10] their career.

[00:02:11] Maybe they wouldn’t tell you this list explicitly, but you can uncover these things from any

[00:02:17] good developer.

[00:02:19] They would tell you these are important.

[00:02:21] So we’re going to discuss one of those traits today.

[00:02:23] The last one we discussed was rational humility.

[00:02:27] And that is the…

[00:02:27] The foundation for learning, right?

[00:02:30] We discussed that you don’t want to be all the way towards the side of artificial humility

[00:02:38] where you act humble by acting like you don’t know anything or that you’re not good enough

[00:02:44] for any job.

[00:02:46] Certainly that’s not productive.

[00:02:47] But then on the opposite end, where a lot of developers end up over the years, is developing

[00:02:53] a sense of narcissism or arrogance.

[00:02:55] And this is definitely something we want to talk about.

[00:02:57] We want to avoid as developers as well.

[00:03:00] And both of those can be poisonous, but right there in the middle, that rational humility,

[00:03:06] the idea that you recognize very reasonably that you have a lot left to learn and that

[00:03:12] very often you’re going to be wrong.

[00:03:14] And even the best developers, very often they get things wrong.

[00:03:18] And learning is a constant process and you’ll never be done with that.

[00:03:21] So that should inform the idea that everything that you say and everything that you do, you

[00:03:27] know, you’re doing it with the recognition that something could go wrong, that a decision

[00:03:34] you make may just not be the best decision, right?

[00:03:37] You will make mistakes.

[00:03:39] And sometimes even when you have very good reasons for making decisions and for doing

[00:03:44] the things that you do, they’re going to turn out poorly.

[00:03:47] And that actually leads directly into today’s episode.

[00:03:51] And we’re going to be talking about the next trait, and that is having the grit of a scientist,

[00:03:57] the grit of a scientist.

[00:03:58] I want to talk about the two parts of that.

[00:04:03] First grit, and then the second part is scientists.

[00:04:06] You know, what is grit?

[00:04:07] Well, this is something that a lot of research has been done recently.

[00:04:11] Of course, Angela Duckworth has a book by the name of grit.

[00:04:16] It is grit, the power of passion and perseverance.

[00:04:19] If you want to go and read more about grit, there’s videos of Angela and certainly podcast

[00:04:24] episodes on the subject of grit.

[00:04:27] Including an excellent Freakonomics episode on the subject of grit.

[00:04:30] But I want to present this to you through the light of what it means as a developer

[00:04:36] to utilize this concept of grit.

[00:04:39] What is grit?

[00:04:40] Well, to put it very simply, grit is the ability to stick to something.

[00:04:45] In other words, you see something through to the end.

[00:04:49] And this is important because, you know, a lot of the work that we do as developers,

[00:04:54] you know, there may be 80% of us who are not experts.

[00:04:55] And we’re not experts.

[00:04:56] We’re not experts.

[00:04:57] We’re not experts.

[00:04:57] That is really particularly interesting to us.

[00:05:00] And then 20% that is really not very interesting at all, right?

[00:05:04] There may be some custodial work that we do as developers.

[00:05:07] There may be some things that we have to do that are only business functions.

[00:05:12] They don’t really necessarily excite the builder part of our brains or the architect part of

[00:05:19] our brains.

[00:05:19] And there may be developers who absolutely see value in those pieces as well.

[00:05:25] But it’s important to recognize.

[00:05:26] That you’re not always going to have, you know, the most interesting problem to solve

[00:05:31] sitting on your desk.

[00:05:32] Sometimes you’re going to be fighting with your command line, right?

[00:05:38] Sometimes you’re going to be fighting with a bug that you can’t quite figure out.

[00:05:43] And grit on its own means that you have the kind of the will, the willpower to stick to

[00:05:51] something.

[00:05:52] And this also applies to your learning career as a developer.

[00:05:56] We’ve discussed.

[00:05:56] This on the show, uh, plenty of times before, but the idea that grit is important for your

[00:06:03] learning career.

[00:06:05] What this really means is if you choose to move forward, uh, let’s say with learning

[00:06:11] a particular language or new technology of any kind, really, uh, have the grit to see

[00:06:17] that learning process through.

[00:06:19] And of course, it’s important to understand, you know, when is the right time to give up

[00:06:24] on something?

[00:06:24] If the technology is not going to be viable.

[00:06:26] Or if it’s not providing you with, you know, any particularly new perspective or knowledge

[00:06:32] that you didn’t have before, you know, there’s plenty of reasons to give up on something.

[00:06:36] But what I see most often happening, especially with developers who are unsure of what to

[00:06:43] adopt next is kind of a, a shotgun approach.

[00:06:47] And you learn a little bit of a lot of different things.

[00:06:50] And unfortunately, you know, this leaves you basically in the same place that you started.

[00:06:55] So I recommend.

[00:06:56] Against that shotgun learning approach, and instead adopting this concept, this gritty

[00:07:02] concept of sticking to one or two or three things that you learn a little bit deeper,

[00:07:09] learn a little bit more about.

[00:07:11] Now we mentioned that the attribute is not just grit is the grit of a scientist.

[00:07:17] And what does that mean?

[00:07:18] That’s what we’re going to talk about right after we talk about today’s sponsor fuse with use.

[00:07:23] You can build iOS and the Android apps with less.

[00:07:26] Code and better collaboration.

[00:07:28] If you’ve ever used something like unity for game development, then you have a little bit of an idea

[00:07:34] of what fuse provides for a mobile application development.

[00:07:38] So if you use 1.0 has, has launched, they’re no longer in beta and they have fuse studio.

[00:07:44] Now it is their new premium editor and workspace for working with fuse projects.

[00:07:50] Now this is included in the professional plan, but most people actually don’t need the paid.

[00:07:56] Project.

[00:07:56] Plan, which includes few studio, the fuse platform itself and the free plan.

[00:08:01] They stand firmly on their own.

[00:08:04] So I highly recommend you go check it out, especially if you are a mobile application developer, or if

[00:08:09] you’re interested in becoming a mobile application developer, and the tool set has been a little bit

[00:08:14] daunting to you.

[00:08:16] I recommend you go and check it out.

[00:08:17] Spec.

[00:08:18] Dot FM slash fuse.

[00:08:20] And you can learn more about what fuse has to offer.

[00:08:22] Of course it runs on Mac.

[00:08:23] Oh, S it runs on windows as well.

[00:08:26] Uh, and the fuse installer, it includes everything that you need to get started.

[00:08:30] So there’s no complicated process and getting started up, go and check it out.

[00:08:34] Spec.

[00:08:34] Dot FM slash fuse, and you can learn more about the fuse professional plan.

[00:08:40] We didn’t go into a lot of detail on that, but you can learn more about what that professional plan offers for you when you’re ready to upgrade to that.

[00:08:48] But you don’t have to do that to begin with spec.

[00:08:50] Dot FM slash fuse.

[00:08:52] And it’s free to get started.

[00:08:53] Thanks so much to fuse for sponsoring today’s episode of development.

[00:08:56] We’re talking about grit and more specifically, we’ve already talked about grit a little bit.

[00:09:02] Uh, we’re talking about having the grit of a scientist as developer.

[00:09:08] Now I want to set this up for you because the idea that most people have in their mind, if they’ve heard and studied and learned about grit is this idea that you stick to something until it succeeds.

[00:09:21] However, there is a reality that developers have to face.

[00:09:25] And that is the reality.

[00:09:26] A failure.

[00:09:27] Whenever we sit down at our computers, uh, to write some code or whenever we are, you know, drawing out an idea on a whiteboard, uh, whenever we have collaborative meetings with designers or product owners, we undertake the possibility of failure.

[00:09:47] We recognize it as developers, uh, very often in our work because we’re constantly faced with perpetual.

[00:09:56] Failure.

[00:09:57] In fact, most of a project’s lifecycle is taking something that is failing and moving it to a non-failing state.

[00:10:06] Uh, this is really the concept of test driven development.

[00:10:10] You write failing tests on purpose.

[00:10:12] And it’s easy as a developer to take these failures to heart, right?

[00:10:18] This is why a lot of developers have a lot of frustration built up at the end of a given work day.

[00:10:24] This is a very emotional.

[00:10:26] thing for a lot of people as well because, you know, we tie our own worth or our own competency

[00:10:33] to how many failures we are able to fix or, more importantly, how many failures we are unable to

[00:10:40] fix in a given day. And it may feel like as a developer that you’re constantly in that failure

[00:10:47] state because, quite honestly, you almost are. And this is why it’s important to have the grit

[00:10:53] of a scientist. You see, scientists go through this as well. Whenever you set up an experiment,

[00:10:59] you create a hypothesis and you test that hypothesis. Of course, the scientific method

[00:11:07] allows for failure. This is not the kind of failure that grit will get you through,

[00:11:12] but rather the grit needed for scientists is the ability to recognize failure,

[00:11:19] learn from that failure, and start a new experience.

[00:11:23] So, when you fail, and you will fail many times as a developer, in fact, many times in a given day,

[00:11:33] when you do fail, the grit of a scientist is necessary for you to take a step back,

[00:11:40] observe the failure, recognize the components that contributed to the failure,

[00:11:47] as much as practical, of course, and then learn from those components and start a new experience.

[00:11:53] This is why it is so gritty. This is why it takes so much stick-to-it-ness to be a developer,

[00:12:02] because you’re constantly going back and trying again. The antithesis of this is pushing forward

[00:12:10] and accepting those failures as if they are now ingrained into a system. Pushing forward,

[00:12:17] not recognizing the components that are contributing to failure. This leads to,

[00:12:23] again, incredibly poor codebases that are neglected because the failures were ignored.

[00:12:30] Instead of sticking to the problem and trying to solve it until it is solved through a process

[00:12:38] of iteration, the developer decides to move forward and solve it later, or pass the buck

[00:12:45] to another developer, or maybe accept the idea that the codebase is bad. This is not something

[00:12:52] that a great developer will do. This is not something that a great developer will do.

[00:12:53] So how can you develop this grit of a scientist? Well, there’s a few ways that you can kind of

[00:13:01] practice this. The first is to actually go through that iterative process and specifically identify

[00:13:07] what stage you are in at a given point in time. So you need to set up some assumptions and

[00:13:12] some hypotheses whenever you’re getting ready to start solving a problem.

[00:13:18] You need to actually execute, go through the process of solving that problem,

[00:13:22] and then you need to go through the process of solving that problem.

[00:13:23] And then you need to go through the process of solving that problem.

[00:13:23] And then you need to evaluate and then reiterate over that, right? So the evaluation step is

[00:13:28] probably the most missed out of those three steps. Of course, this is an abbreviated version

[00:13:35] of the scientific method. I encourage you to go and Google and read a Wikipedia article

[00:13:40] on the scientific method. There’s a lot that you can learn from this. But if you take away

[00:13:45] one thing from today’s episode, it is to evaluate and reiterate when you run into a problem.

[00:13:52] When you hit a point of failure, you’re going to have to evaluate and reiterate.

[00:13:53] Don’t try to continue pushing. Evaluate that failure. If you ignore the failure and you never

[00:14:00] evaluate it, then you can’t get better. It’s impossible to recognize the patterns that lead

[00:14:07] to failure if you’re not evaluating. Thank you so much for listening to today’s episode of

[00:14:12] Developer Tea. Thank you again to Fuse for sponsoring today’s episode. Head over to

[00:14:16] spec.fm slash fuse to get started with an all-in-one platform for iOS and Android development.

[00:14:22] It’s going to totally change the way that people develop mobile applications.

[00:14:28] Thank you so much for listening. Make sure you subscribe if you don’t want to miss out on the

[00:14:31] future traits of great developers. Once again, this is an extension of the Developer Career

[00:14:37] Roadmap episodes. If you haven’t listened to those, you can find those on spec.fm.

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

Vox

Explorador