- Get to grips with data flow using immutability and learn how to reason with code
- Eliminate the common loop problems efficiently using Recursion
- Boost your performance by using lazy functions and employing laziness to increase performance
- Play with the included sample application – a text-based adventure game – to see the techniques put together
Along with being tried and trusted, functional programming is one of the biggest current trends in programming.
Its focus on side-effect free code, unadorned data manipulation and simple structures promote a coding style that reduces bugs, and lifts the level of abstraction to a point where we can achieve more with less code.
All topics discussed in the course can be used to various degrees in any code-base – even if your daily work is with a huge object-oriented project, the techniques discussed will certainly be useful.
- We start by investigating the power of higher-order functions by diving right into the implementation of the sample application.
- We then elaborate by partially applying and composing functions before we end up with lazy evaluation to boost our abstraction power and performance.
- Right from the start we'll dive into the implementation of a text-based adventure game.
- We will also see how function composition is used to solve specific problems in this domain by combining highly generic functions.
- We learn function programming techniques that help improve asynchronous code used to load the game from disk.
- Later we'll become acquainted with a few other examples as well, as we learn about designing applications around an immutable data structure.
- And we end our journey with a discussion of recursion and how it relates to lazy data structures, and show examples of using previously discussed techniques on infinite data sets.
Introduction to Functional Programming
- The Course Overview free 00:03:54
- What Is Functional Programming? free 00:04:08
- Your First Functional Programming Concepts 00:03:33
Higher Order Functions
- First-class Functions 00:02:41
- Passing Functions as Arguments 00:08:31
- Returning Functions 00:04:39
- Callbacks 00:05:14
- Continuation Passing Style 00:06:34
- Promises 00:10:33
- Partial Function Application 00:07:05
- Currying 00:08:44
- Composition 00:07:01
- What Is Immutability? 00:06:46
- Working with Immutability 00:08:59
- Immutability in the UI 00:06:00
- Mechanics and Performance 00:06:59
- Recursive Thinking 00:07:25
- A Recursive AST Parser 00:07:15
- Trampolining 00:04:48
- Lazy Evaluation 00:08:46
- Lazy Sequences 00:05:45
- Infinite Sequences 00:05:12