How reliable is an if statement?

Question

If I run the following code,

while(true)
{
    if(true)
    {
        Console.WriteLine("True");
    }
    else
    {
        Console.WriteLine("False")
    }
}

How reliable is it that the Console will print "True" ? Will if ever print "False" ? Why ?

Edit: I had no idea that physical components of a computer were so perfect.

Answer 1

The question is a bit more interesting than downvoting peple think.

Sure, that conditional logic is really perfect. Visual studio generates a warning: Unreachable code detected, so the else branch will never ever be executed.

Even in case of hardware fault, computer / operating system / program itself is more likely to crash than the second brunch to execute.

But it does not mean that "False" will not be printed. String literals in dotnet normally are interned. Look at this hack:

static unsafe void Main(string[] args)
{
    // "True" is interned now
    string s = "True";

    // unsafe access to the interned string
    fixed (char* h = s)
    {
        // We have to change the length of the string.
        // The length is stored as integer value right before the first char
        ((int*)h)[-1] = 5;

        // Next operations change content of interned string
        h[0] = 'F';
        h[1] = 'a';
        h[2] = 'l';
        h[3] = 's';

        // But next one is dangerous - they can damage memory contents 
        h[4] = 'e';
    }

    // the most reliable code ever:)
    while (true)
    {
        if (true)
        {
            Console.WriteLine("True");
        }
        else
        {
            Console.WriteLine("False");
        }
    }
}

The else branch is not executed, which can be ensured with debugger, so the conditional logic is still consistent. However the program prints "False" even through the System.Console's method.

This trick requres enabling the unsafe context in the compiler options, moreover, it can damage process's memory.

Answer 2

I'd say reliable enough that you don't have to worry about it, but not perfect.

For example there is a slight chance that the bit that says true is flipped to false (cosmic rays interference, faulty ram, bad luck..) and you're program would then write False. These types of errors are called soft errors.

Studies by IBM in the 1990s suggest that computers typically experience about one cosmic-ray-induced error per 256 megabytes of RAM per month.[1]

Note that most modern compilers would remove your if branch due to optimization, thus further reducing chance :).

And of course memory is not the only thing that could go wrong. CPU could probably make mistake when evaluating compare instruction, hard drive might store the program itself wrongly, OS could fail to protect memory of your process from some other faulty process, etc.. All these things are extremely unlikely.

Related Question: https://softwareengineering.stackexchange.com/questions/34120/how-often-do-cpus-make-calculation-errors

Answer 3

It will ALWAYS print "True" because that is the way that it is designed.

Answer 4

If it didn't display true I think the whole of computing would suddenly become flawed. There is an area of computing where this might apply look at "fuzzy logic" in google.

Answer 5

The only way it could print "False" is if you did something like this:

using System;

namespace Demo
{
    public static class Console
    {
        public static void WriteLine(string unused)
        {
            System.Console.WriteLine("False");
        }
    }

    public static class Program
    {
        private static void Main(string[] args)
        {
            if(true)
            {
                Console.WriteLine("True");
            }
            else
            {
                Console.WriteLine("False");
            }        
        }
    }
}

(Yes, this does indeed print "False" - but clearly I cheated. ;))

But aside from cheating, an if statement, like all other boolean logic, is completely reliable and deterministic.