The Lambda Path
Tags: functional, javascript, clojure
Published: 2019-10-09 13:16:20

---
title: The Lambda Path
published: true
date: 2019-10-08 19:00:00 UTC
tags: functional, fp, javascript, clojure
canonical_url: https://caioferreira.dev/post/the-lambda-path/
---

Photo by [Roman Mager](https://unsplash.com/@roman_lazygeek) on [Unsplash](https://unsplash.com/photos/5mZ_M06Fc9g)

# Introduction

Being passionate by functional programming I am often asked about how and where one can learn more about this style. Hence, I decided to compile some resources on the subject to suggest a path to this beautiful world.

I split the content into three levels: Beginner, Intermediate and Advanced. Since this is thought of as a starter to master path, I gave preference to contents in Javascript, which is a well-known language that allows for a great extent of functional patterns.

Some purists probably will hate me for this choice.

In this path I tried to add resources on fundamental functional concepts and tools, then an introduction to some functional patterns like Combinators, Category Theory, Railroad Programming and finally a material to deepening into complex subjects.

After all, I also added some tips on dedicated functional languages that I found easy to play with or that I simply love to work with.

# The Yellow Bricks Road

## Beginner

[Functional Programming Principles](https://www.freecodecamp.org/news/functional-programming-principles-in-javascript-1b8fc6c3563f/) - Article about basic principles of the functional paradigm, like pure functions and immutability

[Functional programming in Javascript](https://www.youtube.com/playlist?list=PL0zVEGEvSaeEd9hlmCXrk5yUyqUag-n84) -  **Highly recommended.**  Video series from the renowned Youtube channel FunFunFunction about functional tools and concepts in Javascript. The explanation is deep and clear about the subjects.

[Eloquent Javascript: Functional Programming](http://eloquentjavascript.net/1st_edition/chapter6.html) - The Eloquent Javascript’s chapter about functional programming. It is a hands on to building fundamental tools by hand, understanding its applications and usages.

[Becoming Functional](http://shop.oreilly.com/product/0636920030331.do) - An excellent book about the functional paradigm as a whole, presenting topics from functional principles like pure functions to advanced techniques like pattern matching. Unfortunately, the example is in Java.

## Intermediate

[Functional Design Patterns](https://www.youtube.com/watch?v=E8I19uA-wGY&ab_channel=IvanPlyusnin) - An amazing talk about how to combine different pieces of pure functions into more complex applications.

[Javascript Combinators](https://vimeo.com/153097877) - a talk from one of the greatest names in Functional Javascript, Reginald “Raganwald” Braithwaite, where he explores the concept of composition and introduces the Combinators pattern, a powerful functional tool inspired by Lambda Calculus.

[Professor Frisby Mostly Adequate Guide to Functional Programming](https://mostly-adequate.gitbooks.io/mostly-adequate-guide/) - An excellent resource on more complex functional patterns using Category Theory. This approach is less common on Front End and probably we can get most of the benefits of the functional paradigm without the complexity of an entire branch of mathematics.

## Advanced

[Category Theory for Programmers](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/) - The most recognized and advanced resource on Category Theory for development ends.

[To Grok a Mockingbird](https://raganwald.com/2018/08/30/to-grok-a-mockingbird.html) & [Why Y? Deriving the Y Combinator in JavaScript](http://raganwald.com/2018/09/10/why-y.html) - two incredible articles from Reginald Braithwaite about the application of the Combinators pattern.

# Going full functional

If you enjoyed your travel and want to keep going into this path, I recommend that you play with some fully functional programming language. I suggest Elm, ReasonML, and Clojure.

The first two (Elm and ReasonML) are functional languages that compile to JavaScript and are used to build front end applications. A special note to ReasonML which has great integration with React, being a language developed by Facebook.

The last one is Clojure, a JVM language, dynamically typed and from the LISP family. It is used primarily on the back-end and is well suitable for describing complex domain since it’s syntax is very flexible and can be customized in a way to better describe your problem space.

You can find more about these languages here:

- Elm: [Documentation](https://elm-lang.org/) and [Code Example](https://github.com/rtfeldman/elm-spa-example)
- ReasonML: [Documentation](https://reasonml.github.io/) and [Code Example](https://github.com/jihchi/reason-react-realworld-example-app)
- Clojure: [Best Book for new Clojurists](https://www.braveclojure.com/clojure-for-the-brave-and-true/) and [Code Example](https://github.com/furkan3ayraktar/clojure-polylith-realworld-example-app)

# Summary

The Lambda World is a vast and beautiful one, you will find many ways of thinking and solving problems. That is the main reason why I love FP, it not only brings new tools to your workbench but also constantly shifts your mental models. In this segment I could not leave the most impactful talk on my perspective on the work and profession on software engineering: [Simple Made Easy](https://www.infoq.com/presentations/Simple-Made-Easy/) by Rich Hickey, the creator of Clojure.

I hope these tips help you and fair travel!