The Curious Engineer

All blogs / Software / engineering practice

ploeh blog

blog.ploeh.dk

Danish software design

Software / engineering practiceOCaml / F#C# / .NETTesting / QA

’10’15’20’25
Posts
838 from 28 Jan 2009 to 26 Oct 2026
Posting
weekly (35 in the last year)
Kind
personal blog
Feed
https://blog.ploeh.dk/atom.xml

2026 26

  1. QuickCheck property: Uncategorised bill
  2. Properties for a budgeting exercise
  3. Releasing AI-generated software
  4. Redesign without fear
  5. On learning programming in an age of LLMs
  6. Worse is better: C# versus F#
  7. Why use ORMs if LLMs write code?
  8. Does code quality still matter?
  9. Worse is better: JSON versus XML
  10. Worse is better
  11. Motivated reasoning
  12. In defence of bureaucracy
  13. Secret agentic AI
  14. The hailo effect
  15. Programming languages for AI
  16. Will you go to prison for an AI?
  17. Which of these languages are best for AI?
  18. In defence of correctness
  19. TDD as induction
  20. Critiquing tests
  21. Simplifying assertions with lenses
  22. Code that fits in a context window
  23. AI-generated tests as ceremony
  24. Filtering as domain logic
  25. Two regimes of Git
  26. Coupling from a big-O perspective

2025 52

  1. Git integration is ten years away
  2. Test-specific Eq
  3. Tautological assertions are not always caused by aliasing
  4. Pattern guards for a protocol
  5. Treat test code like production code
  6. Result is the most boring sum type
  7. Empirical software prototyping
  8. 100% coverage is not that trivial
  9. Empirical Characterization Testing
  10. Empirical test-after development
  11. Epistemology of software
  12. Result isomorphism
  13. Shift left on x
  14. Composing pure Haskell assertions
  15. It's striking so quickly the industry forgets that lines of code isn't a measure of productivity
  16. Greyscale-box test-driven development
  17. IO is special
  18. Song recommendations with C# free monads
  19. Song recommendations with F# free monads
  20. Song recommendations with Haskell free monads
  21. Song recommendations with free monads
  22. Testing races with a synchronizing Decorator
  23. Song recommendations with F# agents
  24. Song recommendations with C# Reactive Extensions
  25. Song recommendations with pipes and filters
  26. A parser and interpreter for a very small language
  27. Song recommendations from Haskell combinators
  28. Song recommendations from F# combinators
  29. Song recommendations from C# combinators
  30. Song recommendations from combinators
  31. Testing races with a slow Decorator
  32. Song recommendations as a Haskell Impureim Sandwich
  33. Song recommendations as an F# Impureim Sandwich
  34. Song recommendations proof-of-concept memory measurements
  35. Song recommendations as a C# Impureim Sandwich
  36. Song recommendations as an Impureim Sandwich
  37. Porting song recommendations to Haskell
  38. Porting song recommendations to F#
  39. Characterising song recommendations
  40. Alternative ways to design with functional programming
  41. Ports and fat adapters
  42. Phased breaking changes
  43. Appeal to aithority
  44. Reactive monad
  45. Easier encapsulation with static types
  46. In defence of multiple WiP
  47. Geographic hulls
  48. Modelling data relationships with C# types
  49. Dependency inversion without inversion of control
  50. Modelling data relationships with F# types
  51. Recawr Sandwich
  52. Encapsulating rod-cutting

2024 53

  1. Pytest is fast
  2. Implementing rod-cutting
  3. A restaurant sandwich
  4. Implementation and usage mindsets
  5. Short-circuiting an asynchronous traversal
  6. Nested monads
  7. Collecting and handling result values
  8. Traversals
  9. Pendulum swing: no Haskell type annotation by default
  10. Functor compositions
  11. Legacy Security Manager in Haskell
  12. Functor sums
  13. The Const functor
  14. Das verflixte Hunde-Spiel
  15. FSZipper in C#
  16. Functor products
  17. A Binary Tree Zipper in C#
  18. Keeping cross-cutting concerns out of application code
  19. A List Zipper in C#
  20. Zippers
  21. Using only a Domain Model to persist restaurant table configurations
  22. Using a Shared Data Model to persist restaurant table configurations
  23. Using Ports and Adapters to persist restaurant table configurations
  24. Three data architectures for the server
  25. The end of trust?
  26. Should interfaces be asynchronous?
  27. An immutable priority collection
  28. A mutable priority collection
  29. A failed attempt at priority collection with inheritance
  30. Simpler encapsulation with immutability
  31. You'll regret using natural keys
  32. Continuous delivery without a CI server
  33. Fundamentals
  34. Gratification
  35. Conservative codomain conjecture
  36. Service compatibility is determined based on policy
  37. Fitting a polynomial to a set of points
  38. Services share schema and contract, not class
  39. Extracting curve coordinates from a bitmap
  40. Trying to fit the hype cycle
  41. Services are autonomous
  42. Extracting data from a small CSV file with Python
  43. Boundaries are explicit
  44. The four tenets of SOA revisited
  45. Testing exceptions
  46. Extracting data from a small CSV file with Haskell
  47. Range as a functor
  48. Statically and dynamically typed scripts
  49. Error categories and category errors
  50. A Range kata implementation in C#
  51. A Range kata implementation in F#
  52. A Range kata implementation in Haskell
  53. Variations of the Range kata

2023 52

  1. Serializing restaurant tables in C#
  2. Serializing restaurant tables in F#
  3. Serializing restaurant tables in Haskell
  4. Serialization with and without Reflection
  5. Synchronizing concurrent teams
  6. Trimming a Fake Object
  7. CC golf
  8. Fakes are Test Doubles with contracts
  9. A C# port of validation with partial round trip
  10. Domain Model first
  11. At the boundaries, static types are illusory
  12. What's a sandwich?
  13. Dependency Whac-A-Mole
  14. The case of the mysterious comparison
  15. Do ORMs reduce the need for mapping?
  16. A first stab at the Brainfuck kata
  17. Decomposing CTFiYH's sample code base
  18. A first crack at the Args kata
  19. Compile-time type-checked truth tables
  20. Replacing Mock and Stub with a Fake
  21. NonEmpty catamorphism
  22. Test-driving the pyramid's top
  23. Is software getting worse?
  24. Works on most machines
  25. AI for doc comments
  26. Validating or verifying emails
  27. Validation and business rules
  28. When is an implementation detail an implementation detail?
  29. Collatz sequences by function composition
  30. The Git repository that vanished
  31. Favour flat code file folders
  32. Visual Studio Code snippet to make URLs relative
  33. Folders versus namespaces
  34. Is cyclomatic complexity really related to branch coverage?
  35. Refactoring pure function composition without breaking existing tests
  36. Are pull requests bad because they originate from open-source development?
  37. A restaurant example of refactoring from example-based to property-based testing
  38. Anagrams kata as a one-liner
  39. An abstract example of refactoring from interaction-based to property-based testing
  40. More functional pits of success
  41. On trust in software development
  42. Confidence from Facade Tests
  43. Warnings-as-errors friction
  44. Test Data Generator monad
  45. A thought on workplace flexibility and asynchrony
  46. Epistemology of interaction testing
  47. Contravariant functors as invariant functors
  48. Built-in alternatives to applicative assertions
  49. Agilean
  50. In the long run
  51. The IO monad
  52. Adding NuGet packages when offline

2022 52

  1. Functors as invariant functors
  2. Error-accumulating composable assertions in C#
  3. When do tests fail?
  4. GitHub Copilot preliminary experience report
  5. An initial proof of concept of applicative assertions in C#
  6. Decouple to delete
  7. The Reader monad
  8. Applicative assertions
  9. A regular grid emerges
  10. Encapsulation in Functional Programming
  11. Stubs and mocks break encapsulation
  12. Refactoring a saga from the State pattern to the State monad
  13. Some thoughts on the economics of programming
  14. Refactoring the TCP State pattern example to pure functions
  15. When to refactor
  16. Coalescing DTOs
  17. The State pattern and the State monad
  18. Natural transformations as invariant functors
  19. Can types replace validation?
  20. ASP.NET validation revisited
  21. Endomorphism as an invariant functor
  22. Invariant functors
  23. An applicative reservation validation example in C#
  24. Natural transformations
  25. Functor relationships
  26. Get and Put State
  27. Test Double clocks
  28. The State monad
  29. Some thoughts on naming tests
  30. Asynchronous monads
  31. The Lazy monad
  32. Waiting to never happen
  33. The Identity monad
  34. An Either monad
  35. At the boundaries, applications aren't functional
  36. The Maybe monad
  37. The List monad
  38. Monad laws
  39. Kleisli composition
  40. Monads
  41. Contravariant Dependency Injection
  42. Type-safe DI Containers are redundant
  43. A type-safe DI Container as a tuple
  44. Can one flatten a statically typed list?
  45. A type-safe DI Container as a functor
  46. A conditional sandwich example
  47. Nested type-safe DI Containers
  48. A type-safe DI Container C# example
  49. Type-level DI Container prototype
  50. Enumerate Wordle combinations with an applicative functor
  51. Type-safe DI composition
  52. To ID or not to ID

2021 52

  1. Label persistent test data with deletion dates
  2. Changing your organisation
  3. Backwards compatibility as a profunctor
  4. The Liskov Substitution Principle as a profunctor
  5. Postel's law as a profunctor
  6. Functions as pipes
  7. Types as sets
  8. Reader as a profunctor
  9. Profunctors
  10. Functor variance compared to C#'s notion of variance
  11. Readability verification
  12. Serendipity-driven development
  13. Reader as a contravariant functor
  14. The Equivalence contravariant functor
  15. Keep IDs internal with REST
  16. Unit testing private helper methods
  17. The Specification contravariant functor
  18. The Command Handler contravariant functor
  19. Contravariant functors
  20. The Reader functor
  21. Am I stuck in a local maximum?
  22. The Tennis kata revisited
  23. Referential transparency fits in your head
  24. The State functor
  25. A reading of Extensibility for the Masses
  26. Fractal hex flowers
  27. Property-based testing is not the same as partition testing
  28. Agile pull requests
  29. New book: Code That Fits in Your Head
  30. Abstruse nomenclature
  31. From State tennis to endomorphism
  32. Tennis kata using the State pattern
  33. Against consistency
  34. Simplifying code with Decorated Commands
  35. Structural equality for better tests
  36. Leaky abstraction by omission
  37. Consider including identity in URLs
  38. Threading context through a catamorphism
  39. Mazes on Voronoi tessellations
  40. Table-driven tennis scoring
  41. The dispassionate developer
  42. Pendulum swing: pure by default
  43. Pendulum swing: sealed by default
  44. Pendulum swing: internal by default
  45. Pendulum swings
  46. When properties are easier than examples
  47. Accountability and free speech
  48. ASP.NET POCO Controllers: an experience report
  49. Self-hosted integration tests in ASP.NET
  50. Parametrised test primitive obsession code smell
  51. Waiting to happen
  52. Dynamic test oracles for rho problems

2020 52

  1. An F# demo of validation with partial data round trip
  2. A Haskell proof of concept of validation with partial data round trip
  3. Validation, a solved problem?
  4. Branching tests
  5. Name by role
  6. Good names are skin-deep
  7. Redirect legacy URLs
  8. Checking signed URLs with ASP.NET
  9. Signing URLs with ASP.NET
  10. Fit URLs
  11. Monomorphic functors
  12. Subjectivity
  13. Fortunately, I don't squash my commits
  14. EnsureSuccessStatusCode as an assertion
  15. An XPath query for long methods
  16. We need young programmers; we need old programmers
  17. Add null check without brackets in Visual Studio
  18. Properties for all
  19. Adding REST links as a cross-cutting concern
  20. Unit testing is fine
  21. An ASP.NET Core URL Builder
  22. Using the nameof C# keyword with ASP.NET 3 IUrlHelper
  23. Task asynchronous programming as an IO surrogate
  24. Closing database connections during test teardown
  25. Implementation of the C# IO container
  26. Referential transparency of IO
  27. Syntactic sugar for IO
  28. The IO functor
  29. IO container in a parallel C# universe
  30. The IO Container
  31. Retiring old service versions
  32. Where's the science?
  33. Modelling versus shaping reality
  34. Afk
  35. Significant whitespace is DRY
  36. An F# implementation of the Maître d' kata
  37. Unit bias against collections
  38. Curb code rot with thresholds
  39. Repeatable execution in C#
  40. Repeatable execution in Haskell
  41. Repeatable execution
  42. Conway's Law: latency versus throughput
  43. Polymorphic Builder
  44. Impureim sandwich
  45. Discerning and maintaining purity
  46. Builder as a monoid
  47. Builder isomorphisms
  48. Non-exceptional averages
  49. The Maître d' kata
  50. Algebraic data types aren't numbers on steroids
  51. On doing katas
  52. The case of the unbalanced brackets

2019 52

  1. Semigroup resonance FizzBuzz
  2. The case of the mysterious curly bracket
  3. Zone of Ceremony
  4. Put cyclomatic complexity to good use
  5. Refactoring registration flow to functional architecture
  6. TimeSpan configuration values in .NET Core
  7. Small methods are easy to troubleshoot
  8. Diamond rock
  9. The 80/24 rule
  10. A basic Haskell solution to the robot journeys coding exercise
  11. A red-green-refactor checklist
  12. Tautological assertion
  13. Devil's advocate
  14. 10x developers
  15. Unit testing wai applications
  16. Picture archivist in F#
  17. Picture archivist in Haskell
  18. Naming newtypes for QuickCheck Arbitraries
  19. Functional file system
  20. A rose tree functor
  21. Rose tree bifunctor
  22. Rose tree catamorphism
  23. Church-encoded rose tree
  24. Chain of Responsibility as catamorphisms
  25. Tester-Doer isomorphisms
  26. Payment types catamorphism
  27. Yes silver bullet
  28. Full binary tree catamorphism
  29. Composition Root location
  30. Tree catamorphism
  31. Either catamorphism
  32. List catamorphism
  33. Maybe catamorphism
  34. Peano catamorphism
  35. Boolean catamorphism
  36. Catamorphisms
  37. Applicative monoids
  38. Lazy monoids
  39. A pure Test Spy
  40. An example of state-based testing in C#
  41. An example of state based-testing in F#
  42. The programmer as decision maker
  43. An example of state-based testing in Haskell
  44. Code quality isn't software quality
  45. An example of interaction-based testing in C#
  46. From interaction-based to state-based testing
  47. Asynchronous Injection
  48. How to get the value out of the monad
  49. Better abstractions revisited
  50. Some thoughts on anti-patterns
  51. An Either functor
  52. Either bifunctor

2018 56

  1. Tuple bifunctor
  2. Bifunctors
  3. The Lazy applicative functor
  4. Danish CPR numbers in F#
  5. Set is not a functor
  6. The Test Data Generator applicative functor
  7. Functional architecture: a definition
  8. What to test and not to test
  9. Applicative validation
  10. The Maybe applicative functor
  11. Applicative combinations of functions
  12. An applicative password list
  13. Full deck
  14. Applicative functors
  15. Asynchronous functors
  16. Typing is not a programming bottleneck
  17. The Lazy functor
  18. The Identity functor
  19. On Constructor Over-injection
  20. Reactive functor
  21. A Visitor functor
  22. A Tree functor
  23. Flattening arrow code using a stack of monads
  24. Dependency Injection revisited
  25. Angular addition monoid
  26. Typing and testing problem 23
  27. Terse operators make business code more readable
  28. Visitor as a sum type
  29. Church-encoded payment types
  30. Church-encoded Either
  31. Church-encoded Maybe
  32. Church-encoded natural numbers
  33. Church-encoded Boolean values
  34. Church encoding
  35. Composite as a monoid - a business rules example
  36. Project Arbitraries with view patterns
  37. Inlined HUnit test lists
  38. Parametrised unit tests in Haskell
  39. Null Object as identity
  40. Endomorphic Composite as a monoid
  41. Coalescing Composite as a monoid
  42. Maybe monoids
  43. The Maybe functor
  44. Functors
  45. Functors, applicatives, and friends
  46. Composite as a monoid
  47. Some design patterns as universal abstractions
  48. Inheritance-composition isomorphism
  49. Abstract class isomorphism
  50. Object isomorphisms
  51. Uncurry isomorphisms
  52. Argument list isomorphisms
  53. Function isomorphisms
  54. Unit isomorphisms
  55. Software design isomorphisms
  56. Colour-mixing magma

2017 42

  1. Rock Paper Scissors magma
  2. Magmas
  3. Quasigroups
  4. Semigroups accumulate
  5. Bounding box semigroup
  6. Semigroups
  7. Monoids accumulate
  8. Endomorphism monoid
  9. Function monoids
  10. Tuple monoids
  11. Convex hull monoid
  12. Money monoid
  13. Strings, lists, and sequences as a monoid
  14. Monoids
  15. Monoids, semigroups, and friends
  16. From design patterns to category theory
  17. Interception vis-à-vis Pure DI
  18. The Test Data Generator functor
  19. Test data without Builders
  20. Builder as Identity
  21. The Builder functor
  22. Generalised Test Data Builder
  23. Test Data Builders in C#
  24. From Test Data Builders to the identity functor
  25. F# free monad recipe
  26. Combining free monads in F#
  27. Combining free monads in Haskell
  28. A pure command-line wizard
  29. Hello, pure command-line interaction
  30. Pure interactions
  31. Pure times in F#
  32. Pure times in Haskell
  33. Pure times
  34. Fractal trees with PureScript
  35. Using Polly with F# async workflows
  36. Simple holidays
  37. A reusable ApiController Adapter
  38. Dependency rejection
  39. Partial application is dependency injection
  40. Dependency injection is passing an argument
  41. From dependency injection to dependency rejection
  42. Decoupling application errors from domain models

2016 26

  1. From REST to algebraic data
  2. Domain modelling with REST
  3. Easy domain modelling with types
  4. When variable names are in the way
  5. Decoupling decisions from effects
  6. Untyped F# HTTP route defaults for ASP.NET Web API
  7. Conditional composition of functions
  8. Roman numerals via property-based TDD
  9. SUT Double
  10. TIE fighter FsCheck properties
  11. CQS and server-generated Entity IDs
  12. Async as surrogate IO
  13. Composition with an Either computation expression
  14. Functional architecture is Ports and Adapters
  15. Ad-hoc Arbitraries - now with pipes
  16. Types + Properties = Software: other properties
  17. Types + Properties = Software: finite state machine
  18. Types + Properties = Software: initial state
  19. Types + Properties = Software: composition
  20. Types + Properties = Software: properties for the Forties
  21. Types + Properties = Software: properties for the advantage state
  22. Types + Properties = Software: state transition properties
  23. Types + Properties = Software: designing with types
  24. Types + Properties = Software
  25. Are shuffled plays random?
  26. Make pre-conditions explicit in Property-Based Tests

2015 38

  1. Tail Recurse
  2. Integration Testing composed functions
  3. The Rules of Attraction: Location
  4. The Rules of Attraction: Language
  5. Recurse
  6. To log or not to log
  7. Code coverage is a useless target measure
  8. Null has no type, but Maybe has
  9. Service Locator violates encapsulation
  10. Visual Value Verification
  11. Command Query Separation when Queries should have side-effects
  12. Applications and their side effects
  13. Unit testing internals
  14. Public types hidden in plain sight
  15. Temporary Field code smell
  16. Ad hoc Arbitraries with FsCheck.Xunit
  17. When x, y, and z are great variable names
  18. Type Driven Development: composition
  19. Type Driven Development: implementing shouldIdle
  20. Type Driven Development
  21. Idiomatic or idiosyncratic?
  22. Type Driven Development with F# Pluralsight course
  23. REST implies Content Negotiation
  24. stringf
  25. Functional design is intrinsically testable
  26. Test-Driven Development with F# Pluralsight course
  27. Introduction to Property based Testing with F# Pluralsight course
  28. C# will eventually get all F# features, right?
  29. Less is more: language features
  30. Unit Testing with F# Pluralsight course
  31. POSTing JSON to an F# Web API
  32. Property Based Testing without a Property Based Testing framework
  33. A simpler Arbitrary for the Diamond kata
  34. Library Bundle Facade
  35. From Primitive Obsession to Domain Modelling
  36. 10 tips for better Pull Requests
  37. Diamond kata with FsCheck
  38. Composition Root Reuse

2014 38

  1. Placement of Abstract Factories
  2. Exception messages are for programmers
  3. Good times with F#
  4. Name this operation
  5. The IsNullOrWhiteSpace trap
  6. Unit Testing methods with the same implementation
  7. AtomEventStore
  8. Faking a continuously Polling Consumer with scheduled tasks
  9. Decommissioning Decoraptors
  10. Decoraptor
  11. CQS versus server generated IDs
  12. Why DRY?
  13. Encapsulation and SOLID Pluralsight course
  14. Drain
  15. Hire me
  16. Passive Attributes
  17. Web API Raygun error handler
  18. Pure DI
  19. Compile-Time Lifetime Matching
  20. Captive Dependency
  21. Feedback on ASP.NET vNext Dependency Injection
  22. DI-Friendly Framework
  23. DI-Friendly Library
  24. Conforming Container
  25. Configuring Azure Web Jobs
  26. Service Locator violates SOLID
  27. AutoFixture conventions with Albedo
  28. Single Writer Web Jobs on Azure
  29. Composed assertions with Unquote
  30. Exude
  31. Arbitrary Version instances with FsCheck
  32. SOLID: the next step is Functional
  33. Using NuGet with autonomous repositories
  34. How to use FSharp.Core 4.3.0 when all you have is 4.3.1
  35. NuGet Package Restore considered harmful
  36. A Functional architecture with F#
  37. REST efficiency
  38. Hyprlinkr 1.0.0

2013 64

  1. ZeroToNine
  2. Semantic Versioning with Continuous Deployment
  3. Layers, Onions, Ports, Adapters: it's all the same
  4. Not going to NDC London after all
  5. Albedo
  6. Mocks for Commands, Stubs for Queries
  7. Replace overloading with Discriminated Unions
  8. Easy ASP.NET Web API DTOs with F# CLIMutable records
  9. Verifying every single commit in a Git branch
  10. DI in .NET receives a Jolt Productivity Award
  11. Karma from bash on Windows
  12. DI and events: Composition
  13. DI and events: Reactive Extensions
  14. DI and events: Third-party Connect
  15. DI and events: Constructor Subscription
  16. Dependency Injection and events
  17. Running a pure F# Web API on Azure Web Sites
  18. How to create a pure F# ASP.NET Web API project
  19. Checking math homework with F#
  20. LINQ versus the LSP
  21. Defensive coding
  22. NDC 2013 session recordings
  23. A heuristic for formatting code according to the AAA pattern
  24. Where to put unit tests
  25. REST lesson learned: Consider a self link on all resources
  26. REST lesson learned: Consider a home link on all resources
  27. REST lesson learned: Avoid hackable URLs
  28. Herding Code podcast
  29. REST lesson learned: Avoid 204 responses
  30. REST lesson learned: Avoid user-supplied data in URI segments
  31. REST lessons learned
  32. How to change the Generate Property Stub refactoring code snippet in Visual Studio 2012
  33. Advanced Unit Testing Pluralsight course
  34. FizzBuzz kata in Clojure
  35. Ploeh blog syndication feed addresses
  36. How to automatically populate properties with AutoMoq
  37. How to configure AutoMoq to set up all properties
  38. Structural Inspection
  39. Why trust tests?
  40. Listen to trivial tests
  41. Auto-mocking Container
  42. Test trivial code
  43. Code readability hypotheses
  44. Outside-In TDD versus DDD
  45. Moving the blog to Jekyll
  46. AutoFixture 3
  47. String Calculator kata with Autofixture exercise 8
  48. String Calculator kata with Autofixture exercise 7
  49. String Calculator kata with Autofixture exercise 6
  50. String Calculator kata with Autofixture exercise 5
  51. String Calculator kata with Autofixture exercise 4
  52. String Calculator kata with Autofixture exercise 3
  53. String Calculator kata with Autofixture exercise 2
  54. String Calculator kata with AutoFixture exercise 1
  55. String Calculator kata with AutoFixture
  56. Beware of Productivity Tools
  57. Outside-In Test-Driven Development Pluralsight course
  58. Partial Type Name Role Hint
  59. Role Interface Role Hint
  60. Metadata Role Hint
  61. NSubstitute Auto-mocking with AutoFixture
  62. Argument Name Role Hint
  63. Type Name Role Hints
  64. Role Hints

2012 33

  1. Zookeepers must become Rangers
  2. Rangers and Zookeepers
  3. Encapsulation of properties
  4. AppSettings convention for Castle Windsor
  5. When to use a DI Container
  6. Dependency Injection in ASP.NET Web API with Castle Windsor
  7. Dependency Injection and Lifetime Management with ASP.NET Web API
  8. Concrete Dependencies
  9. The order of AutoFixture Customizations matter
  10. FizzBuzz kata in F#: stage 2
  11. FizzBuzz kata in F#: stage 1
  12. Hyprlinkr
  13. Primitive Dependencies
  14. Facade Test
  15. Test-specific Equality versus Domain Equality
  16. Resemblance and Likeness
  17. The Resemblance idiom
  18. Bank OCR kata in F#: user stories 3 and 4
  19. Bank OCR kata in F#: user story 2
  20. Bank OCR kata in F#: user story 1
  21. Design patterns across paradigms
  22. TDD test suites should run in 10 seconds or less
  23. Vendor Media Types With the ASP.NET Web API
  24. Wiring HttpControllerContext With Castle Windsor
  25. Injecting HttpControllerContext With the ASP.NET Web API
  26. Hyperlinking With the ASP.NET Web API
  27. IQueryable is Tight Coupling
  28. Robust DI With the ASP.NET Web API
  29. Migrating from WCF Web API to ASP.NET Web API
  30. Implementing an Abstract Factory
  31. Is Layering Worth the Mapping?
  32. Loose Coupling and the Big Picture
  33. SOLID is Append-only

2011 42

  1. Testing Container Configurations
  2. Factory Overload
  3. Polymorphic Consistency
  4. TDD improves reusability
  5. Independency
  6. SOLID concrete
  7. Checking for exactly one item in a sequence using C# and F#
  8. Weakly-typed versus Strongly-typed Message Channels
  9. Message Dispatching without Service Location
  10. AutoFixture goes Continuous Delivery with Semantic Versioning
  11. Service Locator: roles vs. mechanics
  12. Joining AppHarbor
  13. Composition Root
  14. SOLID Code isn't
  15. At the Boundaries, Applications are Not Object-Oriented
  16. Design Smell: Default Constructor
  17. Design Smell: Redundant Required Attribute
  18. Code Smell: Automatic Property
  19. Design Smell: Primitive Obsession
  20. Design Smell: Temporal Coupling
  21. Poka-yoke Design: From Smell to Fragrance
  22. Tennis Kata with immutable types and a cyclomatic complexity of 1
  23. Generic unit testing with xUnit.net
  24. AutoFixture 2.1
  25. Windows Azure migration smell: SQL Server over-utilization
  26. Feedback mechanisms and tradeoffs
  27. Provider is not a pattern
  28. AutoFixture 2.1 beta 1
  29. Constructor strategies for AutoFixture
  30. Enumerables are dynamic - also in AutoFixture
  31. MSDN Magazine article about CQRS on Windows Azure
  32. Commands are Composable
  33. Encapsulating AutoFixture Customizations
  34. Resolving closed types with MEF
  35. Compose object graphs with confidence
  36. Injection Constructors should be simple
  37. Interfaces are access modifiers
  38. Creating general populated lists with AutoFixture
  39. Creating specific populated lists with AutoFixture
  40. The BCL already has a Maybe monad
  41. Scalable doesn't mean fast
  42. My Christmas challenge has a winner

2010 49

  1. Challenge: Resolve closed types with MEF
  2. The TDD Apostate
  3. On Role Interfaces, the Reused Abstractions Principle and Service Locators
  4. Towards better abstractions
  5. Interfaces are not abstractions
  6. Integrating AutoFixture with ObjectHydrator
  7. Rhino Mocks-based auto-mocking with AutoFixture
  8. Refactoring from Abstract Factory to Decorator
  9. Refactoring from Service Locator to Abstract Factory
  10. Pattern Recognition: Abstract Factory or Service Locator?
  11. Convention-based Customizations with AutoFixture
  12. Windows Azure Migration Sanity Check
  13. AutoFixture 2.0 Released
  14. AutoData Theories with AutoFixture
  15. The Register Resolve Release pattern
  16. Instrumentation with Decorators and Interceptors
  17. My future is Azure
  18. Don't call the container; it'll call you
  19. Changing the behavior of AutoFixture auto-mocking with Moq
  20. AutoFixture as an auto-mocking container
  21. AutoFixture 2.0 beta 1
  22. StructureMap PerRequest vs. Unique lifetimes
  23. Domain Objects and IDataErrorInfo
  24. Introducing AutoFixture Likeness
  25. Upcoming talks spring 2010
  26. Sneak view at Castle's WCF Facility
  27. ServiceHostFactory lifetime
  28. Fun with literal extensions and Ambient Context
  29. Changing Windsor lifestyles after the fact
  30. Why I'm migrating from MSTest to xUnit.net
  31. AutoFixture 1.1
  32. Dependency Injection is Loose Coupling
  33. Mapping types with AutoFixture
  34. AutoFixture 1.1 RC1
  35. Freezing mocks
  36. More about frozen pizza
  37. AutoFixture Freeze
  38. CNUG TDD talk
  39. Service Locator is an Anti-Pattern
  40. Refactoring to Aggregate Services
  41. AutoFixture 1.0
  42. What's so dangerous about a DI attribute?
  43. IWindsorInstaller
  44. Dependency Injection Inversion in .NET
  45. AutoFixture 1.0 RC2
  46. Enabling DI for Lazy Components
  47. Rebuttal: Constructor over-injection anti-pattern
  48. AutoFixture 1.0 RC1
  49. Anonymous Get

2009 59

  1. MEF TechTalk with me
  2. Wiring ASP.NET MVC Error Handling with Castle Windsor
  3. LoggingExceptionFilter
  4. Building and assigning arrays with AutoFixture
  5. Global Error Handling in ASP.NET MVC
  6. Anonymous Do
  7. Dependency Injection Podcast with me
  8. Using Castle Windsor's PerWebRequest lifestyle with ASP.NET MVC on IIS7
  9. Creating length-constrained strings with AutoFixture
  10. AutoFixture beta 1
  11. Anonymous With
  12. WCF Podcast with me
  13. Writing a book
  14. SOLID or COLDS?
  15. Customizing A Type's Builder With AutoFixture
  16. AutoFixture .8.6 Released
  17. Self-updating AJAX links with ASP.NET MVC
  18. AutoFixture .8.5 Released
  19. Do Redux
  20. Omitting Only Certain Properties With AutoFixture
  21. A Fluent Interface For Testing INotifyPropertyChanged
  22. Disabling AutoProperties In AutoFixture
  23. DataTemplating In ASP.NET MVC
  24. AutoFixture .8.4 And Roadmap
  25. AutoFixture As Test Data Builder
  26. Custom Tokens Over Non-HTTP Transports
  27. AutoFixture .8.3 Released
  28. AutoFixture .8.2 Released
  29. Calling Methods While Building Anonymous Variables With AutoFixture
  30. Tweet
  31. Testability Is Really The Open/Closed Principle
  32. AutoFixture Cheat Sheet
  33. Setting Property Values While Building Anonymous Variables With AutoFixture
  34. Delegates Are Anonymous Interfaces
  35. The AutoFixture Builder
  36. SyncOrchestrator.Synchronize() Throws COMException When Unit Testing
  37. AutoFixture .8.1 Released
  38. AutoFixture As Fixture Object
  39. Anonymous Sequences With AutoFixture
  40. Managing Loosely Coupled Projects
  41. Dealing With Constrained Input
  42. Speaking at 7N IT Conference 2009
  43. Replacing AutoFixture's Default Algorithms
  44. Dealing With Types Without Public Constructors
  45. Creating Booleans With AutoFixture
  46. Creating Numbers With AutoFixture
  47. Creating Strings With AutoFixture
  48. How AutoFixture Creates Objects
  49. Joining Safewhere
  50. Announcing: AutoFixture
  51. Fixture Object
  52. Explicit Expectations
  53. Specification-Driven Development
  54. Constrained Non-Determinism
  55. Derived Values Ensure Executable Specification
  56. Updating Detached Entities With LINQ To Entities
  57. SUT Factory
  58. Zero-Friction TDD
  59. Living In Interesting Times