JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

In the last few years, the software development industry has seen a resurgence of functional programming. But what is it? And how do you get started? 

“Just Enough” is an introduction to functional programming, written in JavaScript, that doesn’t get bogged down in the jargon and mathematical theory that can be so intimidating. Instead, it provides an approachable introduction to the paradigm that will give you the education and confidence you need to start using the programming style right away.

With “Just Enough” as our guide, this course will focus on the foundational knowledge needed to approach any functional language. By the end of the course, you will understand:

- higher order functions
- pure functions
- immutability
- currying
- partial application
- pointfree programming
- functional composition

In just 30 minutes, you’ll learn more than just enough. 

In this introductory course on functional programming, we will learn "just enough" of the concepts you need to start using the programming paradigm.

One of the goals of this course is to introduce as little jargon as necessary. Functional programming vernacular can be very intimidating and a barrier to entry, so we'll avoid those whenever possible.

Another goal of this course is to teach the concepts in a language agnostic fashion. While this course is written in JavaScript, the concepts can be applied to any functional programming language, such as Haskell, Scala, Clojure, etc.

Together we will learn about higher order functions, pure and impure functions, immutable data structures, currying, partial application, the importance of argument order, pointfree programming, composition, a tiny bit of math with the associative property, and how to debug functional compositions.

My personal hope with this course is to inspire you to take what you learn here and go explore functional programming more.

Course Introduction to Just Enough Functional Programming In JavaScript

This lesson teaches the concept of higher order functions (HOF) in JavaScript, a necessary building block of functional programming in any language. 

A higher order function does at least one of the following things, often both:

1. Accepts a function as an argument
2. Returns a new function

To demonstrate this, we will build a higher order function, `withCount()`, that modifies any function passed to it so that it logs out how many times it has been called.

Modify Functions with Higher Order Functions in JavaScript

This lesson teaches you the concepts of immutability, the difference between mutable and immutable data structures, and how to change data through mutable and immutable patterns. Immutable data is necessary in functional programming because mutations are a side effect. Our transformation of data should not affect the original data source, but instead should return a new data source with our updates applied.

To demonstrate the difference between mutability and immutability, imagine taking a drink from a glass of water. If our glass is mutable, when we take a drink, we retain the same glass and change the amount of water in that glass. However, if our glass is immutable, when we take a drink, we get back a brand new, identical glass containing the correctly drank amount. Perhaps a strange way to conceive of the action, but creating new data structures makes our methods pure and thread-safe, a benefit of functional programming.

Avoiding Mutations in JavaScript with Immutable Data Structures

This lesson teaches you what currying is: the act of refactoring a function so that it receives its arguments one at a time.  We will use the canonical example of an add function to demonstrate this. This lesson also teaches the concept of “arity”, the number of arguments a function receives, as it is useful knowledge for functional programming.

Refactor a Function to Use Currying in JavaScript

This lesson teaches you the difference between pure and impure functions through examples of both. Pure functions are any functions whose output is solely derived from its inputs and causes no side effects in the application or outside world. Mathematical functions are examples of pure functions.

Impure functions come in a variety of shapes and sizes. Some typical examples would be:

* Functions whose output depends on outside/global state
* Functions that return different outputs for the same inputs
* Functions that modify application state
* Functions that modify the "outside world"

Functional programming is built upon the use of pure functions and the strict control of side effects. Being able to recognize either type of function is a key fundamental for functional programming.

Identify Side Effects by Comparing Pure and Impure JavaScript Functions

This lesson teaches you how arguments passed to a curried function allow us to store data in closure to be reused in our programs and applications. Since each argument, except for the final one, returns a new function, we can easily create reusable functions by supplying some of these arguments beforehand, and sharing these partially applied functions with other parts of our codebase. In this lesson, we'll create a curried function to fetch requests from an API that uses partial application to create reusable functionality.


Create Reusable Functions with Partial Application in JavaScript 

This lesson teaches you what pointfree programming is, passing a named function as an argument to avoid writing an anonymous function with interim variables instead. Pointfree programming increases code legibility, decreases the surface area for bugs, and makes our code more composable and unit testable. We will demonstrate this by removing the anonymous arrow function passed as a callback to a `map` method with a named function.

Eliminate Anonymous JavaScript Functions with Pointfree Programming

This lesson teaches you the concept of composition, the building up of complex functionality through the combining of simpler functions. In a sense, composition is the nesting of functions, passing the result of one in as the input into the next. But rather than create an indecipherable amount of nesting, we'll create a higher order function, `compose()`, that takes all of the functions we want to combine, and returns us a new function to use in our app.

Build Up Complex Functionality by Composing Simple Functions in JavaScript

This lesson teaches you to order the arguments of your functions following functional programming principles. By ordering our arguments in a specific way, we allow our functions to benefit from partial application, improve reusability, and enable composition of functions. Specifically, we will focus on always providing the data as the last argument to our functions so that the result of one function can be piped as the argument into another function.

Improve JavaScript Function Usability with Proper Argument Order in Functional Programming

This lesson teaches you what the associative property is, the mathematical principle that proves the grouping of values in when adding or multiplying does not affect the result and applies it to functional composition. This lesson will demonstrate how we can achieve the same composition with different groupings of smaller compositions. This gives us confidence in our code and the ability to create even greater complexity with compositions.

Using the Associative Property in JavaScript Functional Compositions

Functional compositions are purposely opaque, with no obvious way to "visualize" the data as it transforms. This is great when our function works, as it's hard to _add_ bugs, but challenging when our compositions aren't correct. This lesson teaches you how to debug functional compositions by writing and using a `trace()` function to log out our values as they transform. This allows us to continue using pointfree programming while also providing a view into our compositions.


Just Enough Functional Programming in JavaScript

Kyle Shevlin

Course Content