HACKS:

There is also a trick for 'toggling' comments, a single character can comment out one piece of code, and uncomment another:

/*
inside_comment();
/*/
outside_comment();
//*/

//*
outside_comment();
/*/
inside_comment();
//*/

If you're in C or C++, use the preprocessor instead, like this

#if 0
if ( foo == bar )
{
dosomething();
return();
}
#endif

Changing the 0 to a 1 uncomments. Bonus, you don't have to worry if there is an existing /**/ comment block in the code you're commenting out. Double bonus, you can nest #if statements.

ifdef's are way better for removing code because they always work, even if you are removing code that has comments in it

I sometimes put something like this while writing css files:

/* *
* { outline: 1px solid red; }
/* */

a.

I used to do almost exactly the same thing, depending on syntax highlighting to reveal the comments.

I do occasionally but almost every other time I use #ifdefs. Much long but MUCH more formal and it allows me to see the code that's being hidden in the syntax highlighting - or conversely, if someone's reviewing my code and doesn't have syntax highlighting, the fact that those lines of code are not being compiled is far more obvious with the #ifdefs.

You know, quickly toggling CSS comments (with their damn C-style comments only) has always driven me crazy. This is a great idea.

It may be neat for a while, but when you return to your code in 6 months, you'll find that the code is now less readable.

You could also use the blockcomment plugin for vim. Admittedly, it's a little more than a single character (select block + \x and same to uncomment)

If you need to put documentation, liscence, or other rather uniform (i.e. you want to script their insertion) headers on something written in scheme and C you can do something like:

;;/*
;; Commentary here
;;*/

and have only one script. Depending on compiler settings the C compiler might whine about empty statements, but there's really no way arround that one. This way you only need one headerify script.

FYI, the Lua language has this feature by design - with "--[[" on the opening line and "--]]" on the closing line. To disable the comment, insert a space on the first line, i.e. change it to "-- [[".

See http://www.lua.org/manual/5.1/manual.html#2.1

Use an editor where you can just toggle in and toggle out of comments? Textmate for example.

I've used

/*/
Old Version
/*/
New version
/**/

in the past, which can be toggle between the two blocks with an extra * in the top line.

I use this frequently:
#if 1
// New code here
dosomethingelse();
#else
// old code here
dosomething();
#endif

Changing the 1 to a 0 allows you to quickly switch between the old and new code. If you're making multiple changes, just do:
#define NEW_CODE 1
#if NEW_CODE
#else
#endif
This allows flipping multiple blocks between old and new with a single change.

I wanted to post about the comment toggling but Twan and Robin both beat me to it! It's funny to see how many people have discovered and use that little trick.

If you want to read this in its original form (from 8 years ago, no less) and lots of other C tricks, then head over to http://www.gamedev.net/reference/articles/article1239.asp