This minimal subset then at the given location is the variable that causes the failure.

If we can change a variable value such that the failure goes away, we do have a failure cause.

The basic idea is as follows

Here's a quiz. I invoke the GNU compiler, and it crashes.

Which of the following is not true every infection can be traced back to a defect that causes it, every execution of a defect causes an infection, every infection ends in a failure, and finally, every defect can cause a failure up to you.

What we get in here is actually an entire cause effect chain.

So all of this looks very simple, however, in real life, it's much more complicated than that.

We can have errors that are not causes and causes that are not errors.

Computer glitch.

On the more philosophical level, when delta debugging returns, is not only to simply itself but is also to cause for the failure.

Now let's go and proceed a bit systematically. The situation we are in is classical.

First, we have the ball then we have the window crashing forward.

Be careful when you heard the word theory. Its meaning depends very much on whoever says it.

We're going to look at all the various input sources for your program and discuss how to capture and replay them such that you can faithfully reproduce a failure that happens in the field.

Note, like real infections, they can die out before they ever, ever cause real harm.

Here's one, here's one, and there's one and you fix them and you think you're done, but you don't know whether any of these actually fixes the problem because it may well be that these errors you find that none of them actually causes the failure.

Bad weather caused an extreme shortage of food.

Here is developer Dora.

This infection is now being propagated possibly to other state and eventually becomes visible as a failure towards the user.

And then, there are also some chores to be made.

What's happened to us? A malfunction of some sort.

Is there something wrong?

So this does something very similar to delta debugging pointing out the culprit, which has been changed such that the failure occurs.

Again, we can use delta debugging to simplify this.

Okay, let's give this all a test.

Whereas if you deal with compiler internals, it's a long path from a bug in the compiler to a bug in the actual compiled program, which then, again, has to be executed in order to have the bug cause a failure.

What is an error? An error is something that deviates from what's correct, right, or truth.

On top of that, we're going to build a tool that makes you infer assertions from executions.

We do have a program and the program gets some input and out pops a failure that can be seen by the user.

So the infection is not propagated and never ever becomes visible to the user.

So why does delta debugging returned cause?

Because there's something wrong with you.

I was just following up to make sure phones are okay.

In reality, we have 10,000 of such variables and not only do we have 10,000 of such variables, we also have 10,000 of steps between defect and failure.

It is not the case that every defect always can cause a failure because defects cannot be an unreachable code and therefore, they may not cause a failure.

Finally, we need to make sure that quotes only have a special meaning within tags, so we make this endtag instead.

Most car accidents happen because drivers aren't paying attention.

But what happens if this information is not available?

You can execute a program again and again, never have a failure and still have a defect in there, however, if a program fails, that is if we actually see a failure, then we can always trace it back to the defect that causes it.

We assume that if the patches 3 and 6 are applied, then the failure occurs.

It's not a bug. It's a misfeature.

In order to make sure that the defect is an error, we must show how to correct it and to show that the defect causes the failure, we must show that the failure no longer occurs after we have changed it.

We are going to explore techniques that help you in tracking the way of an error all through the program execution.

We can run the whole thing with this input and very easily reproduce the failure.

It is important to show both the defect is an error and the cause in order to avoid situations in which a defect only is an error but does not cause the failure or that something causes the failure but is not an error.