While we anchor these techniques into your mind with the practical usage, you will also learn about techniques to write maintainable software, test-driven development, top-down design, and bottom-up design. Finally, we will use Mocha and Chai to write unit tests for the functional part of the applications.
By the end of this Video Learning Path, you will get a hands-on functional application development experience.
For this course, we have combined the best works of this esteemed authors:
Zsolt Nagy is a web development team lead, mentor, and software engineer living in Berlin, Germany. As a software engineer, he continuously challenges himself to stick to the highest possible standards when improving his own knowledge. The best way of learning is to create a meaningful product on the way.
Pure functions, like mathematical functions, always return the same value when given the same inputs, so the two are interchangeable. Functional Programming is expressive, we think less about what's happening inside functions and focus more on relations between function inputs and their outputs.
Every program has impure functions; they are the only ticket in town for reading, writing and displaying information. In order to protect the benefits, we've gained by writing pure functions; we'll begin looking at how we can isolate impure code while still using it to feed us information.
Pure functions seem to restrict what we’re able to do in our apps, higher-order functions open our eyes to new ways we can write and use functions. They give us powerful tools and reusable utilities.
There are constructs in our programs we have grown accustom to always using, loops are one of these constructs. We can stop writing loops and instead use higher-order functions. This will make our code more readable, expressive and open our thinking to new ways of using higher-order functions.
Reduce is another very popular higher-order function used for working over collections of data. It can be a little more difficult to reason about than map and filter, however it can have a lot more uses than map and filter as well.
Higher-order functions did some neat tricks for us working with Arrays, and we aren’t close to finish. Rendering to the DOM can get a lift from higher-order components by allowing us to perform generalized work over arbitrary components
As programs grow, creating higher-order nested functions won’t be as flexible as we once thought. There is a better way to pass a couple input values into a function and still get as return a higher-order function with those values in a closure without wiring nests of functions like Russian dolls.
Now that we understand what partial application and currying are, we’ll want to see how we can use some common partial application utilities to write higher-order functions without writing entire new functions or refactoring old ones. We’ll see how a few different utilities operate.
Partial Application and Currying can take time to adjust to but they become tools we don’t want to live without. It’s nice to be able to quickly write partial application utilities so we can add them to any project. Writing utilities gives the added benefit of gaining stronger understanding.
It’s time again to combine the techniques we’ve been learning and see how they work well with each other. We should be able to use a lot more functions with our higher-order functions map, filter, and reduce as well as instantly improve any function that works over arrays with the “curry” utility.
Making objects immutable could add complexity to an application. Persistent data structures might be complicated to add into a project and many time might not even be needed. Lenses can simplify working with data and make adding new data structures into a project easier.
Our objective is to understand what category theory is, in order to define functors. Knowing these terms will give you a deeper understanding of the concepts underlying the map function in functional programming.
Now that you have a basic idea about functors, we can move on to understand monads in practice. We will not focus on the theoretical details that much. You will rather understand the basics in practice, so that you will be able to approach more complex theoretical articles.
This video will contain a simplified introduction to generator functions in order to use it for the purpose of handling asynchronous code.
Eager evaluation often comes at a price. Therefore, it is essential to understand an alternative: lazy evaluation, including its benefits and drawbacks. As one of the drawbacks of lazy evaluation is the cost of retrieving the same elements multiple times, youwill learn how to combat this drawback with memoization.
You will learn how to implement lazy evaluation with generator functions. We will implement a lazy filter function, and then we will cover a couple of examples. You will learn how to handle infinite sequences, and how to retrieve multiple elements of an infinite sequence using the lazy take function.
I will give you a short overview on what's awaiting you. This is a long and practical section, so I highly recommend preparing for the challenge by following the advice in this video. This section will also act as a revision for volumes 1 and 2. I will highlight the sections and videos you will need in case you get stuck with a concept.
Let me introduce you to the wireframe of the app we will build in this section. The application itself is called the Weather App.
This video will walk you through the ins and outs of setting up an application including automated testing.
You will learn how to use test driven development to write a functional utility library guided by tests. You will learn the basics of writing automated testsand bottom-up software design in order to construct some utility belt libraries for the purpose of building the weather app.
We will continue practicing bottom-up design and test driven development to build a parser utility. The parser utility will be used later to render the DOM nodes of the application.
We will solve the problem of handling timezones in our application by installing moment.js and using the Google timezone API. We will then finish both of our utility libraries exercising test driven development.
After a short introduction on how to test asynchronous code and API interactions, we will create a city weather form and implement a click event to fire the API. You will learn how to query sequential and parallel API calls using async-await. We will also handle the response to prepare our data for rendering.
We connect top-down and bottom-up code by rendering weather data on screen. Rendering is done using a presenter module, encapsulating a DOM insertion, and some event handlers. We conclude the implementation of the weather app with some cleanup.
Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.
With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.
From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.
Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.