The SpeedTrace Pro profiler follows and records the program flow of any .NET application on a function/method level for later profiling or tracing analysis, allowing you to identify performance bottlenecks, deadlocks, software design problems as well as resource and data flow problems.

One of the nicest features in this application is the presence of “Callback-API”.
It provides user-extended functionality to allow developers to adapt the tracer to their needs and to write user-specific extensions for dot.NET Framework 2.0, 3.0 or 3.5 applications.

SpeedTrace Pro can make accessible the arguments and return values of a function. This outstanding feature enables you not only to trace function calls but also to obtain the values passed or returned – important data that normal profilers lose during aggregations. You can make use of this data to obtain the relevant information, especially when bugs appear under certain conditions.

The data tracing values of .NET applications may be used to trap bugs easily and to perform data-dependent analyses.

SpeedTrace - .NET Profiler and Tracer

Forget for a second about .NET.
If someone asks you how much is 1.000025 – 0.000025 your answer will probably be “1″ and correct. An easy question, right ?

Now, let’s go back to .NET and check if our calculations are correct.

        static void Main(string[] args)
        {
            double d1 = 1.000025;
            double d2 = 0.000025;
            Console.WriteLine((d1 - d2) == 1);
        }

If you think the result will be “true”… well, it’s not.

Let’s see another example :

        static void Main(string[] args)
        {
            double d1 = 1.000025;
            double d2 = 0.000025;

            // Will result 1
            Console.WriteLine(d1 - d2);

            // Will result 0.99999999999999989
            Console.WriteLine((d1 - d2).ToString ("R"));
        }

For those who might not know, the meaning of ToString(“R”) is Round-trip.

This format is supported only for the Single and Double types. The round-trip specifier guarantees that a numeric value converted to a string will be parsed back into the same numeric value. When a numeric value is formatted using this specifier, it is first tested using the general format, with 15 spaces of precision for a Double and 7 spaces of precision for a Single. If the value is successfully parsed back to the same numeric value, it is formatted using the general format specifier. However, if the value is not successfully parsed back to the same numeric value, then the value is formatted using 17 digits of precision for a Double and 9 digits of precision for a Single.

So, what happened here ? Is it a bug ?
The answer is – NO, IT’S NOT A BUG ( and it’s not happening only on my computer ).

The thing is, that the above is about how .NET rounding a floating point number.
I won’t explain here the math ( there is already a great article explaining it ), and i won’t say don’t use floating point types.

You just need to know that when you are using it – be carefull, especialy in equations and formatting, otherwise your calculations will be wrong and your result not accurate.

What will be the output of the next code ?

static void Main(string[] args)
{
    int i = 100;
    for (int n = 0; n < 100; n++)
    {
         i = i++;
    }
    Console.WriteLine(i);
}

Heisenbug
A heisenbug (named after the Heisenberg Uncertainty Principle) is a computer bug that disappears or alters its characteristics when an attempt is made to study it.

Bohrbug
A Bohr bug or bohrbug (named after the Bohr atom model) is a bug that makes itself manifest consistently under a well-defined (but possibly unknown) set of conditions.

Mandelbug
A mandelbug (named after fractal innovator Benoît Mandelbrot) is a computer bug whose causes are so complex that its behavior appears chaotic.

Schroedinbug
A schroedinbug is a bug that manifests only after someone reading source code or using the program in an unusual way notices that it never should have worked in the first place, at which point the program promptly stops working for everybody until fixed.

Phase of the Moon bug
The “phase of the moon” is sometimes spouted as a silly parameter on which a bug might depend, such as when exasperated after trying to isolate the true cause. The Jargon File documents two rare instances in which data processing problems were actually caused by phase-of-the-moon timing.

Statistical bug
Statistical bugs can only be detected in aggregates and not in single runs of a section of code.

Source : Wikipedia – Unusual software bug

    // Question #1
    class Program
    {
        static void Main(string[] args)
        {
            int i = 13;
            string Result = B.Get(i);
            Console.WriteLine(Result);
        }
    }

    public class A
    {
        public static string Get(int Value) {
            return "A";
        }
    }

    public class B : A
    {
        public static string Get(float Value)
        {
            return "B";
        }
    }

    // Question #2
    class Program
    {
        static void Main(string[] args)
        {
            int i = 13;
            string Result = B.Get(i);
            Console.WriteLine(Result);
        }
    }

    public class B
    {
        public static string Get(float Value)
        {
            return "B";
        }

        public static string Get(int Value) {
            return "A";
        }
    }

What will be the result of the above code parts ?