The Curious Engineer

All blogs / OCaml / F#

F# for Fun and Profit

fsharpforfunandprofit.com

This site shows you ways that F# can help in day-to-day development of mainstream commercial business software

OCaml / F#Functional / PL theoryTesting / QA

’05’10’15’20’25
Posts
202 from 1 Jan 2001 to 28 Dec 2025
Posting
now and then (2 in the last year)
Kind
personal blog
Feed
https://fsharpforfunandprofit.com/index.xml

2025 2

  1. Weaving design, part 2
  2. Designing weaving software

2021 5

  1. The EDFH is defeated once again
  2. Generating interesting inputs for property-based testing
  3. The 'The Return of the EDFH' series
  4. The Return of the Enterprise Developer From Hell
  5. Terms and Conditions

2020 25

  1. Revisiting the six approaches
  2. Dependency Interpretation
  3. Dependency injection using the Reader monad
  4. Dependency injection using parameters
  5. Six approaches to dependency injection
  6. Low-risk ways to use F# at work
  7. Recursive types and folds
  8. The 'Annotated walkthroughs' series
  9. The 'Computation Expressions' series
  10. The 'dependency cycle' series
  11. The 'designing with types' series
  12. The 'expressions and syntax' series
  13. The 'functional approach to authorization' series
  14. The 'Handling State' series
  15. The 'object-oriented programming in F#' series
  16. The 'Optimization' series
  17. The 'porting from C#' series
  18. The 'Property Based Testing' series
  19. The 'recipe for a functional app' series
  20. The 'thinking functionally' series
  21. The 'Understanding F# types' series
  22. The 'Understanding monoids' series
  23. The 'Why use F#' series
  24. Understanding Map and Apply and Bind
  25. Understanding Parser Combinators

2019 1

  1. Against Railway-Oriented Programming

2018 1

  1. Why F# is the best enterprise language

2017 1

  1. Serializing your domain model

2016 2

  1. Functional approaches to dependency injection
  2. Happy F# Day!

2015 36

  1. Thirteen ways of looking at a turtle - addendum
  2. Thirteen ways of looking at a turtle (part 2)
  3. Thirteen ways of looking at a turtle
  4. Writing a JSON parser from scratch
  5. Improving the parser library
  6. Building a useful set of parser combinators
  7. Understanding Parser Combinators
  8. Trees in the real world
  9. Generic recursive types
  10. Understanding Folds
  11. Introducing Folds
  12. Catamorphism examples
  13. Introduction to recursive types
  14. Choosing between collection functions
  15. Algebraic type sizes and domain modelling
  16. Map and Bind and Apply, a summary
  17. Reinventing the Reader monad
  18. Using map, apply, bind and sequence in practice
  19. Understanding traverse and sequence
  20. Using the core functions in practice
  21. Understanding bind
  22. Understanding map and apply
  23. Swapping type-safety for high performance using compiler directives
  24. Introvert and extrovert programming languages
  25. F# decompiled into C#
  26. Refactoring the Monadster
  27. Completing the body of the Monadster
  28. Dr Frankenfunctor and the Monadster
  29. We don't need no stinking UML diagrams
  30. Happy F# Day!
  31. Enterprise Tic-Tac-Toe, part 2
  32. Enterprise Tic-Tac-Toe
  33. Is your programming language unreasonable?
  34. Using types as access tokens
  35. Constraining capabilities based on identity and role
  36. A functional approach to authorization

2014 17

  1. Choosing properties in practice, part 3
  2. Choosing properties in practice, part 2
  3. Choosing properties in practice, part 1
  4. Choosing properties for property-based testing
  5. Understanding FsCheck
  6. The Enterprise Developer from Hell
  7. Calculator Walkthrough: Part 4
  8. Calculator Walkthrough: Part 3
  9. Calculator Walkthrough: Part 2
  10. Calculator Walkthrough: Part 1
  11. Other interesting ways of using F# at work
  12. Using F# for database related tasks
  13. Using F# for testing
  14. Using F# for development and devops scripts
  15. Twenty six low-risk ways to use F# at work
  16. Analysis of Roslyn vs. the F# compiler
  17. Commentary on 'Roman Numerals Kata with Commentary'

2013 31

  1. Working with non-monoids
  2. Monoids in practice
  3. Monoids without tears
  4. Railway oriented programming: Carbonated edition
  5. Cycles and modularity in the wild
  6. Cyclic dependencies are evil
  7. Refactoring to remove cyclic dependencies
  8. Organizing modules in a project
  9. Why I won't be writing a monad tutorial
  10. Railway oriented programming
  11. How to design and code a complete program
  12. Ten reasons not to use a statically typed functional programming language
  13. Implementing a CE: The rest of the standard methods
  14. Implementing a CE: Adding laziness
  15. Implementing a CE: Overloading
  16. Implementing a CE: Delay and Run
  17. Implementing a CE: Combine
  18. Implementing a CE: Zero and Yield
  19. More on wrapper types
  20. Computation expressions and wrapper types
  21. Introducing 'bind'
  22. Understanding continuations
  23. Computation expressions: Introduction
  24. Designing with types: Conclusion
  25. Designing with types: Non-string types
  26. Designing with types: Constrained strings
  27. Designing with types: Making state explicit
  28. Designing with types: Discovering new concepts
  29. Designing with types: Making illegal states unrepresentable
  30. Designing with types: Single case union types
  31. Designing with types: Introduction

2012 72

  1. Getting started with direct porting
  2. Porting from C# to F#: Introduction
  3. Object expressions
  4. Interfaces
  5. Inheritance and abstract classes
  6. Classes
  7. Object-oriented programming in F#: Introduction
  8. Formatted text using printf
  9. Built-in .NET types
  10. Units of measure
  11. Enum types
  12. Understanding type inference
  13. Worked example: A stack based calculator
  14. Worked example: Roman numerals
  15. Worked example: Parsing command line arguments
  16. Match expressions
  17. The Option type
  18. Discriminated Unions
  19. Records
  20. Tuples
  21. Type abbreviations
  22. Overview of types in F#
  23. Understanding F# types: Introduction
  24. Exceptions
  25. Control flow expressions
  26. Parameter and value naming conventions
  27. F# syntax: indentation and verbosity
  28. Binding with let, use, and do
  29. Overview of F# expressions
  30. Expressions vs. statements
  31. Expressions and syntax: Introduction
  32. Attaching functions to types
  33. Organizing functions
  34. Function signatures
  35. Defining functions
  36. Function associativity and composition
  37. Partial application
  38. Currying
  39. How types work with functions
  40. Function Values and Simple Values
  41. Mathematical functions
  42. Thinking Functionally: Introduction
  43. Why use F#: Conclusion
  44. Anything C# can do...
  45. Seamless interoperation with .NET libraries
  46. Completeness
  47. Functional Reactive Programming
  48. Messages and Agents
  49. Asynchronous programming
  50. Concurrency
  51. Worked example: Designing for correctness
  52. Using the type system to ensure correct code
  53. Exhaustive pattern matching
  54. Immutability
  55. Correctness
  56. Active patterns
  57. Partial Application
  58. Functions as interfaces
  59. Out-of-the-box behavior for types
  60. Convenience
  61. Pattern matching for conciseness
  62. Using functions as building blocks
  63. Using functions to extract boilerplate code
  64. Low overhead type definitions
  65. Type inference
  66. Conciseness
  67. Four Key Concepts
  68. Comparing F# with C#: Downloading a web page
  69. Comparing F# with C#: Sorting
  70. Comparing F# with C#: A simple sum
  71. F# syntax in 60 seconds
  72. Introduction to the 'Why use F#' series

2001 2

  1. License
  2. Shopping cart example in C#

Undated 7

  1. installing and using F#
  2. “why use F#?"
  3. “why use F#"
  4. “explore the site”
  5. learning F#
  6. troubleshooting F#
  7. videos page