Archives

And how to classify them

More malicious compliance, more property-based testing

Six approaches to dependency injection, Part 5

Six approaches to dependency injection, Part 4

Six approaches to dependency injection, Part 3

Six approaches to dependency injection, Part 2

(when used thoughtlessly)

Or, how to share algebraic data types with the outside world

Part one of a series, starting with partial application.

Growing and getting better each year

Bonus ways: An Abstract Data Turtle and a Capability-based Turtle.

Continuing with examples of event sourcing, FRP, monadic control flow, and an interpreter.

Examples of an API, dependency injection, a state monad, and more!

In 250 lines of code

Adding more informative errors

15 or so combinators that can be combined to parse almost anything

Building a parser combinator library from scratch

Examples using databases, JSON and error handling

Implementing a domain in three ways

Recursion vs. iteration

Threading state through a recursive data structure

Applying the rules to other domains

Don't fear the catamorphism...

A guide for the perplexed

Comprehending cardinality for fun and profit

Or, designing your own elevated world

A real-world example that uses all the techniques

Mixing lists and elevated values

Working with independent and dependent data

Or, how to compose world-crossing functions

A toolset for working with elevated worlds

An experiment in how to have your cake and eat it too

Late night thoughts on language personality types

Or, what C# code do you have to write to get the same functionality as F#?

Dr Frankenfunctor and the Monadster, part 3

Dr Frankenfunctor and the Monadster, part 2

Or, how a 19th century scientist nearly invented the state monad

A comparison of code vs UML

Celebrating the 5th anniversary of F# in Visual Studio

In which I throw away the previous design, and switch to a capability-centric approach

A walkthrough of the design decisions in a purely functional implementation

or, why predictability is important

A functional approach to authorization, part 3

A functional approach to authorization, part 2

Capability based security and more

Properties for a dollar object

Properties for roman numeral conversion

Properties for list functions

Or, I want to use PBT, but I can never think of any properties to use

Generators, shrinkers and more

Outwitting malicious compliance with property-based testing

Designing using a state machine

Adding the services and user interface, and dealing with disaster

Testing the design with a trial implementation

The type-first approach to designing a Calculator

Twenty six low-risk ways to use F# at work (part 5)

Twenty six low-risk ways to use F# at work (part 4)

Twenty six low-risk ways to use F# at work (part 3)

Twenty six low-risk ways to use F# at work (part 2)

You can start right now -- no permission needed

Lines of code, dependency analysis and more

My approach to the Roman Numerals Kata

Monoids without tears - Part 3

Monoids without tears - Part 2

A mostly mathless discussion of a common functional pattern

Three ways to implement FizzBuzz

Comparing some real-world metrics of C# and F# projects

Cyclic dependencies: Part 1

Cyclic dependencies: Part 2

A recipe for a functional app, Part 3

A recipe for a functional app, part 2

A recipe for a functional app, part 1

A rant against something I don't get

Implementing While, Using, and exception handling

Delaying a workflow externally

Stupid method tricks

Controlling when functions execute

How to return multiple values at once

Getting started with the basic builder methods

We discover that even lists can be wrapper types

Using types to assist the workflow

Steps towards creating our own 'let!'

How 'let' works behind the scenes

Unwrapping the enigma...

A before and after comparison

Working with integers and dates safely

Adding more semantic information to a primitive type

Using state machines to ensure correctness

Gaining deeper insight into the domain

Encoding business logic in types

Adding meaning to primitive types

Making design more transparent and improving correctness

F# equivalents to C#

Three approaches to porting existing C# code to F#

Tips and techniques for printing and logging

Ints, strings, bools, etc

Type safety for numerics

Not the same as a union type

Behind the magic curtain

Using combinators to build functionality

More pattern matching in practice

Pattern matching in practice

The workhorse of F#

And why it is not null or nullable

Adding types together

Extending tuples with labels

Multiplying types together

Also known as aliases

A look at the big picture

A new world of types

Syntax for throwing and catching

And how to avoid using them

a, f, x and friends

Understanding the offside rule

How to use them

Control flows, lets, dos, and more

Why expressions are safer and make better building blocks

How to code in F#

Creating methods the F# way

Nested functions and modules

A function signature can give you some idea of what it does

Lambdas and more

Building new functions from existing ones

Baking-in some of the parameters of a function

Breaking multi-parameter functions into smaller one-parameter functions

Understanding the type notation

Binding not assignment

The impetus behind functional programming

A look at the basics of functional programming

A whirlwind tour of object-oriented code in F#

Some convenient features for working with .NET libraries

F# is part of the whole .NET ecosystem

Turning events into streams

Making it easier to think about concurrency

Encapsulating a background task with the Async class

The next major revolution in how we write software?

How to make illegal states unrepresentable

In F# the type system is your friend, not your enemy

A powerful technique to ensure correctness

Making your code predictable

How to write 'compile time unit tests'

Dynamic patterns for powerful matching

How to fix some of a function's parameters

OO design patterns can be trivial when functions are used

Immutability and built-in equality with no coding

Features that reduce programming drudgery and boilerplate code

Pattern matching can match and bind in a single step

Function composition and mini-languages make code more readable

The functional approach to the DRY principle

No penalty for making new types

How to avoid getting distracted by complex type syntax

Why is conciseness important?

The concepts that differentiate F# from a standard imperative language

In which we see that F# excels at callbacks, and we are introduced to the 'use' keyword

In which we see that F# is more declarative than C#, and we are introduced to pattern matching.

In which we attempt to sum the squares from 1 to N without using a loop

A very quick overview on how to read F# code

An overview of the benefits of F#