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.

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.

The basic idea is as follows

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.

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

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

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

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

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

Is there something wrong?

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

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.

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.

Here is developer Dora.

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

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

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

Bad weather caused an extreme shortage of food.

Okay, let's give this all a test.

Again, we can use delta debugging to simplify this.

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

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

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.

But what happens if this information is not available?

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

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

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

So why does delta debugging returned cause?

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's caused by melders who have been improperly trained.

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.

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

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

On Macs, Safari supports WebGL but you'll have to do a little twiddle to enable it. Linux has it's own issues.

Because there's something wrong with you.

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.

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

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

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.

It simply means that after any fix you need to verify whether your fix actually did the trick and better yet before the fix, you should be able to precisely predict that your change will actually fix the failure.