- 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.