Vox

Leitura de 16 min

3X3: Three Questions To Get Unstuck On Big Problems

Summary

In this episode of Developer Tea, host Jonathan Cottrell addresses the challenge of solving large, complex problems that often go unresolved for extended periods. These are the kinds of systemic issues that can spawn entire businesses, new frameworks, or market changes. Rather than offering immediate solutions, Cottrell provides three strategic questions designed to create forward momentum and help listeners get “unstuck” when facing these daunting challenges.

The first question encourages a future-oriented perspective: “What will seem obvious once this problem has been solved that doesn’t seem obvious today?” Cottrell explains that great inventions often seem obvious in hindsight, and by attempting to view the problem from a future vantage point, we can identify deficiencies in current approaches. This exercise requires understanding trends and potentially unrelated industries to envision what future clarity might reveal.

The second question focuses on transferable principles: “What shared principles can I learn from an already solved problem?” Cottrell emphasizes that solutions often share underlying structures, similar to how developers learn data structures and algorithms to recognize problem patterns. By extracting principles from previously solved problems and applying them to new challenges, we can leverage existing knowledge to approach current obstacles more effectively.

The third and final question involves root cause analysis: “What was I doing when I got stuck?” Cottrell compares this to retracing steps when something is lost or using rubber duck debugging in programming. By returning to the origin of the problem and examining the environment when the issue arose, we can identify missteps or missing elements. This reverse engineering approach can lead to more innovative solutions that leapfrog rather than incrementally improve upon existing approaches.

Throughout the episode, Cottrell connects these questions to practical developer experiences like technical interview preparation and debugging techniques. He concludes by encouraging listeners to combine these approaches—rebuilding from the base level using principles while keeping the end goal in mind—to reset their problem-solving process and achieve meaningful progress on complex challenges.

Recommendations

Techniques

  • Rubber Duck Debugging — A problem-solving technique where developers explain their code line-by-line to an inanimate object (like a rubber duck) to identify errors. Cottrell mentions this as an example of retracing steps to understand where things went wrong.

Tools

  • Linode — A cloud hosting service that allows developers to deploy and manage SSD servers with various Linux distributions, resources, and node locations. The episode mentions a 5 plan) and features like Node Balancer for connecting multiple servers.

Topic Timeline

  • 00:00:00 — Introduction to big problems and the three-question framework — Jonathan Cottrell introduces the episode’s focus on solving large, complex problems that can generate entire businesses or go unsolved for years. He explains that these are not everyday problems but systemic challenges that require strategic thinking. The episode will present three questions designed to create forward momentum rather than immediate solutions.
  • 00:02:40 — Sponsor segment: Linode cloud hosting service — Cottrell discusses the episode’s sponsor, Linode, a cloud hosting service that allows developers to deploy SSD servers quickly. He highlights features like multiple data centers, affordable pricing starting at 20 credit (four free months) using the code “developertea2018” at checkout.
  • 00:05:12 — First question: What will seem obvious once solved? — Cottrell presents the first question: “What will seem obvious once this problem has been solved that doesn’t seem obvious today?” He explains that great inventions appear obvious in hindsight due to our narrative reconstruction of events. By attempting to view the problem from a future perspective, we can identify current blind spots and deficiencies in existing approaches.
  • 00:07:03 — Second question: Learning principles from solved problems — The second question asks: “What shared principles can I learn from an already solved problem?” Cottrell emphasizes that solutions share underlying structures, similar to how developers recognize problem patterns through data structures and algorithms. By extracting principles from previously solved challenges, we can apply them to new problems and identify deficiencies in current approaches.
  • 00:09:12 — Third question: Retracing steps to the origin — The third question is: “What was I doing when I got stuck?” Cottrell compares this to retracing steps when something is lost or using rubber duck debugging. By returning to the problem’s origin and examining the environment when the issue arose, we can identify missteps or missing elements. This root cause analysis can lead to innovative solutions that leapfrog rather than incrementally improve.
  • 00:11:29 — Conclusion and upcoming episode preview — Cottrell concludes by encouraging listeners to combine the three approaches—rebuilding from the base level using principles while keeping the end goal in mind. He previews Wednesday’s episode about uncovering short-term purpose and thanks Linode for sponsoring. Listeners are reminded about the $20 credit offer using the code “developertea2018” at spec.fm/linode.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-03-19T09:00:00Z
  • Duration: 00:12:21

References

Podcast Info

Transcript

[00:00:00] We all have problems to solve every day, but I’m going to talk about not your average problem for

[00:00:11] today’s episode. I want to talk about kind of these bigger problems that you face. And these

[00:00:17] are the kinds of problems that can generate entire businesses. These are the kinds of problems that

[00:00:22] you know, you stay up late thinking about and perhaps problems that go unsolved for years on

[00:00:28] end. We’re going to talk about three things, more specifically, three questions that you can ask

[00:00:35] to help you get unstuck on these kinds of problems. And being unstuck on these kinds of problems

[00:00:40] doesn’t mean that you’re going to solve them immediately, but rather that you’re going to have

[00:00:44] a forward momentum, kind of a moment of surge if you ask these questions and then spend time

[00:00:51] adequately answering these questions. My name is Jonathan Cottrell and you’re listening to

[00:00:56] Developer Tea. Today is Monday.

[00:00:58] Of course, and it is the first episode in a three by three week. If you’re not familiar with our three

[00:01:05] by threes in these episodes, we try to bring Developer Tea back to the practical pieces of

[00:01:11] advice that I can give you to become a better developer. The whole goal of this show is to help

[00:01:17] you connect to your purpose. And I hope you’ll subscribe today so that you don’t miss out on

[00:01:22] Wednesday’s episode. We’re talking about more purpose oriented episode on Wednesday, and we’re

[00:01:27] going to have some practical

[00:01:28] discussions around that topic more explicitly on Wednesday. But for today, we’re talking about

[00:01:34] getting unstuck, getting unstuck on these large problems. And these are problems that don’t have

[00:01:41] a single answer. Very often, these problems are answered by entire companies and entire changes

[00:01:49] in the market. These are the kinds of problems that are answered by new frameworks or even new

[00:01:55] languages for developers. And sometimes they’re answered

[00:01:58] by something entirely unrelated to the technology that you’re using as well. So obviously, this

[00:02:05] episode isn’t limited to developers in its scope. But I believe that developers often run up against

[00:02:11] these kinds of big questions, these big kind of systematic things that need to be solved.

[00:02:18] And we have to start thinking about the questions that we’re asking when we’re trying to solve

[00:02:23] these kinds of problems. Okay, so you know that on our three by three episodes, we talk about

[00:02:28] our sponsor for the day before we dive into the three practical things you can take away from this

[00:02:34] episode. So I want to do that right now. And we’re talking about Linode. Today, Linode is an excellent

[00:02:40] sponsor that we’ve had on for quite a while on this show. And one of the earliest sponsors we’ve

[00:02:45] had on developer T. Linode allows you to instantly deploy and manage an SSD server in the Linode

[00:02:52] cloud, you can get a server running in just seconds, with your choice of Linux distribution

[00:02:56] resources and node location.

[00:02:58] Quite literally, you pick those three things and you launch your Linode. They have a free credit

[00:03:06] for you for being a developer to listen. This is 20 can

[00:03:11] actually take you a pretty good distance. More specifically, if you choose their $5 a month plan,

[00:03:17] of course, that’s going to be four free months of Linode service. This is enough to learn a lot

[00:03:23] about Linode. I imagine this being kind of your trial period to

[00:03:28] find out if you like the way that Linode works. This is an excellent way for you to do that. So $20

[00:03:35] worth of credit. That’s four free months, we’ll give you the code in just a moment. But I want to

[00:03:38] tell you a few more specifics. They have 10 data centers, their plan started a gigabyte of RAM for

[00:03:44] $5 a month, we’ve already covered that they have high memory plans starting at 16 gigabytes, and

[00:03:50] going up from there. These are massively powerful servers that you can spin up on Linode. Again, in

[00:03:56] just a few minutes. Of course,

[00:03:58] depending on what kind of problem you’re solving, you may want to spin up a bunch of smaller Linode

[00:04:03] servers, a bunch of these one gigabyte servers, for example, and then connect them together. Well,

[00:04:08] Linode provides tools to do just that they have something called node balancer that allows you to

[00:04:13] connect your nodes together. There’s so many ways that you can use Linode. Of course, we’ve talked

[00:04:18] about some of the most important features for developers, which include support and the tools

[00:04:25] that they provide to allow you to

[00:04:28] cover from mistakes that you might make. There’s tons of things that Linode provides to you as developer. But I will let

[00:04:36] you find out more about them. You can find out so much about Linode by heading over to spec.fm, slash Linode. And again, use the code

[00:04:43] developer T 2018. At checkout, that’s all one word. Developer T 2018 at checkout to get that $20 worth of credit. Thank you again to

[00:04:51] Linode for sponsoring today’s episode of developer T. So it’s a three by three episode. And in today’s episode, we’re giving you

[00:04:57] three things.

[00:04:58] that will help you get unstuck on big problems.

[00:05:02] Unstuck on big problems.

[00:05:05] So let’s jump straight in.

[00:05:06] Number one, the number one question that you should be asking to get unstuck on a big problem.

[00:05:12] What will seem obvious once this problem has been solved that doesn’t seem obvious today?

[00:05:18] When we look at most great inventors,

[00:05:21] the things that they invented on the other end of that invention,

[00:05:26] they seem fairly obvious.

[00:05:27] And part of the reason for this is because in hindsight,

[00:05:31] everything that we see seems to make sense.

[00:05:35] We create this narrative representation of how something came about.

[00:05:39] But ultimately, this isn’t the way things occur.

[00:05:43] For example, if you think about the telephone,

[00:05:45] it seems obvious that we would use some kind of electrical current in order to communicate.

[00:05:51] But when we look back in time,

[00:05:54] it’s very difficult to recapture the perspective,

[00:05:57] the perspective that we had before something occurred.

[00:06:01] It’s very difficult to unwind that narrative in our minds.

[00:06:06] So it’s important to put some energy into the opposite direction,

[00:06:10] trying to figure out what we will look back and decide was obvious into the future.

[00:06:16] Now, of course, this isn’t incredibly easy by any means.

[00:06:20] But the way that we look at the world today,

[00:06:23] when we try to generate new ideas, sometimes,

[00:06:27] we’re better served if we look back from the future.

[00:06:32] And sometimes this requires more investment,

[00:06:34] more mental investment in understanding trends and perhaps even understanding

[00:06:39] unrelated industries and how those industries collide.

[00:06:42] But looking into the future and trying to look back from that vantage point,

[00:06:47] you know, this is the same concept.

[00:06:49] You’ve probably heard the phrase start with the end in mind.

[00:06:52] This is the same concept just from the perspective of problem solving.

[00:06:56] So what will we look back on?

[00:06:57] What will we look back and determine was obvious in the future?

[00:07:01] The number two question that I want you

[00:07:03] to ask in order to hopefully get unstuck on a problem is what shared principles can

[00:07:08] I learn from an already learned problem? What shared principles can I learn

[00:07:12] from an already learned, already solved problem?

[00:07:15] And really, this is going to help you do what we said in number one.

[00:07:20] This is going to help you kind of jump into the future and look backwards.

[00:07:23] Because what you’ll find is that as you uncover these

[00:07:27] principles, they will seem to kind of give you the clear deficiency.

[00:07:34] They’ll point to a clear deficiency in the current way that things are solved.

[00:07:38] So, you know, solutions have shared underlying structures.

[00:07:43] We use metaphors, we use abstraction to understand how

[00:07:48] various problems may be similar, kind of the the the bones inside of the problem,

[00:07:53] not necessarily the way the problem is solved at the surface level,

[00:07:57] but rather the underlying structures that are similar.

[00:08:01] This is exactly why we learn things like data structures and algorithms as

[00:08:05] developers, because it helps us recognize the shape of a problem rather than

[00:08:10] the specifics of the problem. This this can also help you choose a way

[00:08:16] of a particular way that you already understand to solve a problem that you’ve

[00:08:21] never seen before. Right.

[00:08:22] So if you’ve prepared for a technical interview, you’ve probably done this.

[00:08:26] And this is where you try to recognize, you know, certain types of problems.

[00:08:30] This is a searching problem or this is a sorting problem or a categorization problem.

[00:08:37] Having these models for the way that we see things, really,

[00:08:41] there’s principles that we’ve learned that apply to all sorting problems.

[00:08:46] There’s principles that we’ve learned that apply to all categorization problems.

[00:08:50] So if we can look at problems that have already been solved and try to draw out

[00:08:56] the principles.

[00:08:56] And then apply them to new problems that we’re trying to solve, very often we can

[00:09:01] take what we’ve already learned in the past and reuse it to learn and

[00:09:06] really become more action oriented into the future.

[00:09:09] And the last question I want you to ask when you’re trying to solve a problem,

[00:09:12] and really this applies to smaller problems as well, is very simple.

[00:09:16] What was I doing when I got stuck?

[00:09:19] Another way of wording this problem is what is the origin of the issue?

[00:09:25] When did this issue

[00:09:26] become exactly that?

[00:09:29] What was the the environment like when the issue arose?

[00:09:33] What are the surrounding problems that may be exacerbating this particular problem?

[00:09:38] Whenever you lose something, isn’t it always the common advice to retrace your steps?

[00:09:43] Perhaps in a problem scenario, it helps to retrace your steps in a similar way.

[00:09:47] So back up and look at what you’ve tried.

[00:09:51] This kind of problem solving is often what rubber duck debugging actually does, right?

[00:09:56] It forces you to retrace the steps that you’ve already taken and realizing that

[00:10:01] you took a step that you shouldn’t have, for example, or maybe you forgot to take

[00:10:05] a step that you should have by putting your mind back in the moment where things

[00:10:10] went wrong, you might see a different path you can take.

[00:10:14] But be certain that the moment you transport to is the correct one.

[00:10:18] And when in doubt, you should go further back to when you knew things were working correctly.

[00:10:23] This is really kind of a root analysis.

[00:10:26] A root cause analysis, right?

[00:10:29] If you’re solving a creative problem, try to understand the driving reason that the

[00:10:33] problem exists in the first place.

[00:10:35] This kind of reverse engineering can often lead to more novel and valuable

[00:10:40] solutions that leapfrog rather than baby step in terms of innovation.

[00:10:45] So it’s important to realize the space that your problem exists

[00:10:50] in, where it came from, and why other things are not solving it.

[00:10:55] What is wrong?

[00:10:56] What’s wrong with what you’ve already done?

[00:10:58] And peel back those solutions, whether it’s your solution or

[00:11:04] society’s or culture’s solutions that already have

[00:11:07] been attempted, or even a co-worker’s solution that’s already been attempted.

[00:11:11] At any scale, if you can peel back and go back to the origin of the problem

[00:11:15] and rebuild from the base level using principles with the end in mind,

[00:11:22] this is going to kind of reset that process.

[00:11:26] And it hopefully will get you unstuck.

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

[00:11:32] Once again, this is the first in a series of three by threes for this week.

[00:11:37] We’re talking about all kinds of things in these episodes, and I hope that you

[00:11:42] will subscribe so you don’t miss out on the next three by three on Wednesday.

[00:11:46] We’ll be talking about ways of uncovering your short term purpose.

[00:11:52] What is your short term purpose?

[00:11:54] Well, listen on Wednesday and we’ll talk about it.

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

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

[00:12:01] You can get a twenty dollar credit that’s worth four months of service on Linode.

[00:12:06] Head over to spec.fm slash Linode and use the code developertea2018 at checkout.

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

[00:12:13] Until next time, enjoy your tea.

Visão de gráfico