Functional Programming in JavaScript video edition

Table of contents

1. PART 1. Think functionally
   1. Chapter 1. Becoming functional
   2. Chapter 1. What is functional programming?
   3. Chapter 1. Pure functions and the problem with side effects
   4. Chapter 1. Referential transparency and substitutability
   5. Chapter 1. Benefits of functional programming
   6. Chapter 1. Reacting to the complexity of asynchronous applications
   7. Chapter 2. Higher-order JavaScript
   8. Chapter 2. Functional vs. object-oriented programming
   9. Chapter 2. Managing the state of JavaScript objects
   10. Chapter 2. Deep-freezing moving parts
   11. Chapter 2. Functions
   12. Chapter 2. Types of function invocation
   13. Chapter 2. Closures and scopes
   14. Chapter 2. JavaScript’s function scope
   15. Chapter 2. Practical applications of closures
2. PART 2. Get functional
   1. Chapter 3. Few data structures, many operations
   2. Chapter 3. Understanding lambda expressions
   3. Chapter 3. Gathering results with _.reduce
   4. Chapter 3. Reasoning about your code
   5. Chapter 3. SQL-like data: functions as data
   6. Chapter 3. Learning to think recursively
   7. Chapter 3. Recursively defined data structures
   8. Chapter 4. Toward modular, reusable code
   9. Chapter 4. Requirements for compatible functions
   10. Chapter 4. Curried function evaluation
   11. Chapter 4. Partial application and parameter binding
   12. Chapter 4. Composing function pipelines
   13. Chapter 4. Composition with functional libraries
   14. Chapter 4. Managing control flow with functional combinators
   15. Chapter 4. Fork (join) combinator
   16. Chapter 5. Design patterns against complexity
   17. Chapter 5. Building a better solution: functors
   18. Chapter 5. Functors explained
   19. Chapter 5. Functional error handling using monads
   20. Chapter 5. Error handling with Maybe and Either monads
   21. Chapter 5. Interacting with external resources using the IO monad
   22. Chapter 5. Monadic chains and compositions
3. PART 3. Enhancing your functional skills
   1. Chapter 6. Bulletproofing your code
   2. Chapter 6. Challenges of testing imperative programs
   3. Chapter 6. Testing functional code
   4. Chapter 6. Separating the pure from the impure with monadic isolation
   5. Chapter 6. Capturing specifications with property-based testing
   6. Chapter 6. Measuring effectiveness through code coverage
   7. Chapter 6. Measuring the complexity of functional code
   8. Chapter 7. Functional optimizations
   9. Chapter 7. Currying and the function context stack
   10. Chapter 7. Deferring execution using lazy evaluation
   11. Chapter 7. Implementing a call-when-needed strategy
   12. Chapter 7. Taking advantage of currying and memoization
   13. Chapter 7. Recursion and tail-call optimization (TCO)
   14. Chapter 8. Managing asynchronous events and data
   15. Chapter 8. Falling into a callback pyramid
   16. Chapter 8. First-class asynchronous behavior with promises
   17. Chapter 8. Future method chains
   18. Chapter 8. Lazy data generation
   19. Chapter 8. Functional and reactive programming with RxJS
   20. Chapter 8. RxJS and promises