Browse by Tags

• Arrays
• ASP
• AStar
• baseball
• BBC Television
• Begging the question
• Best Of FAIC
• Big Words
• Books
• Breaking Changes
• Brittle Base Classes
• C# 4.0
• cast operator
• Channel 9
• closures
• Code Generation
• Code Quality
• coin flipping
• Color Color
• COM Programming
• conditional compilation
• constructors
• Continuation Passing Style
• Conversions
• Covariance and Contravariance
• Currying
• customer service
• declaration spaces
• definite assignment
• Delphi
• Dialogue
• double dispatch
• English Usage
• equality
• exception handling
• existing
• Floating Point Arithmetic
• Ford Focus
• foreach
• friend assemblies
• Functional Programming
• goto
• Immutability
• Iterators
• Jargon
• JScript
• JScript .NET
• keywords
• Lambda Expressions
• Language Design
• local variables
• localization
• Mathematics
• maui
• Memory Management
• Metablogging
• Michelle Pfeiffer
• Mistakes
• myths
• Overload Resolution
• partial
• Performance
• precedence
• Psychic Debugging
• Puzzles
• queries
• query continuation
• Rants
• Rarefied Heights
• reachability
• Recursion
• refactoring
• reference
• reference equality
• relativity
• Science
• scope
• Scrabble
• Scripting
• Security
• Simple Names
• skepticism
• Software development methodology
• Static Methods
• switch statements
• Threading
• translation
• Type Inference
• type safety
• unsafe code
• Value Types
• VBScript
• Video
• virtual dispatch
• virtual machines
• VSTO
• What's The Difference?
• Wikipedia
• Z-Machine
• Zork

• Always write a spec, part one

  Joel had a great series of articles many years ago about the benefits of writing functional specifications , that is, specifications of how the product looks to its users. I want to talk a bit about technical specifications, that is, a specification of Read More... Posted Thursday, November 19, 2009 6:45 AM by Eric Lippert | 26 Comments Filed under: C#, Puzzles, Code Quality, Software development methodology

• Closing over the loop variable, part two

  Thanks to everyone who left thoughtful and insightful comments on last week's post. More countries really ought to implement Instant Runoff Voting; it would certainly appeal to the geek crowd. Many people left complex opinions of the form "I'd prefer Read More... Posted Monday, November 16, 2009 8:18 AM by Eric Lippert | 41 Comments Filed under: C#, Breaking Changes, Lambda Expressions, foreach, closures, coin flipping

• Closing over the loop variable considered harmful

  I don't know why I haven't blogged about this one before; this is the single most common incorrect bug report we get. That is, someone thinks they have found a bug in the compiler, but in fact the compiler is correct and their code is wrong. That's a Read More... Posted Thursday, November 12, 2009 6:50 AM by Eric Lippert | 119 Comments Filed under: C#, Breaking Changes, Lambda Expressions, Language Design, foreach, closures

• Three Umpires

  Three baseball umpires are having lunch together. The first umpire says "Well, a lot of them are balls, and a lot of them are strikes, but I always calls 'em as I sees 'em." The second umpire says "Hmph. I calls 'em as they are ." The third umpire slowly Read More... Posted Monday, November 09, 2009 7:01 AM by Eric Lippert | 11 Comments Filed under: C#, baseball

• Simple names are not so simple, Part Two, plus, volcanoes and fried foods

  I've returned from a brief vacation, visiting friends on the island of Maui. I'd never been to that part of the world before. Turns out, it's a small island in the middle of the Pacific Ocean, entirely made out of volcanoes. Weird! But delightful. The Read More... Posted Thursday, November 05, 2009 6:52 AM by Eric Lippert | 9 Comments Filed under: C#, Puzzles, Dialogue, declaration spaces, scope, customer service, Simple Names, maui

• Simple names are not so simple

  C# has many rules that are designed to prevent some common sources of bugs and encourage good programming practices. So many, in fact, that it is often quite confusing to sort out exactly which rule has been violated. I thought I might spend some time Read More... Posted Monday, November 02, 2009 6:23 AM by Eric Lippert | 14 Comments Filed under: C#, Puzzles, Language Design, declaration spaces, scope, Simple Names, local variables, refactoring

• I have a Fit, but a lack of Focus.

  Here's a statement I read the other day about making comparisons between objects of reference type in C#: Object.ReferenceEquals(x,y) returns true if and only if x and y refer to the same object. True or false? My wife Leah recently acquired a Honda Fit, Read More... Posted Thursday, October 29, 2009 6:54 AM by Eric Lippert | 17 Comments Filed under: C#, myths, reference equality, Honda fit, Ford Focus

• Some new videos

  Somehow it has happened again; people just keep on recording videos of me and putting them on the internet. In these videos you find out what I look like when lit from above and behind. Kinda spooky. We should have made the room entirely dark and held Read More... Posted Monday, October 26, 2009 6:17 AM by Eric Lippert | 5 Comments Filed under: C#, Video, Covariance and Contravariance, C# 4.0

• What is this thing you call "thread safe"?

  Caveat: I am not an expert on multi-threading programming. In fact, I wouldn't even say that I am competent at it. My whole career, I've needed to write code to spin up a secondary worker thread probably less than half a dozen times. So take everything Read More... Posted Monday, October 19, 2009 6:50 AM by Eric Lippert | 27 Comments Filed under: C#, Threading, Immutability, Wikipedia, Michelle Pfeiffer, Begging the question

• As Timeless As Infinity

  User: Recently I found out about a peculiar behaviour concerning division by zero in floating point numbers in C#. It does not throw an exception, as with integer division, but rather returns an "infinity". Why is that? Eric: As I've often said, "why" Read More... Posted Thursday, October 15, 2009 6:25 AM by Eric Lippert | 32 Comments Filed under: VBScript, C#, Floating Point Arithmetic, Dialogue, Language Design, exception handling, Delphi

• Absence of evidence is not evidence of absence

  Today, two more subtly incorrect myths about C#. As you probably know, C# requires all local variables to be explicitly assigned before they are read, but assumes that all class instance field variables are initially assigned to default values. An explanation Read More... Posted Monday, October 12, 2009 6:51 AM by Eric Lippert | 15 Comments Filed under: C#, Science, Memory Management, myths, relativity, skepticism, definite assignment, constructors

• What's the difference between "as" and "cast" operators?

  Most people will tell you that the difference between " (Alpha) bravo " and " bravo as Alpha " is that the former throws an exception if the conversion fails, whereas the latter returns null. Though this is correct, and this is the most obvious difference, Read More... Posted Thursday, October 08, 2009 6:36 AM by Eric Lippert | 34 Comments Filed under: C#, Conversions, What's The Difference?, cast operator

• Why No Extension Properties?

  I'm frequently asked "you guys added extension methods to C# 3, so why not add extension properties as well?" Good question. First, let me talk a bit about C# 3. Clearly the big feature in C# 3 was LINQ. In a sense we had only three features in C# 3: Read More... Posted Monday, October 05, 2009 6:29 AM by Eric Lippert | 23 Comments Filed under: C#, C# 4.0, Language Design, extension properties

• Why does char convert implicitly to ushort but not vice versa?

  Another good question from StackOverflow . Why is there an implicit conversion from char to ushort, but only an explicit conversion from ushort to char? Why did the designers of the language believe that these asymmetrical rules were sensible rules to Read More... Posted Thursday, October 01, 2009 9:53 AM by Eric Lippert | 17 Comments Filed under: C#, Conversions, integer arithmetic

• String interning and String.Empty

  Here's a curious program fragment: object obj = "Int32"; string str1 = "Int32"; string str2 = typeof(int).Name; Console.WriteLine(obj == str1); // true Console.WriteLine(str1 == str2); // true Console.WriteLine(obj == str2); // false !? Surely if A equals Read More... Posted Monday, September 28, 2009 6:23 AM by Eric Lippert | 25 Comments Filed under: Performance, C#, equality, string interning