It takes an order of magnitude less mental energy to define a problem compared to solving said problem.

God I wish I didn't relate to this.

Laziness is occasionally a virtue while programming; sometimes it takes less time to write the linq statement rather than a foreach.

But then again, if it’s such a trivial app that I’d sacrifice future maintenance for completion speed, then I’m likely the only one who’s gonna ever use it.

I dunno, maybe they overloaded the division operator. Overloading / will affect /=

Well, if you didn't want to be condescended to,

_<3

Nobody tries to be a CTO. It just happens.

https://www.virtualbox.org/wiki/VirtualBox

287.4.12.0/25, huh? you know you still have up to 287.4.12.127, right?

At least that's what it would mean if there were 287 values in an octet. Jusging by the first "octet" you're using some kind of super future IP protocol that looks like an impossible IPv4 network address, and packs nine bits in the space of eight.

Tell me your secrets of IPv40 future man! When will they releease the >255 octets?

It's still 100% HOSIX compliant.

I am Spartacus!

Take a walk. Think. You were obviously focused on someother feature in the code, and shouldn't beat yourself up. Just ask yourself what put you down the path that you took, and what you could have done to recognize that you were looking in the wrong place. Maybe you can learn something about how your co-workers handle certain issues, making you synergise more effectively.

Mainly, learn from it.

Brainfuck

Most of the question has been answered in great depth already, however there is one detail that has not yet been mentioned: the fact that classes are reference-type object and not value-type objects (like structs).

The primary difference here is that when you assign a reference type object to a variable, that variable actually becomes a reference to the assigned object. Consider the following:

namespace ReferenceEx
{
     class Program
    {
        public static void Main()
        {
            RefTypeEx objectA = new RefTypeEx(8); //A has initial value of 8
            RefTypeEx objectB = new RefTypeEx(10); //B has initial value of 10.
            objectA = objectB; //Assign B to A.
            objectA.Val = 6; //change A's value to 6. Because A is now just a reference to B, B's value also changes to 6.
            Console.WriteLine(string.Format("A is {0} and B is {1}", objectA.Val, objecB.Val);  //display the behaviour.
        }
    }
    class RefTypeEx
    {
         public int Val;
         public RefTypeEx(int input)
        {
            val = input;
        }
    }
}

A and B both start as discrete instances, each with different values.

B is then assigned to A, making both of them references to the same instance. As a consequence, as no other code looks for that old initial value of A, that object is "disposed" by the .net runtime.

For a more specific explanation, B and A start off with the same blueprint, but once instanciated, look at different chunks of memory. When we assign B to A, we give the location in memory to A and it will start looking at the exact same memory location. For all intents and purposes, B and A become different ways to access the same memory location.

Why don't we just fork it?

Yes, you need to install Synesthesia on your brain.

Perl 'compiles' to bytecode in a very similar way to Java. It's still interpreted.

Inasmuch as c# and most c-style syntax languages are concerned:

> is the greater than operator. '3>1' evaluates true.
< is the less than operator. '1<3' evaluates true.
<< is the bit-shift left operator (shift to higher order) 10 << 1 will evaluate to 20 (00001010 becomes 00010100)
>> is the bit-shift right operator (shift to lower order) 20 >> 1 will evaluate to 10. 

<T> is a type argument where T is the name of a type. It is used in generics to specify a type at run time rather than at compile time.

Consider the following:

List<String> gCollection = new List<String>();

In this example, the type argument is String, telling the constructor for the List class that its elements will either be of type string, or a type derived from string.

Here's the complete c# specification. It includes definitions, descriptions, and interrelations of all basic features of the language.

http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf