Wanted! Eric Lippert old hits

If you suddenly didn’t know, besides any nonsense published on this blog, I’m also translating Eric Lippert’s Fabulous Adventures in Coding blog into Russian. In the Russian version, this blog is called Incredible Adventures in the code .

I have been engaged in this business for a year and a half and have never regretted the time spent. I hope that reading Eric's articles in Russian gives at least a fraction of the pleasure that I get when translating!

But today I am not talking about that. More precisely not quite about that. We began to publish translations dating back to April 2009, but, surprisingly, before that, Eric wrote no less often and no less interesting. Therefore, I propose to return to his old hits and restore justice, so to speak, and translate into Russian and them.
')



I made a small list of what I think to translate, but it is quite possible that I missed something (and I missed something for sure), so I am completely open to suggestions (*). So, here is the list itself:

• The Stack Is An Implementation Detail, Part One (2009-04-27)
  
  The Stack Is An Implementation Detail, Part Two (2009-04-05)
  A couple of very interesting and popular articles, in which the difference between significant and reference types is considered from the point of view of the locations of their instances in memory. This topic is considered, probably, in hundreds of different articles, and Eric himself writes about this very often. However, this is one of the best notes in this thread.
  
• Events and Races (2009-04-29)
  
  One of the classic questions of the correct “ignition” of events is the question of multithreading. This post is about that.
  
• Representation and Identity (2009-03-19)
  
  An excellent note about why when unpacking a packed byte into an int, we get an InvalidCastException exception.
  
• Locks and exceptions do not mix (2009-03-06)
  
  The article discusses the changes made to the implementation of the Monitor.Enter method in .Net 4.0 to prevent possible deadlocks, which were quite possible in earlier versions of the .Net Framework.
  
• References are not addresses (2009-02-17)
  
  The difference between references and pointers in the C # language is considered, and, as the name says, Eric shows why it is incorrect to treat links as an address in memory.
  
• Why no var on fields? (2009-01-26)
  
  And really, why? I have already answered some of these questions quite recently in my article , well, it's better to read all the difficulties of compiler implementation with Eric :)
  
• Vexing exceptions (2008-09-10)
  
  Very useful article in which three "semantic" types of exceptions are considered. All this helps to fix some issues of exception handling in my head and yet understand how to handle them.
  
• High maintenance (2008-09-08)
  
  An excellent review of just one function, in 6 lines of which 5 different code smells are shown. Many interesting thoughts, ranging from the contract functions to the problems of preliminary generalization (premature generialization).
  
• Reading Code Over the Telephone (2008-05-16)
  
  Not rocket science, but, nevertheless, it is very useful to know how various lambda expressions are read.
  
• Subtleties of C # IL codegen (2007-08-17)
  
  An interesting note that shows why, for example, lock (expression) statement is not thread-safe in case of asynchronous exceptions, and also considers the difference between the call and callvirt instructions .
  

Let me remind you once again that this is not a complete list, but only what was in my bookmarks, so there is no claim to completeness. And therefore, I am waiting for your offers!

----------------

(*) I hope for a reasonable argument of the proposals. We are simply unable to translate and publish all the old posts, and frankly, there is no need for that. Therefore, if you propose a certain article to be translated, it is reasonable at least to provide a brief summary (with a couple of sentences), and if possible, tell them what makes it so outstanding.