Shit programmers write

Maybe we should reevaluate some best practices. I have debated before on here that many unit tests seem useless as the units are too small, and you essentially end up testing your language or framework which you already know works. Integration testing on the other hand makes a lot more sens.

When I started with Java, it seemed appropriate to put hundreds of getter / setter methods. Is there much advantage to that over allowing the variable to be accessed directly? (Perl felt very strange at first having getter and setter methods combined as one method).

As I get more experienced as a developer, my skill set has grown but my coding becomes simpler. Don't use every language feature to show how knowledgeable you are. Use it when appropriate, and when it makes the code more readable / reusable / simpler. Sometimes a higher level abstraction is more difficult to understand , but is overall better choice. An example would be a map as opposed to a for loop. Less chance of side effects in a map, as we don't have to track the iterator variable, but a map is not as intuitive for less experienced coders.

    return bolReturn;

The above actually seems reasonable if you assume the programmer that wrote it was intelligent. I'm imagining that the above code is called multiple times by the application, for a new optional feature in development. Currently, they haven't developed the feature, and so we are always returning false. But in the future, we likely will want to show the feature given some condition. So this programmer has (hopefully) decided that (s)he will write the current code to take this future development into account, and rather than pass some boolean or config value throughout the code, has isolated it to one specific method.

Now, when they go to implement Optional, whatever that is, that developer can just update this one method with the expression, and go about coding their feature without any knowledge of the previous code base, which is exactly what's supposed to happen.

  return foo == null ? null : foo;

  function nop()
  {
      if (Math.random() == 0.1234567890)
      {
          for (var i = 0; i < arguments.length; i++)
          {
              console.log(arguments[i]);
          }
      }
  }

This feels horribly familiar. I'm not sure to recognize the specific language used, but there must be cases where one would like to target empty of filled with non processable characters strings only, and let null and falsy values pass through. This kind of use would typically need a line of comment, but hey...

    if (Math.random() == 0.1234567890)
    {
        for (var i = 0; i < arguments.length; i++)
        {
            console.log(arguments[i]);
        }
    }

"I Don’t Know".ToJson();

    public string ToJson()
    {
        var s = new StringBuilder("{");
        for (var i = 0; i < CustomField.CustomFieldOption.Count; i++)
        {
            var item = CustomField.CustomFieldOption[i];
            s.Append("\"" + item.CustomFieldOptionId + "\"");
            s.Append(":\"" + item.OptionName + "\"");
            if (i < CustomField.CustomFieldOption.Count - 1)
            {
                s.Append(",");
            }
        }
        s.Append("}");
        return s.ToString();
    }

I'm pretty sure there hasn't been reason for anyone to do that for a decade or so, though.

Maybe I'm missing a button somewhere, but I needed to open up the DOM inspector or RSS feed to read every single one.

Unacceptable