Wanted! Old hits by Eric Lippert

If you suddenly did not know, then in addition to all the nonsense published on this blog, I also translate Eric Lippert's Fabulous Adventures in Coding blog into Russian. In the Russian version, this blog is called Incredible Adventures in Code .

I have been doing 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 small fraction of the pleasure that I receive when translating!

But today I’m not talking about that. More precisely, not quite about that. We began to publish translations dated 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, so to speak, justice and translate them into Russian.




I made a short list of what I am thinking of translating, but it is quite possible that I missed something (and I definitely missed something), 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 that discuss the difference between significant and reference types from the point view locations of their instances in memory. This topic is probably covered 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 issue of multithreading. This note is about this.
  
• Representation and Identity (2009-03-19)
  
  An excellent note on why, when unpacking a packed byte into int, we get an InvalidCastException .
  
• 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 that were quite possible in earlier versions of the .Net Framework.
  
• References are not addresses (2009-02-17)
  
  The difference between links and pointers in C # is considered, and, as the name says, Eric shows why links are incorrectly viewed as an address in memory.
  
• Why no var on fields? (2009-01-26)
  
  And the truth is why? I already answered some of these questions quite recently in my article , but it’s better to read all the difficulties of compiler implementation from Eric :)
  
• Vexing exceptions (2008-09-10)
  
  A very useful article that addresses three “semantic” types of exceptions. All this helps to settle in the head some issues of exception handling and still understand how to handle them.
  
• High maintenance (2008-09-08)
  
  Excellent review of just one function, in 6 lines of which 5 different code smells are shown. There are a lot of interesting thoughts, starting from the function contract ending with 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 the various lambda expressions are read.
  
• Subtleties of C # IL codegen (2007-08-17)
  
  An interesting note that shows why, for example, a lock (expression) statement is not thread safe in case of asynchronous exceptions, and also discusses the difference between call and callvirt instructions .
  

I 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'm waiting for your suggestions!

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

(*) I hope for a reasonable argumentation of the proposals. We are simply not able to translate and publish all the old posts, and frankly speaking, there is no need for this. Therefore, if you are proposing a certain article for translation, then it’s wise to at least give a brief summary (a couple of sentences), and if possible, tell us why it is so outstanding.