Original subtitles

So we talked about problem solving,

which is a very important skill of any software developer.

Now, another extremely important

developer skill is debugging,

which means to find and fix errors.

So let's finish this section by talking about debugging

to make you ready for the rest of the course ahead.

So first of all, as you might already know,

a software bug is a defect or a problem

in a computer program.

So basically, any unexpected or unintended behavior

of a program is called a bug.

And the actual term bug was coined in the 1940s

when this real bug was causing an error

in Harvard's computer.

Now, there are many reasons for bugs in programs,

but what matters here is that bugs

are a completely normal part of software development,

because we are humans,

and humans make mistakes.

In fact, every complex application contains bugs,

which sometimes go undiscovered for years

and can cause security holes or other problems.

So really, don't feel bad if you introduce bugs

in your own count.

We all do it, even the most expert programmers.

Now luckily, not all bugs cause huge security holes.

In fact, many bugs are quite small

and simple to discover.

So let's see a simple example.

Remember in our previous example,

the goal was to reverse whatever was passed

into the function.

So let's say we finished writing the reverse function,

and call it with this array and get this result.

But clearly something is wrong here, right?

The return value looks scrambled,

but not reversed at all.

So this means that we must have a bug somewhere

in our reverse function, okay?

To fix this, we use a process called debugging,

which is essentially finding, fixing,

and then preventing bugs.

So let's see how that works.

So the first step is to actually become aware

that there is some kind of bug,

because as I said, in a large application,

bugs can actually go undiscovered for years.

Now, discovering bugs usually happens

during development using automated testing software

or user reports during production.

And bugs that are identified during production

are the worst bugs,

because it means that they went undiscovered

during development and are now affecting

real users of our application.

So that's why it's really important

to identify bugs early,

for example, using automated tests.

Now, while identifying the bug,

sometimes we also need to take into consideration

the context in which the bug happened.

For example, certain bugs might only happen

in a certain browser,

or only for certain users, for some reason.

Next, once we know there is a bug,

we need to go into our code and find the bug.

We need to isolate where exactly it's happening,

and we can do that using the developer console

that we already know.

However, that only works for small bugs

and simple code where we have a good idea

where the bug might be located.

But if the code is more complex

and we have no idea where the bug might be,

then we need to use a debugger software.

And I will show you how that works in the next video

because it's really important for developer

to be able to use a debugger.

Anyway, once we know where the bug is located,

we can finally fix it so we can correct the bug.

And this is probably the easiest part.

So essentially, all we need to do

is to replace the existing, so the wrong solution,

with a new correct solution that actually works.

As a final step, we should then prevent this bug

from ever happening again in our code base.

For example, we can search our project

for the same bug in similar code,

like in a similar function.

It's totally possible that we did the same mistake

twice in our code,

and if that's the case,

we must fix the bug everywhere.

A more advanced way of preventing bugs

is to write tests using testing software.

And I might add a bonus section on testing

to the course at some point

because this is actually an important part

of software development.

Okay, and that's it.

That's a broad overview of debugging in programming.

And we really just scratched the surface here,

because you're still at the beginning of the journey.

And so this is just an introduction.

Anyway, let's now fix some bugs in the next video.