Since I started playing with — and occasionally raving about — functional programming, a lot of people have asked me how to get started. Instead of writing the same email repeatedly, I decided to put everything in one place. This is a collection of the resources that actually helped me, updated as I find better ones.
Fair warning: I came to FP from an OOP background (C#, mostly), so these resources are weighted toward that transition rather than toward someone coming from Python or JavaScript. I have added a JavaScript section at the end for those coming from that direction.
Why Functional Programming
Before the resource list: why bother?
The functional paradigm changes how you think about problems. Where object-oriented programming organises code around things that do things, functional programming organises it around transformations of data. The result tends to be code that is easier to test (pure functions have no hidden state), easier to reason about (immutability removes whole categories of bugs), and surprisingly well-suited to concurrent execution.
For developers who work with databases, the fit is particularly strong. Relational queries are essentially functional transformations — data in, data out, no side effects. SQL is, in some ways, more functionally structured than most OOP code.
The other honest answer: learning FP makes you better at every other paradigm you use. The instinct to make state changes explicit, to favour transformation over mutation, to think in terms of input and output rather than objects and methods — these habits improve C# and JavaScript code even when you never write a line of F# or Haskell in production.
Common Misconceptions
"FP is only for academics." This was true twenty years ago. Today, functional concepts are central to React, LINQ, modern Python, Java streams, and Rust. You are already using FP whether you call it that or not.
"You need to understand monads before you can write useful FP code." No. Write pure functions. Avoid mutation where possible. Use higher-order functions (map, filter, fold). That is 80% of the value, and it does not require category theory.
"FP is slow." Immutability can have overhead, but modern compilers and runtimes handle this well. In most application code the performance difference is irrelevant. Where it matters, it is addressable.
Getting Started: Concepts
Professor Frisby's Mostly Adequate Guide to Functional Programming — a free, open-source book on GitHub. Covers pure functions, currying, composition, functors, and monads with JavaScript implementations. The writing is dry and occasionally very funny. Start here if you want to ease in gradually.
Functional Programming in Scala (the Red Book) — more demanding. Even without using Scala, working through the early chapters builds a rigorous mental model that transfers to other languages. The exercises are genuinely challenging in the right way.
Erik Meijer's Functional Programming Fundamentals — a lecture series on Channel 9 using Haskell. Meijer is an exceptional teacher. If you can follow the syntax (or let it wash over you and focus on concepts), this is one of the clearest treatments of the fundamentals available for free.
Getting Started: Video
Railway Oriented Programming by Scott Wlaschin — available on YouTube and Vimeo. Uses F# to demonstrate error handling without exceptions using a functional approach. Even without F#, the mental model is immediately applicable. This was one of the first things that made the paradigm feel useful rather than merely interesting.
Functional Design Patterns by Scott Wlaschin — a longer talk covering how common OOP design patterns (strategy, template method, decorator) map to functional equivalents that are often simpler. Watch this back-to-back with Railway Oriented Programming as a good half-day investment.
Functional Programming with Effects by Rob Norris (scala) — a more advanced talk, but worth watching once you have the basics. The section on effects and how they relate to side effects reframes a lot of what intermediate FP developers think they understand.
Going Deeper: F#
If you want a practical, production-capable functional language that runs on .NET, F# is the obvious choice for C# developers. The interoperability story is excellent.
fsharpforfunandprofit.com — Scott Wlaschin's site, the canonical F# learning resource. The Why Use F# series is the starting point; the Domain Modelling Made Functional series is essential once you have the basics. Reading the entire site would take weeks and be worth it.
The Book of F# by Dave Fancher — practical introduction for C# developers. Covers the language thoroughly without requiring academic FP background.
Exercism F# Track — free, community-maintained exercise platform. The F# track is one of the better-maintained language tracks, and working through exercises with mentorship feedback accelerates learning considerably.
JavaScript FP Resources
If JavaScript is your primary language, the entry points are different:
Mostly Adequate Guide (above) — this uses JavaScript throughout, so it is directly applicable.
Ramda — a practical FP utility library for JavaScript. The documentation includes examples that demonstrate immutable transformation patterns. Working through the API is itself an education in functional thinking applied to real data manipulation.
fp-ts — TypeScript-first functional programming library. More demanding, but for TypeScript developers who want the full functional toolkit (Option, Either, TaskEither, etc.) this is the current standard.
"Functional-Light JavaScript" by Kyle Simpson — a pragmatic take on applying FP ideas in JavaScript without requiring a full paradigm shift. Good for teams who want to move incrementally.
A Suggested Learning Path
For most developers, this order makes sense:
- Watch Railway Oriented Programming (45 minutes)
- Read Why Use F# on fsharpforfunandprofit.com (2-3 hours)
- Work through the first 6 chapters of Professor Frisby's Guide
- Write something small in F# or Haskell — anything, just to get the compiler feedback loop
- Watch Functional Design Patterns
- Read Domain Modelling Made Functional (book or the blog version)
- Start applying what you have learned in whatever language you use at work
The last step is the one that matters. Reading and watching is preparation. The learning happens when you sit with a real problem and try to solve it functionally.
The Mindset Shift
The hardest part of learning functional programming is not the syntax. It is accepting that the way you have been structuring programs for years is not the only way — and sitting with that discomfort while you build a new set of instincts.
This is, incidentally, also good practice for the mind-body work this site explores in other areas. Changing a deeply ingrained pattern requires noticing the pattern, tolerating the discomfort of working without it, and giving the new pattern time to become automatic. FP is an unusually good workout for that kind of cognitive flexibility.
Start with Professor Frisby if you want to ease in. Start with Meijer if you want to be challenged immediately. Either way: write code. Reading about functional programming without writing it is like reading about swimming.