This question exists because it has historical significance, but it is not considered a good, on-topic question for this site, so please do not use it as evidence that you can ask similar questions here. This question and its answers are frozen and cannot be changed. More info: help center.

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
If this question can be reworded to fit the rules in the help center, please edit the question.

''' <summary>
''' Represents an exception that was logged. Since System.Exception implements IDictionary, it can't be
''' serialized, so I had to write this. Pretty fucking stupid thing to have to do, System.Exception should
''' be serializable right out of the box, IMHO.
''' </summary>
''' <remarks></remarks>
Public Class LogException

A large project I worked on used StyleCop and FXCop in the automated build with rules to prevent people checking in code with uncommented fields, methods, properties etc., etc.

Someone got so pissed off with having to add comments like "Gets or sets the full name." to self-documenting properties like FullName, that they went to the effort of writing a macro to get around the rules.

The macro inserted XML summary tags for methods, properties etc. with a single non-displaying Unicode character as the tag content which would fool the build rules whilst simultaneously striking his minor blow against mindless insistence on commenting stuff for the sake of it...

...at least until they introduced another rule to check for Unicode characters in comments.

Sometime in the early 1980's we were writing financial modeling code for utilities in PL/I. Got a call from a client with code blowing up right after a comment

/* Honest this works */

The guy had taken our standard set of financial equations and done about 15 pages of algebra to combine a bunch of code into one equation. After Three Mile Island when utilities had to write off their nuclear plants at huge costs the equation failed because of a FIXED BIN 15 (integer) overflow that would not have happened if the algebra hadn't happened.

// StupidCompilerDontInline(SCDI), in the test project where
// allcode was in a single cpp the compiler had inlined nearly
// everything which lead to nice stackoverflow.
// To prevent this the metods are made virtual
#define SCDI virtual

Had a programmer working for me once that put "Style" comments throughout his code where he codified his internal debates about the particular implementation details and to take parting shots when he was overruled on a particular coding decision.

Examples:

'STYLE
'It's arguable which is better, but I pass the image handle rather than simply
'passing the scaling values in order to keep the calling code simpler (by a
'couple of declarations statements). Alternatively, I could pass these data
'members directly from the calling code, but that would violate encapsulation.

'STYLE
'As I have done elsewhere, I will register my offical protest (just give me the
'forms to fill out) regarding the implementation of annotation serialization as
'a property rather than a pair of Load/Save methods. Again, this is probably a
'matter of style and eminently debatable.

Here's a few that I've put in my code at various times. Some aren't technically comments, but they're the same sort of concept.

In a cross-platform project that needs some special code on one platform only:

//If defined, will include all the Windows-specific code.
#define LOSE
#ifdef LOSE
#include <windows.h> //WIN32. Duh.
#endif
---------------------------------------------------
//Stolen from other_project_name.cpp
---------------------------------------------------
/*
* These comments have been lifted from propagate() and, though they no longer apply to the code, they may still be of value somewhere. Original tabbing and structural elements have been preserved.
*/
//CAUTION: This has a major Bobby Tables risk. Even if a rulebuilder is used, there's still the risk of something getting corrupted in the database itself.
//Reading text from anywhere and simply slotting it into an SQL statement is a major security risk. (With thanks to xkcd for the name "Bobby Tables".)
//Requirement: Eliminate one Bobby Tables by changing [redacted] to be not just straight SQL.
[lots more comments that are not as funny]
/*
* End of lifted comments. There should not be any executable code between these markers.
*/
---------------------------------------------------
/*
Okay. It's unrecognized. Why is this a fatal error? It's actually very closely akin to the miswart of botched #includes being a fatal. When writing a C/C++
program, you need your headers, and if you don't have one, chances are there'll be a million cascaded errors; so by making "unable to open asdf.h" a fatal,
the compiler suppresses all those errors about undefined symbols and potentially misspelled type names.
*/
---------------------------------------------------
//If someone tries to import 'id' as a field name, it won't work. (We already have our own id.) But I think the probability is so low that I can afford to be funny.
if (!stricmp(ptr,"id")) {warn(0,"Import","","'id' is a reserved word and cannot be used as a column name. (Try 'ego' or 'superego'.)"); return;}
---------------------------------------------------
//Need a place to squirrel away SQL statements somewhere
char *uts[1024]; //Unified Temporary Storage. (Why? Because I said so.)
int nuts=0; //What is it that squirrels keep? Ha!
int utsid[sizeof uts/sizeof *uts];
---------------------------------------------------
/**************************************\
* NOTE: This sets tilde.action. If a *
* tilde header does not exist in the *
* import file (not the _content_, if *
* the entire column isn't there), it *
* will duplicate down through all of *
* the rows. This is fine for ~id, as *
* that will never be changed; and if *
* ~Quantity is blank, that throws an *
* error in 'Add'. With ~Action, I am *
* not so certain. I THINK it'd be OK *
* to dup-down most of the time... if *
* the user only ever imports Adds or *
* Revises, but never both at once in *
* a single import. So for safety, to *
* allow a blank ~Action to revise OR *
* add, I'm breaking the check out to *
* a new variable - the curaction. In *
* most cases, it won't be needed, so *
* it's a waste; but it isn't like it *
* has to copy the entire tilde.*, so *
* it's only a small waste. So it can *
* waste a register... big deal. OK ! *
\**************************************/
---------------------------------------------------
//if (!response) // we're going to crash
//if (!items) // we're going to crash
//TODO: Don't crash
---------------------------------------------------

A lot of my comments contain obscure references to films or musicals, but they won't be nearly as funny if you don't know the show.