- Bean Machine Retrospective, part 8
- Bean Machine Retrospective, part 7
- The names of birds, part 4
- The names of birds, part 3
- Bean Machine Retrospective, part 5
- I want toast
- Bean Machine Retrospective, part 4
- Bean Machine Retrospective, part 3
- Bean Machine Retrospective, part 2
- Bean Machine Retrospective, part 1
- Implementing a full fence
- Life, part 33
- Approximate results may vary
- Life, part 32
- Socially distant abbreviated summer vacation
- Life, part 31
- Life, part 30
- Life, part 29
- Life, part 28
- Life, part 27
- Life, part 26
- Life, part 25
- Life, part 24
- Comet NEOWISE
- Life, part 23
- Life, part 22
- Life, part 21
- Life, part 20
- Life, part 19
- Life, part 18
- Life, part 17
- Life, part 16
- Life, part 15
- Life, part 14
- Police brutality in Seattle
- Life, part 13
- Life, part 12
- Life, part 11
- Life, part 10
- Life, part 9
- Life, part 8
- Life, part 7
- Life, part 6
- Summer vacation 2019 part four
- Summer vacation 2019 part three
- Summer vacation 2019 part two
- Summer vacation 2019 part 1
- Porting old posts, part 4
- Fixing Random, part 32
- Fixing Random, part 31
- Applying machine learning to coding itself
- Fixing Random, part 30
- Fixing Random, part 29
- Fixing Random, part 28
- Fixing Random, part 27
- Porting old posts, part 3
- Fixing Random, part 26
- Fixing Random, part 25
- Fixing Random, part 24
- Fixing Random, part 23
- Fixing Random, part 22
- Porting old posts, part 2
- Fixing Random, part 21
- Porting old posts, part 1
- Fixing Random, part 20
- Fixing Random, part 19
- Fixing Random, part 18
- Fixing Random, bonus episode 1
- Fixing Random, part 17
- Fixing Random, part 16
- Fixing Random, part 15
- So long, MSDN blog
- Fixing Random, part 14
- Fixing Random, part 13
- Fixing Random, part 12
- Fixing Random, part 11
- Fixing Random, part 10
- Fixing Random, part 9
- Fixing Random, part 8
- Fixing Random, part 7
- Fixing Random, part 6
- Fixing Random, part 5
- Exhausting vs exhaustive
- Fixing Random, part 4
- Fixing Random, part 3
- Fixing Random, part 2
- Fixing Random, part 1
- An interesting list structure, part 3
- An interesting list structure, part 2
- An interesting list structure, part 1
- Indexer error cases
- Dual numbers, part 4
- Dual numbers, part 3
- Dual numbers, part 2
- Dual numbers, part 1
- Accessibility of nested classes
- Adventures in podcasting
- A dynamic definite assignment puzzle, part 2
- Not so fabulous adventures in banking
- A dynamic definite assignment puzzle
- Anti-unification, part 6
- Anti-unification, part 5
- Anti-unification, part 4
- Anti-unification, part 3
- Anti-unification, part 2
- Anti-unification, part 1
- Unification, part 2
- Unification, part 1
- That was a long break
- Excessive explanation, part twenty-four
- Excessive explanation, part twenty-three
- Excessive explanation, part twenty-two
- Excessive explanation, part twenty-one
- Happy anniversary Visual Studio!
- Excessive explanation, part twenty
- Excessive explanation, part nineteen
- Excessive explanation, part eighteen
- The chess mystery, solved
- Why should I be worried about dying?
- Excessive explanation, part seventeen
- Excessive explanation, part sixteen
- Excessive explanation, part fifteen
- Excessive explanation, part fourteen
- Excessive explanation, part thirteen
- Real Americans
- Excessive explanation, part twelve
- Excessive explanation, part eleven
- Excessive explanation, part ten
- Excessive explanation, part nine
- Excessive explanation, part eight
- Excessive explanation, part seven
- Excessive explanation, part six
- Excessive explanation, part five
- Another spicy interview
- Excessive explanation, part four
- Excessive explanation, part three
- Impactfulness
- I’m on fire!
- Excessive explanation, part two
- Bat room
- Mine entrance
- Slide room
- Winding passage
- Drafty cave
- Twisting passage
- Mirror room
- Hades
- Entrance to Hades
- Windy cave
- White Cliffs Beach
- Frigid River, in the magic boat
- Dam base
- Reservoir North
- Reservoir
- Maintenance room
- Dam
- Reservoir south
- Studio
- Sandy cave
- Aragain falls
- End of rainbow
- Canyon view
- Another troll room
- Forest edge
- Altar
- Egyptian room
- Temple
- Dome room
- Round room
- Troll room
- Cellar
- Attic
- Living room
- Kitchen
- Behind house
- Up a tree
- Like me, on Facebook
- Forest path
- North of house
- West of house
- The dedoublifier, part one
- Monitor madness, part two
- Monitor madness, part one
- Logical implication
- When would you use & on a bool?
- Optimizing associative operations
- Inferring from “is”, part two
- It’s still essential
- Inferring from “is”, part one
- Casts and type parameters do not mix
- Ask me anything!
- A different copy-paste error
- When everything you know is wrong, part two
- When everything you know is wrong, part one
- Wizards and warriors, part five
- Flat-pack sawhorses
- Wizards and warriors, part four
- Wizards and warriors, part three
- Wizards and warriors, part two
- Wizards and warriors, part one
- DRY out your policies
- Long division, part two
- Defying gravity
- Interview with dev.life
- What is the unchecked keyword good for? Part two
- What is the unchecked keyword good for? Part one
- Too many hobbies
- Nostalgia, horror, and a very old bug
- Traffic light UX
- Graph traversal, part four
- Graph traversal, part three
- Graph traversal, part two
- Graph traversal, part one
- Producing combinations, part five
- Eclipse viewing in Seattle
- Producing combinations, part four
- Producing combinations, part three
- Producing combinations, part two
- Producing combinations, part one
- Confusing errors for a confusing feature, part three
- ATBG: Better than nothing
- Confusing errors for a confusing feature, part two
- Confusing errors for a confusing feature, part one
- ATBG: randomness
- Internal or public?
- Melting aluminum
- Comment commentary
- ATBG: Ontogeny, phylogeny and virtual methods
- What is up with transparent identifiers? Part one
- Casting: making a green sand mold
- Short questions
- Analyzing test code
- Copy-paste defects
- Analysis vs code review
- Avoiding C# defects talk Tuesday
- ATBG: Delegates and structural identity
- Real world async/await defects
- London and Budapest
- ATBG: Why do enumerators avoid a bounds check?
- Funniest Hungarian joke ever
- ATBG: Why does my enumerator not advance?
- When should I write a property?
- What are the fundamental rules of pointers?
- ATBG: Why does my code not crash?
- Lowering in language design, part two
- Moving this blog
- Lowering in language design, part one
- Random programming
- Volcanoes and fried foods (rerun)
- ATBG: Warnings vs errors
- Heartbleed and static analysis
- Standard and Daylight are different
- ATBG: Why UTF-16?
- Speaking in Los Angeles Monday
- C# and VB are open sourced
- Reordering optimizations
- Find a simpler problem
- ATBG: Chinese edition
- Can I skip the lock when reading an integer?
- High Performance Windows Store Apps
- Living with unchecked exceptions, part two
- How to debug small programs
- Living with unchecked exceptions
- Even more video
- ATBG: How do exceptions interact with the “using” statement?
- Friday fun with Ogden Nash
- Math is hard; let’s go shopping
- ATBG: How does a lock work?
- Past, present, future
- Questions from Tuesday’s talk
- Live and in person
- More video
- ATBG: inconsistent equality
- Ship it!
- What is “duck typing”?
- Closer is better
- Um, no
- How much bias is introduced by the remainder technique?
- Fighting blind
- ATBG: method type inference with multiple interfaces
- What I did on my long weekend
- The Thien baffle
- The A-star interviews
- The new Seattle office
- ATBG: non-nullable reference types
- Coverity analysis and FXCOP
- A practical use of multiplicative inverses
- Math from scratch, part thirteen: multiplicative inverses
- ATBG: de facto and de jure reachability
- Math from scratch, part twelve: Euclid and Bézout
- Math from scratch, part eleven: integer division
- Math from scratch, part ten: integer comparisons
- ATBG: null coalescing precedence
- Math from scratch, part nine: integer arithmetic
- Math from scratch, part eight: integers
- Math from scratch, part seven: division and remainder
- Happy blogoversary
- ATBG: interfaces and increments
- Math from scratch, part six: comparisons
- Math from scratch, part five: natural subtraction
- Math from scratch, part four: natural multiplication
- ATBG meets math from scratch
- Math from scratch, part three: natural addition
- Math from scratch, part two: zero and one
- Math from scratch, part one
- ATBG: Reflection and default parameters
- Verbatim identifiers
- Higgledy piggledy
- A contravariance conundrum
- What is the type of the null literal?
- Why does a foreach loop silently insert an “explicit” conversion?
- Why not allow double/decimal implicit conversions?
- Ask the Bug Guys
- Why are generic constraints not inherited?
- Benchmarking mistakes, part three
- The psychology of C# analysis
- The answer to the string concatenation puzzle
- Like Eric Lippert, Neil Gaiman enjoys soup
- A string concatenation puzzle
- String concatenation behind the scenes, part two
- A strange rainbow
- String concatenation behind the scenes, part one
- What’s the difference? sizeof and Marshal.SizeOf
- Construction destruction
- An integer division identity
- What the meaning of is is
- Why so fabulous?
- The mystery of the inserted method
- Benchmarking mistakes, part two
- What is lexical scoping?
- Quality assurance fail
- Spot the defect: rounding, part two
- Benchmarking mistakes, part one
- Spot the defect: rounding
- I have a mysterious fifth sense (rerun)
- Producing permutations, part seven
- Producing permutations, part six
- Mmm, curry
- Producing permutations, part five
- Producing permutations, part four
- Producing permutations, part three
- Producing permutations, part two
- Producing permutations, part one
- That’s a big transistor
- Building a tabletop coilgun
- Thumbs up
- What does the langversion switch do?
- Monads, part thirteen
- Monads, part twelve
- Monads, part eleven
- Monads, part ten
- Monads, part nine
- Keeping it sharp
- Monads, part eight
- Monads, part seven
- Monads, part six
- Whidbey Island and bagel mathematics (rerun)
- Monads, part five
- Monads, part four
- Monads, part three
- Monads, part two
- Monads, part one
- Static constructors, part four
- Static constructors, part three
- Free beer!
- Static constructors, part two
- Digital pain (rerun)
- Static constructors, part one
- The view from Columbia Center
- The no-lock deadlock
- Defect spotting, part two
- Defect spotting at the HUB
- Integer division that rounds up
- Five-dollar words for programmers: elision
- Nullable micro-optimizations, part eight
- Hummingbird PSA
- Nullable micro-optimizations, part seven
- Nullable micro-optimizations, part six
- First day
- The postmodern gumballs (rerun)
- Nullable micro-optimization, part five
- It’s still essential!
- Nullable micro-optimization, part four
- Nullable micro-optimization, part three
- Nullable micro-optimization, part two
- Nullable micro-optimizations, part one
- Which is faster?
- My Kauai vacation
- Taking responsibility
- Why are braces required in try-catch-finally?
- Fabulous adventures
- Why is deriving a public class from an internal class illegal?
- Dynamic contagion, part two
- Dynamic contagion, part one
- A method group of one
- Is C# a strongly typed or a weakly typed language?
- High altitude
- Does not compute
- How do we ensure that method type inference terminates?
- Mistakes were made, part three
- Big boxes
- Static analysis of “is”
- Reduction and oxidization
- Mistakes were made, part two
- Mistakes were made, part one
- Royale With Cheese, plus, dividing temperatures
- An “is” operator puzzle, part two
- An “is” operator puzzle, part one
- Mizzou castable refractory instructions
- Wackiness ensues
- Out parameters and LINQ do not mix
- That’s a big anvil
- What If The Crucible Fails?
- Refractory cement
- How hot will the exterior get?
- Avoid Galvanized Metals
- Furnace Design Considerations
- Should C# warn on null dereference?
- Safety Third
- Fabulous Adventures In Casting
- When is a cast not a cast?
- The best advice I ever got
- Foolish consistency is foolish
- Eric rambles on about C#, again
- Implementation-defined behaviour
- Persistence, façades and Roslyn’s red-green trees
- Guid guide, part two
- Guid guide, part one
- Null is not false, part three
- A brief digression
- Null is not false, part two
- Null is not false, part one
- Why not automatically infer constraints?
- Why are local variables definitely assigned in unreachable statements?
- The solution to the simple puzzle
- A simple puzzle
- Generating random non-uniform data in C#
- Bad metaphors
- What is late binding?
- What’s the difference between a trenchcoat and a duster?
- Following the pattern
- Ref returns and ref locals
- Atomicity, volatility and immutability are different, part three
- Atomicity, volatility and immutability are different, part two
- Atomicity, volatility and immutability are different, part one
- Read-only and threadsafe are different
- Optional argument corner cases, part four
- Optional argument corner cases, part three
- Optional argument corner cases, part two
- Optional argument corner cases, part one
- Implementing the virtual method pattern in C#, part three
- Implementing the virtual method pattern in C#, part two
- Implementing the virtual method pattern in C#, part one
- To box or not to box
- Guidelines and rules for GetHashCode
- Never say never, part two
- Never say never, part one
- Looking inside a double
- What would Feynman do?
- Strange but legal
- Curiouser and curiouser
- Bad comparisons, part four
- Bad comparisons, part three
- Bad comparisons, part two
- Bad comparisons, part one
- What’s the difference between covariance and assignment compatibility?
- Closing over the loop variable considered harmful, part two
- Closing over the loop variable considered harmful, part one
- Simple names are not so simple, part two
- Simple names are not so simple, part one
- String interning and String.Empty
- What’s the difference between conditional compilation and the Conditional attribute?
- What’s the difference? fixed versus fixed
- Arrays of arrays
- Four switch oddities
- Precedence vs order redux
- Precedence vs associativity vs order
- Mutating readonly structs
- Covariance and Contravariance, Part 11: To infinity, but not beyond
- How to not get a question answered
- Why Do Initializers Run In The Opposite Order As Constructors? Part Two
- Why Do Initializers Run In The Opposite Order As Constructors? Part One
- Immutability in C# Part Eleven: A working double-ended queue
- Immutability in C# Part Ten: A double-ended queue
- Immutability in C# Part Nine: Academic? Plus my AVL tree implementation
- Immutability in C# Part Eight: Even More On Binary Trees
- Immutability in C# Part Seven: More on Binary Trees
- Immutability in C# Part Six: A Simple Binary Tree
- Immutability in C# Part Five: LOLZ!
- Immutability in C# Part Four: An Immutable Queue
- Immutability in C# Part Three: A Covariant Immutable Stack
- Immutability in C# Part Two: A Simple Immutable Stack
- Covariance and Contravariance in C#, Part 3: Method Group Conversion Variance
- Covariance and Contravariance in C#, Part 2: Array Covariance
- Covariance and contravariance in C#, part 1
- Packet Gnomes
- Multi-cast delegates the evil way
- The JScript Type System Part Eight: The Last Blog Entry About Arrays, I Promise
- A grammatical aside
- Six out of ten ain’t bad
- Speeding can slow you down
- Experience required
- The JScript Type System Part Seven: Yeah, you’ve probably guessed that I wrote the array stuff
- Thin to my chagrin
- The JScript Type System, Part Six: Even more on arrays in JScript .NET
- The JScript Type System, Part Five: More On Arrays In JScript .NET
- The JScript Type System, Part Four: JScript .NET Arrays
- The JScript Type System, Part Three: If It Walks Like A Duck…
- The JScript Type System, Part Two: Prototypes and constructors
- What is the Matrix?
- The JScript Type System, part one
- Eval is evil, part two
- A parable
- Eval is evil, part one
- Functions are not frames
- Global State On Servers Considered Harmful
- How many Microsoft employees does it take to change a lightbulb?
- JScript Goes All To Pieces
- The Most Boring Story Ever
- Compatibility vs. Performance
- Michael’s Security Blog is online
- Attention passengers: Flight 0703 is also known as Flight 451
- Making Sense of HRESULTS
- Constant Folding and Partial Evaluation
- I’m not stringing you along, honest
- The Malware of Ultimate Destruction
- How Bad Is Good Enough?
- Long jumps considered way more harmful than exceptions
- VBScript : VB :: ping-pong : volleyball
- Dead Trees vs. Bits
- I Take Exception To That
- Designing JScript .NET
- Digging A Security Hole All The Way To China
- Wrox is dead, long live Wrox
- It Never Leaks But It Pours
- What Everyone Should Know About Character Encoding
- How Do I Script A Non-Default Dispatch?
- Why is there no #include?
- WSC vs WSH
- Why Can’t I Create The WScript Object?
- Spot the defect!
- I can’t make my script do nothing!
- Eric’s Blog for January 279th, 2003
- “With” considered harmful
- Let’s Get Explicit!
- For-in Revisited
- A Little More on Nothing
- A Whole Lot Of Nothing
- In, Out, In-Out, Make Up Your Mind Already
- What could numeric rounding possibly have to do with MS-DOS?
- Bankers’ Rounding
- More on Certificates and Trust Decisions
- Evil Security Twin Powers… Activate!
- I’m a traveling man, don’t tie me down
- Error messages considered harmful
- They call me “LoadPicture Lippert”
- Hi, I’m Eric and I’ll be your software developer this evening
- JScript eval redux, and some spec diving
- Running Me Ragged
- “For Each” vs. “for in”
- JScript and VBScript Arrays
- Why does VBScript have Execute, ExecuteGlobal and Eval?
- Arrrrr! Cap’n Eric be learnin’ about threadin’ the harrrrd way
- Hard Core Denotational Semantics
- Why is it a bad idea to put script objects in Session scope?
- How does Active Server Pages use the script engines?
- What are threading models, and what threading model do the script engines use?
- How Do The Script Garbage Collectors Work?
- What are closures?
- Are JScript strings passed by reference?
- Why do the script engines not cache dispatch identifiers?
- What Are “Anonymous Functions” In JScript?
- Are JScript strings passed by value or by reference?
- Smart pointers are too smart
- Eric’s Complete Guide to VT_DATE
- Bad Hungarian
- What are the VBScript semantics for object members?
- More on ByVal and ByRef
- Cannot use parentheses when calling a Sub
- Why does JavaScript have rounding errors?
- What’s up with Hungarian Notation?
- Eric’s complete guide to BSTR semantics
*[ATBG]: Ask the Bug Guys *[VSTO]: Visual Studio Tools for Office