There are a lot of times when we want string comparisons to be case insensitive. It's quite a lot of cases, so every language is going to give us a way to easily specify that's what we want.

Take, for example, this C# code, written by one of Robin's team-mates.

We all make simple mistakes. It's inevitable. "Pobody's nerfect," as they say, and we all have brain-farts, off days, and get caught up in a rush and make mistakes.

So we use tools to catch these mistakes. Whether it's automated testing or just checking what warnings the compiler spits out, we can have processes that catch our worst mistakes before they have any consequences.

"Don't use magic numbers," is a good rule for programming. But like any rule, you shouldn't blindly apply it. We know what happens when people do, however: we get constants that might as well be magic numbers.

Still, there are sometimes novel versions of this old song. Shmuel F sends us this one in C:

Lucio C inherited a large WordPress install, complete with the requisite pile of custom plugins to handle all the unique problems that the company had. Problems, of course, that weren't unique at all, and probably didn't need huge custom plugins, but clearly someone liked writing custom plugins.

One of those plugins found a need to broadcast the same method invocation across a whole pile of objects. Since this is PHP, there's no guarantee of any sort of type safety, so they engineered this solution:

Mike's company likes to make sure their code is well documented. Every important field, enumeration, method, or class has a comment explaining what it is. You can see how much easier it makes understanding this code:

    /// <summary>
    /// Provides clear values for Templates
    /// </summary>
    public enum TemplateType
    {
        /// <summary>
        /// 1
        /// </summary>
        TEMPLATE_1 = 1,
        /// <summary>
        /// 2
        /// </summary>
        TEMPLATE_2 = 2,
        /// <summary>
        /// 3
        /// </summary>
        TEMPLATE_3 = 3,
        /// <summary>
        /// 6
        /// </summary>
        TEMPLATE_6 = 6,
        /// <summary>
        /// 8
        /// </summary>
        TEMPLATE_8 = 8,
        /// <summary>
        /// 10
        /// </summary>
        TEMPLATE_10 = 10,
        /// <summary>
        /// 12
        /// </summary>
        TEMPLATE_12 = 12,
        /// <summary>
        /// 17
        /// </summary>       
        TEMPLATE_17 = 17,
        /// <summary>
        /// 18
        /// </summary>
        TEMPLATE_18 = 18,
        /// <summary>
        /// 20
        /// </summary>
        TEMPLATE_20 = 20,
        /// <summary>
        /// 32
        /// </summary>
        TEMPLATE_32 = 32,
        /// <summary>
        /// 42
        /// </summary>
        TEMPLATE_42 = 42,
        /// <summary>
        /// 54
        /// </summary>
        TEMPLATE_54 = 54,
        /// <summary>
        /// 55
        /// </summary>
        TEMPLATE_55 = 55,
        /// <summary>
        /// 57
        /// </summary>
        TEMPLATE_57 = 57,
        /// <summary>
        /// 73
        /// </summary>
        TEMPLATE_73 = 73,
        /// <summary>
        /// 74
        /// </summary>
        TEMPLATE_74 = 74,
        /// <summary>
        /// 177
        /// </summary>
        TEMPLATE_177 = 177,
        /// <summary>
        /// 189
        /// </summary>
        TEMPLATE_189 = 189
    }

Linda found some C# code that generates random numbers. She actually found a lot of code which does that, because the same method was copy/pasted into a half dozen places. Each of those places was a View Model object, and each of those View Models contained thousands of lines of code.

There's a lot going on here, so we'll start with some highlights. First, the method signature: