Problem-Solving for Developers - A Beginner's Guide

Summary

In this video, the creator discusses the critical skill of problem-solving in software development, using the real-world scenario of merging over 600 pull requests on GitHub. The script outlines seven concepts to tackle coding problems efficiently, emphasizing the importance of understanding the problem, researching, breaking it down, and using tools like the GitHub API. It also highlights the value of pseudocode, test-driven development, and the iterative process of refining code. The video encourages viewers to practice, seek feedback, and appreciate the continuous learning journey in programming.

Takeaways

• 😀 Problem-solving is a critical skill for software developers, often more important than knowing every feature of a programming language.
• 🔍 Identifying and understanding the nature of the problem is the first step in solving it, which can save time and effort in the long run.
• 📚 Researching and refining the problem by learning from others' solutions is encouraged, as it can provide a solid starting point for your own code.
• 👥 Collaboration and discussion with other developers can lead to innovative solutions and help break down larger problems into smaller, more manageable tasks.
• 🔬 Utilizing APIs like GitHub's GraphQL API can help automate tasks, such as merging pull requests, which would otherwise be repetitive and time-consuming.
• 📝 Writing pseudocode is an effective way to outline code logic before diving into actual implementation, focusing on structure rather than syntax.
• 🔄 Test-driven development is a recommended practice that can help ensure the quality and reliability of your code by catching issues early.
• 💡 Implementing a working prototype quickly, even if imperfect, can boost confidence and provide a solid foundation for further refinement.
• 🛠️ Continuously improving code through practices like better naming, adding comments, and optimizing algorithms leads to more maintainable and efficient code.
• 🎼 Problem-solving in programming is like learning a musical instrument; it requires consistent practice and gradual improvement to master.
• 👨‍🏫 Seeking feedback from more experienced developers can accelerate learning and help you overcome challenges in your coding journey.

Q & A

What problem did the speaker create by offering to mail a sticker to anyone who submitted a pull request?

The speaker ended up with over 600 pull requests to review and merge, which would have taken a significant amount of time to do manually.

What is the speaker's perspective on the importance of programming in solving problems?

The speaker views programming as a powerful tool for eliminating manual and repetitive work, which is one of the fundamental problems that software is designed to solve.

What does the speaker consider the most important skill of a software developer?

The speaker considers problem-solving to be the most important skill of a software developer, as it enables developers to ship code faster and perform better in technical interviews.

Why does the speaker emphasize the importance of understanding the problem before jumping into solutions?

The speaker emphasizes this because spending time understanding the problem allows for more effective and efficient solutions, and it's a key part of the problem-solving process.

What does the speaker suggest doing before starting to code as a way to break down the problem?

The speaker suggests researching and refining the problem, discussing the idea with other developers, and using APIs to understand the tools and requirements needed to solve the problem.

What is the purpose of writing pseudocode according to the speaker?

Writing pseudocode helps to outline the logic of the code without worrying about syntax or implementation details, making it easier to focus on the structure and flow of the solution.

Why is exploring the API before implementing the code valuable according to the speaker?

Exploring the API beforehand helps to understand the schema and requirements, making the implementation process easier and more efficient.

What is the speaker's approach to writing tests for their code?

The speaker advocates for test-driven development, writing tests before implementing the code to ensure the validation logic is correct and to prevent regressions in the code.

What does the speaker suggest doing after implementing a working prototype of the code?

The speaker suggests taking a break, reflecting on the code, and then improving it by enhancing readability, adding comments, removing duplication, and optimizing algorithms.

How does the speaker describe the process of becoming good at problem-solving in programming?

The speaker describes it as a skill that is developed through practice, repetition, and learning from feedback, similar to learning a musical instrument.

What advice does the speaker give for dealing with a difficult problem in coding?

The speaker advises taking a break and focusing the mind elsewhere for a short period, as the subconscious can continue working on the problem, often leading to an 'aha' moment.

Outlines

00:00

😀 Automating Code Reviews: A Real-World Problem

The speaker introduces a personal challenge of having to manually review and merge over 600 pull requests on GitHub, which sparked the discussion on the importance of problem-solving skills in software development. The video aims to explore seven concepts that can enhance coding problem-solving abilities, emphasizing the shift from learning a programming language to mastering the art of tackling problems efficiently. The example of automating the merging of pull requests using programming is used to illustrate the elimination of manual, repetitive tasks, a fundamental issue software aims to solve.

05:02

🔍 Problem Identification and Breakdown

The speaker outlines the first step in problem-solving: identifying and understanding the problem at hand. In this case, the issue is the need to merge a large number of pull requests on GitHub without manual intervention. The speaker explains the process of defining the problem with context, explaining why it's an issue, and summarizing the benefits of solving it. The problem is then broken down into smaller, more manageable sub-problems, such as validating each pull request and researching the GitHub API to ensure it can support the required tasks.

10:02

📝 Pseudocoding and API Exploration

The speaker discusses the importance of pseudocoding as a means to outline the logic of the code before diving into syntax and implementation details. This method allows for a focus on naming and readability. The speaker also highlights the value of exploring the GitHub API using tools like Insomnia to understand the schema and ensure it meets the project's requirements. The process includes writing a GraphQL query to retrieve open pull requests and planning a function to validate and merge them, emphasizing the need for clear and concise pseudocode to guide the actual coding process.

👨‍💻 Implementing Code and Testing

The speaker moves on to the implementation phase, advocating for a quick prototype approach to get a working model as soon as possible, even if it's not perfect initially. The focus is on getting all tests to pass and having a functional base to build upon. The video also touches on the optional but recommended practice of test-driven development, where tests are written before the code to ensure the validation logic is correct. The process of writing tests, implementing code to pass those tests, and then refactoring is described, highlighting the benefits of this approach for catching issues and preventing regressions.

🛠 Refining and Optimizing Code

After implementing a working prototype, the speaker suggests taking a break to allow the subconscious to work on any lingering issues. Upon returning, the speaker recommends reflecting on the code and looking for areas of improvement, such as enhancing readability, adding comments, removing duplication, and proving the time and space complexity of algorithms. The importance of continuous learning and practice in problem-solving is emphasized, along with seeking feedback from more experienced developers to improve one's skills.

🎓 Conclusion and Call to Action

In conclusion, the speaker wraps up the video by reiterating the importance of practice and feedback in mastering problem-solving skills. They encourage viewers to share their thoughts in the comments and to consider becoming a pro member at Fireship.io for more in-depth learning. The speaker thanks the audience for watching and looks forward to the next video, ending with a motivational note on the journey of learning to program and the development of the mind's ability to visualize computer system solutions to problems.

Keywords

💡Problem Solving

Problem solving is the core theme of the video, defined as the process of identifying, understanding, and figuring out how to overcome obstacles or issues. It is central to the video's narrative as the speaker discusses the importance of this skill in software development. For instance, the speaker describes how they created a problem by offering stickers for pull requests, leading to over 600 code changes that needed to be reviewed and merged, which exemplifies a real-world problem that requires a solution.

💡Pull Request

A pull request is a feature in version control systems like GitHub, allowing contributors to submit their code changes for review and inclusion into a project. In the video, the speaker mentions creating a pull request problem by offering stickers to anyone who submitted one, which resulted in a large volume of pull requests that needed to be addressed.

💡Code Review

Code review is the process of examining and evaluating code changes made by others to ensure they meet certain standards and are free of errors. The video's speaker highlights the tedious nature of manually reviewing and merging each pull request, which underscores the need for automation to eliminate repetitive work.

💡Programming

Programming is the act of writing code to create software or applications. The video emphasizes programming as a means to solve problems, particularly the elimination of manual and repetitive tasks. The speaker uses programming to automate the process of merging pull requests as an example of applying this concept.

💡Software Developer

A software developer is a professional who designs, codes, and maintains applications or systems software. The video discusses the most important skill of a software developer, which is problem-solving. The speaker suggests that top companies assess this skill during interviews through whiteboarding problems.

💡Whiteboarding

Whiteboarding is a technique used in technical interviews where candidates solve problems or design systems on a whiteboard. It is mentioned in the video as a method for companies to gain insight into a candidate's thought process when approaching a software development problem.

💡Context

In the video, context refers to the background or setting in which a problem exists. The speaker uses the context of having over 600 pull requests on GitHub to explain the problem they faced, emphasizing the need to merge these requests efficiently.

💡Research

Research in the video is portrayed as a critical step in problem-solving, where the speaker suggests looking into what others have done to solve similar problems. It is exemplified by the speaker's approach to finding a solution for merging pull requests by researching GitHub's API and discussing with other developers.

💡API (Application Programming Interface)

An API is a set of rules and protocols for building software applications, allowing different software systems to communicate with each other. The video discusses using GitHub's GraphQL API to automate the process of retrieving and merging pull requests, demonstrating the practical application of APIs in solving coding problems.

💡Pseudocode

Pseudocode is an informal high-level description of an algorithm or system's logic in a programming language. The speaker recommends writing pseudocode as a step in the problem-solving process to outline the code's logic before diving into the actual implementation, as seen when planning the solution for merging pull requests.

💡Test-Driven Development

Test-driven development (TDD) is a software development approach where tests are written before the actual code. The video advocates for TDD as a way to ensure the reliability of the code, with the speaker suggesting writing tests to validate the logic for merging pull requests.

💡Implementation

Implementation refers to the act of putting a plan or design into effect, particularly in the context of coding, turning an idea or design into a working program. The video describes the implementation phase as the step following the creation of pseudocode and tests, where the speaker aims to quickly achieve a working prototype.

💡Practice

Practice is the act of performing an activity repeatedly to improve or master it. The video concludes with the speaker emphasizing the importance of continuous practice in honing problem-solving skills in programming, likening it to the development of calluses on a musician's fingers from playing an instrument.

Highlights

The speaker created a problem by offering to mail stickers to anyone who submitted a pull request, resulting in over 600 code changes to review and merge.

Programming is introduced as a solution to eliminate manual, repetitive work, a fundamental problem that software aims to solve.

The importance of problem-solving skills over language-specific features is emphasized for software developers.

Highly experienced developers are characterized by their problem-solving abilities rather than just their knowledge of programming languages.

Problem-solving is identified as a critical skill in technical interviews, where the thought process is valued over memorization of syntax.

The speaker suggests that everyone's problem-solving approach is unique and encourages following one's instincts.

The first step in problem-solving is to identify and understand the nature of the problem, as illustrated by the speaker's experience with pull requests.

The importance of context in defining a problem is highlighted, with the example of optimizing the merging of pull requests on GitHub.

Research and refinement of the problem is suggested as the second step, including discussing ideas with other developers and using APIs.

The use of GitHub's GraphQL API is proposed for retrieving and validating pull requests, breaking down the larger problem into smaller subproblems.

Pseudocode is introduced as a method to outline code logic before implementation, focusing on the structure rather than syntax.

The benefits of writing pseudocode for readability and naming clarity are discussed.

Exploring an API before coding is recommended for understanding its capabilities and limitations.

Test-driven development is introduced as a best practice, emphasizing the value of writing tests before implementing code.

The red-green-refactor process is explained as a method to improve code quality through iterative testing and refinement.

The implementation phase is described as getting a working prototype done quickly, even if it's not perfect initially.

The psychological aspect of solving problems is touched upon, suggesting that taking breaks can lead to solutions through subconscious processing.

Improving a working prototype is easier than writing perfect code from the start, with a list of improvement strategies provided.

The importance of continuous learning and practice in problem-solving is emphasized, likening it to developing calluses on a musician's fingers.

Getting feedback from more experienced developers is suggested as a way to improve one's coding skills and problem-solving abilities.

Transcripts

houston we have a problem I created a

bit of a problem last week by offering

to mail a sticker to anybody who

submitted a pull request to this repo

and now I'm stuck with over 600 code

changes to review and merge I could sit

at my computer for a few days and

manually merge each one by clicking a

button but luckily we have this awesome

thing called code that lets us do this

thing called programming to solve

problems like this in today's video

we'll look at the steps involved in what

many consider to be the most important

skill of a software developer problem

solving well look at seven different

concepts that can help you solve coding

problems quickly and reliably when you

become comfortable with these concepts

you'll be able to ship code faster and

be more comfortable in technical

interviews we can use my real-world

problem with pull requests as an example

what we have here is a very specialized

use case but it represents one of the

most fundamental problems that software

solved the elimination of manual

repetitive work many new developers

start their programming journey focused

on learning a language and that's

perfectly fine because obviously you

need to know a language to solve

problems with code but when you get to

know highly experienced developers

you'll realize that their skill set is

more about problem solving than it is

about knowing every single feature of

the language that use that's why most of

the top companies have you do

whiteboarding problems and interviews

they want insight into your thought

process when you approach a software

development problem because that skill

is much more difficult to learn than

memorizing the syntax of a programming

language it takes years of experience

and practice to get good at but once you

have it down you'll be able to

confidently turn your ideas into reality

through the magic of code and you won't

even need YouTube channels like this for

tutorials but in the meantime make sure

to subscribe and hit the notification

bellow so you don't miss the next

sticker giveaway now I want to start

things off by saying that everybody's

brain is different and there's no one

universal right way to solve a problem

I'm going to show you techniques that

work well for me but follow your

instincts and do what works best for you

the first step is to identify and

understand the nature of the problem if

I had an hour to solve a problem I'd

spend 55 minutes thinking about the

problem and five minutes thinking about

solutions in our case we have six

hundred pull requests on github and we

don't want to have to click this stupid

button six hundred times so what we have

here is an internal optimization that

will hopefully save us time and money

but there are many different types of

software problems out there you might

have a bug and existing software where

you have to look through the application

stack trace and figure out the root

cause or you might have a more abstract

problem like the user experience that

tends to be such a big problem

that many teams break things down into

epic stories and themes through the

agile approach when defining a problem I

first like to start with context we have

more than 600 pull requests on github

that must be merged then explain why

that's an issue it would take hours of

mindless code review and button clicking

to get that done and lastly summarize

why we should solve this problem it can

be automated with the github API to save

us time and money so now that we've

decided this problem is worth our time

we can break it down into a bunch of

smaller problems I remember when I first

got into development I'd often asked

myself where do I start I would have a

clear vision of what I wanted to build

but just no idea how to put things in

motion and that brings us to step number

two research and refine the problem and

how do you do that

of course you google it and then click

on the first Stack Overflow result that

comes up just copy and paste that into

your codebase and the problem is solved

in all seriousness you should go out and

research what other people have done to

solve the same problem because you're

likely not the first one and it's

perfectly okay and typically encouraged

to use other people's solutions as a

starting point just make sure you

confidently understand what the code

does before using it now in our case we

have a pretty specialized problem not

many people have to concurrently merge

600 pull requests if possible discuss

the idea with other developers I want to

give a shout out to Christian wheeler on

github who opened an issue that started

the discussion about how we can merge

all these pull requests he provided a

bash script that we can run from the

command line but after doing some more

research we realized that we would need

to validate every single pull request by

ensuring that each person who made a

submission only modified the one file

that they were authorized to modify and

that breaks our larger problem into a

smaller one of how do we validate each

individual pull request

luckily github has a really nice graph

QL API that we can use to retrieve

information from github servers about

our account but before I started writing

any code I did some research first to

make sure the API supported what I

wanted to do we can further refine the

problem into two smaller objectives

retrieve all the pull requests from

github and then merge each one

individually by researching the API

documentation on github I was able to

confirm that it supports these

requirements now at this point we have

our main problem broken down into a few

subproblems and we've done research on

the tools and api's that can support

these requirements in most situations

there will be more than one way to solve

a problem like in this case I could use

the graph QL API or the REST API so make

sure to weigh the pros and cons of

alternative approaches and now we're

ready for step three pseudocode

in this step our goal is to write an

outline for how we will implement our

code you could do this on a white board

a piece of paper or directly in your

editor the idea is that you focus on the

logic of your code without having to

worry about the syntax or implementation

details if you're very comfortable in a

language like in my case JavaScript I

recommend writing your pseudocode in

that language in this case here I start

with a main function and then inside

that function I know I'll need a graph

QL client I'm not sure where I'll get it

so for now I'm just using this as a

placeholder and I know it's going to

need an auth token to authenticate with

the github API from there I'll need to

retrieve all the open pull requests

using a graph QL query and then I'll

write a function to validate each one

before emerging it in the function body

I'll add some comments about the

validations that we want

run inside this function they say there

are only two hard things in programming

cache and validation and naming things

an added benefit of writing pseudocode

is that you can focus on naming things

before your code gets filled up with a

bunch of other syntax so it's a great

way to increase your code readability

then from there we'll set up a for loop

and if the pull request is valid then

we'll go ahead and merge it with a graph

QL mutation and now we have a general

idea of how we'll implement our code now

because we're working with an API it's

also very valuable to explore that API

before you dive into it to do that I'm

using an app called insomnia that allows

me to make requests to the API before I

actually implement the code in

JavaScript graph QL makes this

especially nice because we can see the

entire schema of the API without ever

having to leave this app I have an

entire video dedicated to graph QL if

you want to learn more about it but the

code itself is pretty self describing

our query first makes a reference to the

git repo and then we fetch ten pull

requests that have a state of open and

then we grab the fields that we know

we'll need in our algorithm like the

changed files the author and so on but

the bottom line here is that

understanding the API will make it much

easier to implement the solution when we

get to the code and now we're ready for

the next step which is optional but

highly recommended test-driven

development if you're building a

critical feature that your business

depends on you should test it and yet

another skill of an experienced

developer is understanding what test

will be valuable for that feature and

really the only way to get good at that

is to start writing tests and see where

they add value to your codebase in this

example I think a valuable test would be

one that checks our validation logic to

ensure that the username that requested

a sticker is the same as the username

that made the pull request the basic

process looks like this we start by

writing a test that describes what we're

actually testing then we execute our

code using some mock data and lastly if

we write an expectation expecting the

return value of that code to be a

certain shape in this case it should be

the value of true from here we could

expand on this by adding additional test

cases with more mock data and we can

keep doing this until we're confident

that our code can handle any situation

that we throw at it but one thing you

might have noticed is that we're writing

this test before we've written or

implemented any actual code why would we

do that

it's not always practical but writing

your test before you write your code can

be extremely valuable because it takes

you through the red green refactor

process you start by writing a failing

test that forces you to think about what

you're trying to do then you figure out

how to do that thing by

implementing some code that makes the

test pass and from that point you can

reflect on what you've done and try to

simplify or optimize your code when you

write good specs they'll be able to

catch issues in your code much quicker

than you can manually debug them and

they also help prevent regressions in

your code when you go back to refactor

things later on and now we're ready to

move on to the easy part the

implementation details now personally

when I go to implement code I try to get

it done as quickly as possible or in

other words have all my tests passing

and have a working prototype in the

least amount of time possible even if

the code is not perfect and the reason

for that is psychological solving a big

problem is a collection of small steps

and when you try to perfect every small

step it takes a really long time to get

to the finish line and that can be

really discouraging

there's nothing worse for a developer

than to work on a project for weeks at a

time only to have the project cancelled

for one reason or another personally I

like to rush to implement my initial

code like I'm doing a hackathon when I

get to a full working prototype I now

have confidence that this problem can be

solved and now it's time to relax get a

good night's sleep and then reflect on

the code in fact here's a little pro tip

that I've learned over the years when

you find yourself banging your head

against the wall in a small problem for

hours just take a break and focus your

mind somewhere else for 15 minutes when

you come back you might magically solve

that problem in five minutes that might

sound silly or just too simple but Isaac

Asimov actually explains that it's your

subconscious still solving the problem

while your conscious mind is doing

something else and that's why people

often have aha moments right before they

go to sleep or in the shower now that we

have a full working prototype let's take

some time to reflect on it there are

many things you can look forward to

improve your code so here's a short list

improve readability by naming things

better add comments remove duplication

and prove the time and space complexity

of your algorithms add caching to reduce

cloud computing costs and improve your

air handling and so on and so on the

bottom line is that it's much easier to

improve a working piece of code than it

is to write a perfect piece of code on

the first go around the last thing you

should keep in mind is that problem

solving is a skill you never stop

learning there's an infinite number of

problems to solve each with its own

unique and novel challenges and you

should take practice seriously practice

we're talking about practice man at the

end of the day it doesn't matter which

programming language philosophy or

framework you use to solve the problem

the only thing that does matter is that

you solve a problem in my opinion the

best way to get good at this skill is to

it's just like a musical instrument

you're not going to pick it up and start

making music right away you have to

spend a huge amount of time practicing

and pushing yourself to overcome new

challenges when you learn to play the

guitar your fingers develop calluses

which build up over months of painful

plane when you learn how to program your

mind develops the ability to look at a

problem and visualize how a computer

system can solve that problem to become

really good at anything you have to

practice and repeat practice and repeat

until the technique becomes intuitive

and lastly get feedback from other

developers especially developers that

are more experienced than you it's easy

to feel self-conscious about your code

especially when you really care about it

but the more you do this the faster your

what the folks per minute will decrease

I'm gonna go ahead and wrap things up

there if you have things you want to add

to this video make sure to leave them in

the comments and if you want to build

entire apps with me consider becoming a

pro member at fire ship IO thanks for

watching and I will see you in the next

one

[Music]