Vox

Leitura de 11 min

Problem Chains

Summary

In this episode, Jonathan Cottrell discusses the concept of ‘problem chains’—the idea that problems are rarely atomic and are instead interconnected in hierarchies of parent and subproblems. He encourages developers to think about a specific problem they face and identify its position within this chain, as this understanding is crucial for effective problem-solving and career growth.

The episode provides a practical exercise: take a problem like ‘users are confused on your platform’ and break it down into subproblems such as unclear visuals, cluttered interface, or confusing language. Each of these can be further decomposed, revealing connections to broader issues like UX, usability, and audience definition. Breaking problems down to their most atomic ‘leaf’ level is essential for determining the specific actions, like writing code, needed to solve them.

Cottrell then explores the opposite direction: integrating problems upward to understand the parent problems they contribute to. For example, user confusion might lead to customer churn or damage to the brand’s reputation. By contextualizing a lower-level problem within its higher-level chain, developers can make more informed decisions, potentially solving the bigger problem without addressing the smaller one directly or replacing an embedded assumption with a better solution.

The key takeaway is that recognizing the interrelated nature of problems allows developers to ask better questions and contextualize their solutions. Understanding where a problem sits in its chain enables more strategic decision-making, whether decomposing it for tactical execution or integrating it for holistic strategy.

Recommendations

Tools

  • DigitalOcean — A cloud platform for running and scaling applications, offering effortless administration tools, robust compute storage, predictable pricing, and included monitoring. The sponsor is providing $100 in credit for listeners.

Topic Timeline

  • 00:00:00 — Introduction to problem framing and branching — Jonathan Cottrell introduces the episode’s topic: problem framing and branching. He explains that problems are almost never atomic and are connected to other problems, either as parent/ancestor problems or as subsystems/subproblems. He sets the goal of helping listeners identify where a specific problem sits in its ‘problem chain’ to aid career growth and problem-solving.
  • 00:01:28 — Exercise: Breaking down a problem into subproblems — Cottrell leads an exercise where listeners think of a specific problem, such as ‘users are confused on your platform,’ and break it down into subproblems. Examples include making visuals clearer, decluttering the interface, or improving language. He explains that each subproblem can have its own subproblems, leading to discussions about UX, usability, accessibility, and audience definition. Breaking problems down to their atomic ‘leaf’ level is crucial for deciding how to solve them, such as determining what code to write.
  • 00:03:08 — Sponsor message: DigitalOcean — A sponsor message for DigitalOcean, which is offering $100 in credit to Developer Tea listeners. The ad describes DigitalOcean as an easy cloud platform for running and scaling applications, with effortless administration tools, robust compute storage, predictable pricing, and included monitoring and alerting. Listeners are directed to do.co/tea to claim the credit.
  • 00:04:33 — Integrating problems upward to parent problems — After the sponsor break, Cottrell shifts from decomposing problems to integrating them upward. Using the same example of user confusion, he explores what parent problem this contributes to, such as users leaving the platform or damaging the brand’s reputation. He illustrates with the example of making account cancellation difficult, which might retain customers but create an angry user base that leaves bad reviews, harming the brand’s customer service reputation.
  • 00:06:36 — Contextualizing problems for better decision-making — Cottrell explains that following a problem chain upward allows for more informed decisions by contextualizing lower-level problems within higher-level goals, like needing a positive customer service reputation to attract and retain users. This process can help skip embedded assumptions in the problem statement, potentially solving the bigger problem without solving the smaller one, or replacing a specific problem with a better one. Recognizing that problems are interrelated helps developers ask better questions based on a problem’s position in the chain.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-07-18T09:00:00Z
  • Duration: 00:08:40

References

Podcast Info

Transcript

[00:00:00] In today’s episode, we’re talking about problem framing and problem branching.

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

[00:00:12] And my goal on the show is to help driven developers connect more closely to their career purpose

[00:00:17] and do better work so they can have a positive influence on the people around them.

[00:00:22] You face problems every day as a developer.

[00:00:25] You face problems at all varying stages of the problem life cycle.

[00:00:32] What are we talking about with the problem life cycle?

[00:00:35] Well, problems are not a simple thing.

[00:00:38] Perhaps a better way of putting it is problems are almost never atomic.

[00:00:44] They almost never exist on their own.

[00:00:48] They’re connected to other problems, either parent problems, kind of ancestor problems,

[00:00:53] or they’re subsystems.

[00:00:55] Subproblems, the things that you could break that one problem down into.

[00:00:59] So I want you to think in today’s episode about a specific problem, and then try to

[00:01:04] identify where in this problem chain that problem actually is.

[00:01:11] And I’ll give you some advice here.

[00:01:13] This is kind of showing what we’re going to talk about later, but where that problem is

[00:01:18] is very important to how you can grow in your career and how you solve that problem.

[00:01:26] Okay, so let’s do this exercise.

[00:01:28] I want you to think of this problem that you have, and I want you to think about how to

[00:01:32] break that problem down.

[00:01:34] So for example, maybe the problem is that users are confused on your platform, and you

[00:01:41] can break that down into a variety of subproblems.

[00:01:44] Maybe you need to make the visuals a little bit more clear.

[00:01:48] Maybe you need to declutter the interface.

[00:01:50] Perhaps the problem is actually in the language that is used.

[00:01:56] Or maybe there’s some kind of communication that needs to happen in parallel to whatever

[00:02:01] your product is.

[00:02:02] Maybe an email needs to be sent.

[00:02:04] Whatever the problem is, you can break it down into subproblems.

[00:02:08] And each of those subproblems will likely have subproblems on its own.

[00:02:11] So for example, you could say that part of the problem is the interface is confusing.

[00:02:17] The interface for the user is confusing to use.

[00:02:20] So how do we break that problem down?

[00:02:22] Well, then we can go into an entire discussion.

[00:02:25] We can go into an entire discussion about UX and usability and accessibility and trying to define who is this audience, right?

[00:02:31] We have multiple connections to other problems that are well up the chain in this problem set.

[00:02:38] So breaking these problems all the way down to their most atomic version, or I guess the leaf of that tree, is very important.

[00:02:45] Because that’s when we decide how we’re going to solve those problems.

[00:02:51] What code are we going to write in order to solve those problems?

[00:02:55] More specifically.

[00:02:57] But what about instead of kind of breaking a problem down, what if we integrate a problem upward?

[00:03:04] We’ll discuss that right after we talk about today’s sponsor, DigitalOcean.

[00:03:08] DigitalOcean has been a sponsor before, and they’ve come back to be a sponsor on DeveloperTea.

[00:03:12] And I’m really excited about this sponsorship because DigitalOcean is providing you, the listeners of DeveloperTea, with $100 worth of credit for trying out DigitalOcean.

[00:03:23] You can get that credit by going to d.o.o.t.

[00:03:25] d.o.c.o.

[00:03:26] That’s d.o. as in DigitalOcean.

[00:03:29] .co.

[00:03:30] Slash t.

[00:03:31] T-E-A.

[00:03:33] And you’ll get that $100 worth of credit.

[00:03:35] Now, what does DigitalOcean do that you would use this $100 on?

[00:03:39] Well, it provides you with the easiest cloud platform to run and scale applications on.

[00:03:46] From effortless administration tools to robust compute storage, as well as predictable and affordable pricing.

[00:03:54] You want?

[00:03:55] You have complex pricing structures, you have a flat rate that you pay per month, and it’s an industry-leading price-to-performance ratio, by the way.

[00:04:06] So those prices are going to be predictable.

[00:04:08] That means you’re not going to have any crazy big bills all of a sudden.

[00:04:12] You’re going to have consistent billing.

[00:04:14] And, by the way, monitoring and alerting are included on your DigitalOcean droplets.

[00:04:20] Go and check it out.

[00:04:20] Head over to d.o.c.o.

[00:04:23] Slash t.

[00:04:24] That’s d.o.c.o.

[00:04:25] Slash t.e.a.

[00:04:27] To get that $100 worth of credit.

[00:04:29] Thanks again to DigitalOcean for sponsoring today’s episode.

[00:04:33] Okay, so we talk about making things smaller on the show all the time.

[00:04:36] Decomposing things.

[00:04:37] Getting down to the very nitty-gritty details.

[00:04:40] The most atomic versions of things.

[00:04:43] And we’ve talked about doing that with problems in today’s episode.

[00:04:46] But what happens when we go the other direction?

[00:04:49] Let’s say, for example, that the problem that you have is

[00:04:53] that users are not going to be able to do that.

[00:04:54] Users are confused on your site.

[00:04:57] Confused using your product.

[00:04:58] We already mentioned this.

[00:05:00] But instead of trying to break that down as to why are they confused,

[00:05:03] we can go the other direction.

[00:05:06] What is the parent problem that this actually contributes to?

[00:05:12] Now, at face value, this may seem obvious.

[00:05:14] Of course, if users are confused,

[00:05:16] then maybe those users are not sticking around.

[00:05:20] Maybe they are leaving your platform altogether.

[00:05:24] They’re leaving your product.

[00:05:24] They are no longer going to be your customers.

[00:05:28] Now, if you evaluate this problem more holistically,

[00:05:32] the real answer might be that your brand is suffering.

[00:05:36] Let’s say, for example, that you make cancelling an account difficult to do.

[00:05:42] Well, this kind of has the opposite effect, right?

[00:05:45] They are no longer leaving your platform

[00:05:47] and you’re retaining these customers because you’ve kind of trapped them.

[00:05:50] Now, unfortunately, what this results in is,

[00:05:54] is kind of an angry user base, right?

[00:05:58] People who will go on and leave really bad reviews about your app

[00:06:01] or, you know, in some other way, represent your brand very poorly.

[00:06:07] And you can call it a brand.

[00:06:08] You can call it, you know, the representation of your product,

[00:06:12] your customer service kind of reputation, whatever it is.

[00:06:17] But people will respond negatively to that.

[00:06:20] So that’s actually a different problem, right?

[00:06:23] This is a totally different problem.

[00:06:24] Then, well, we just want customer retention.

[00:06:28] Why do you care about your customer service reputation?

[00:06:32] Well, the kind of the parent problem, if you continue following this chain up,

[00:06:36] is that you do actually need to retain people.

[00:06:40] You need to have a positive perspective or a positive reputation of customer service

[00:06:46] so that when somebody is evaluating the various options in the market

[00:06:51] for whatever product or service that you provide,

[00:06:53] that one of the things that they’re evaluating is probably customer service, right?

[00:06:58] So this seems pretty obvious.

[00:07:01] But as it turns out, when you contextualize a problem that is further down the chain,

[00:07:07] by following that chain upward, you can make much more informed decisions.

[00:07:14] You can make decisions that skip any assumptions that may be embedded in that problem statement.

[00:07:21] You may be able to kind of, you know,

[00:07:23] short circuit and solve the bigger problem without solving the smaller problem.

[00:07:30] You could remove that ancestor problem, that more specific problem,

[00:07:34] and replace it with a better one.

[00:07:36] Or even directly solve that higher level problem.

[00:07:41] Recognizing that all problems are interrelated with each other,

[00:07:45] very few problems are actually atomic,

[00:07:49] you can start asking better questions

[00:07:51] and contextualizing the solutions to your problem statement.

[00:07:53] And you can start asking better questions

[00:07:55] based on where that problem is in that chain.

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

[00:08:02] We intentionally kept this one a little bit shorter today.

[00:08:05] Of course, that was the initial intent for the show.

[00:08:08] If you like these short episodes,

[00:08:09] then I encourage you to subscribe in whatever podcasting app you use.

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

[00:08:17] You can get $100 worth of credit on DigitalOcean’s platform today

[00:08:21] by heading over to do.co.

[00:08:22] Do.co.

[00:08:23] That’s D-O as in DigitalOcean dot C-O slash T-E-A.

[00:08:29] D-O dot C-O slash T-E-A.

[00:08:31] Thanks again, and until next time, enjoy your tea.

Visão de gráfico