The inspiration for today's post comes from a piece of code – more precisely from one of those famous // TODO comments.
So here's the comment alongside with the line of code:
 

                // TODO unabhängig von Sprache machen
                properties["authorizedGroup"] = "Benutzer";

You are already wondering what "unabhängig von Sprache machen" and "Benutzer" mean – right?

This is the first thing to avoid:

1. never, NEVER EVER – not even while hacking some website with a gun pointed to your head and a blonde giving you head (Swordfish)… OK maybe this is a valid excuse to not comment at all – write your comments in any other language than English.

You will write 100% of your code in English and if you decide to write your comments in German/Polish/Esperanto/Swahili you'll force your brain to switch context dozens of times while reading your code. There is conclusive evidence that switching contexts disrupts your efficiency while coding.  So just don't do it. Write in English. You'll probably improve your English skills along the way.

2. Learn English

Learn to read and write English – proper English. I flinch everytime someone storms into the C# chat over on StackOverflow and writes sentences like this: "I gut prob w/ ASP.NET MVC3. Do u any exp w/ it?"
This sounds like the writer has learned English from the graffitis in the background of an American movie with subtitles. Probably from the movie Dangerous Minds or worse.
Extra tip for readers from India: Putting a 'sir' behind every sentence does improve neither spelling nor grammar.

3. Write about programming – in English

I started this blog for exactly that reason: I want to better communicate my ideas and thoughts about programming. I want to be able to do that in English, because English is the lingua franca for software developers. I want to be a great programmer and I share Joel's opinion, that you the difference between tolerable and great is ability to communicate. After graduation from university I am going to be a military leader of 40-200 men and women. I need to be able to communicate in a concise way and yet not miss important details.
If starting your own blog seems like to much trouble for you, go over to StackOverflow and start answering questions. Try to make your answer the most awesome answer on the web.

4. Install only English versions of your IDE

This is especially true if your IDE is being shipped by Microsoft. For all that Microsoft does really well with its OS, the programming languages, the framework, world peace (OK maybe not with that), the fact is they… ummm… suck at translations. I know professional interpreters that outright refuse to do any work for Microsoft, because of their translation policies.
The number of times I've been trying to find the Microsoft translation (English to German) of a menu item in Visual Studio is beyond count. Often times this boils down to "third menu from the right, fourth item from top" in the end.

5. When logging error messages always use English messages

For the same reasons stated earlier on, I recommend you log all your exceptions / errors in English. This is especially true for exceptions that are automatically translated into the computer's locale – as happens with most exceptions in .NET. Imagine you are receiving a logfile from a customer in Libya and find the error messages written right to left in an unfamiliar alphabet. Good luck finding that bug.
This can be worked around for most exceptions in .NET (solution on StackOverflow) and I'm sure you'll find a way to make it work in your programming language.

6. Bonus tip: get the job done

No matter whether you are a native English-speaker or not, the main part of being a software developer is getting things done.

You have more tips to share?

Please post them in the comments and keep discussing

While catching up on Eric Lippert's blog I just found Programmer Ryan Gosling's tumblr archive.

Check it out. There are some cool pictures there!

Did you ever stumble upon a code block looking something like this?

try
 {
 // do  something
 }
 catch(Exception)
 {
 // swallowed for no good reason
 }

Well, hopefully it wasn’t you who swallowed the exception in the first place.
There might be various reasons for swallowed exceptions and I plan on dedicating a blog post to this topic some day.
Meanwhile suffice to say that there are cases in the wild, where you can’t go back to the code, insert some logging, recompile, build and ship your software.
Might be, that you don’t have the code (third party library used) or even that the CLR swallows the exception (which happens on x64 systems under certain conditions).

However, it might be handy to get a notification every time an exception is thrown.
Luckily, the .NET Framework provides a mechanism for just that. With the AppDomain.FirstChanceException event you can access any exception before it is passed on for handling.

So how do you do this?
It is really quite simple. All you have to do is to register for the event and have an appropriate event handling method:

public static void Main(string[] args)
{
    AppDomain.CurrentDomain.FirstChanceException += FirstChanceHandler;
    try
    {
         throw new Exception("swallowed exception");
    }
    catch(Exception) {}
}

static void FirstChanceHandler(object source, FirstChanceExceptionEventArgs e)
{
    Console.WriteLine(e.Exception);
}

This will print out the exception to the console just as if it had been handled in the catch block.
Note that you can not handle the exception in the event handler! So you still want to write exception handling code.
Furthermore, throwing an exception inside the event handler will (of course) run that very same event handler again and so on, resulting in a StackOverflowException. Not something you want to happen in your app! So be extra careful in that event handler and apply proper exception handling.

This feature comes in pretty handy to get information about any swallowed exceptions that happen in your application.
Additionally, it can be used as a sort of monitoring and early warning system. While exceptions are – mostly – an effect of normal program execution (if they are handled correctly), it is interesting to know which exceptions get thrown and how often they are thrown.
In one of the future articles I will go into further detail on how to create a logging framework for first chance exceptions

This is a summary of  the highest ranking (by vote count) answers from the corresponding StackOverflow.com thread

• Double brace initialization by Boris Terzic
• ThreadLocals (mentioned in the same answer) by Boris Terzic
• joint union in type parameter variance by Apocalisp
• Initializer blocks by David Carlson
• VisualVM by Kevin Wong [available from JDK 1.6_07 onwards]
• labeled blocks / goto by Georgy Bolyuba
• covariant return types by serg10
• transfer of control in finally blocks ‘hiding’ exceptions by James A. N. Stauffer
• methods / constructors in enums by Adrian Mouat
• classpath wildcards by crowne [Java 6 and above]
• Null-checking via instanceof by Cadet Pirx
• type params for generic methods by Kevin Wong

Those are all the hidden features that scored 100+ votes at the time of this writing.

——————————————————————————————————————
I think this is a fine list of some rarely known (read: put to good use) framework classes (ThreadLocals), language functions (NULL checking via instanceof) and tools (VisualVM).

However, I find some of the elements on the list irritating. Take for example the labeled blocks and the infamous goto keyword. I have a hard time understanding why this keyword has been implemented in the first place. And even though it is there, I have not seen it being used in production code.
And this might be the answer to the question: It got this much votes, because people are surprised that goto was implemented in Java at all.

This is my first post in my very own blog. So besides the (albeit) few facts you can read about me on the About page, I’d like to explain why I started this blog.

First and foremost, this is because I love programming. I am reasonably good at it, but I lack in the skills to clearly express myself to fellow programmers. I encountered this time and again, but now is the time to change something about it.
Starting now, I will write blog posts on a regular basis. I’ll try to do two posts a week – hoping that it will improve my writing skills.

Secondly, the spark that started this all came from Stackoverflow.com. The community over there is awesome. One rather common thread is the “Hidden features of [place your favorite programming language here]” thread. Unfortunately, those threads are closed regularly. This leaves those threads without a good summary (see ‘Hidden Features of Java’ for an example). So I’d like to provide summary pages with deep links.

The topics will focus on those “hidden” language features (e.g. the null-coalescing operator in C#). I am aware of the fact that no language feature is really hidden. Most languages today are reasonably standardized and you could always read the specification front to end. But frankly, not many of us do this (me included).
Plus, I enjoy reading those threads on StackOverflow.com from time to time as helpful reminders.