Learning Path: Functional Programming in JavaScript
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
8 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: Functional Programming in JavaScript to your Wishlist.

Add to Wishlist

Learning Path: Functional Programming in JavaScript

Harness the power of functional programming to build and test real-world applications
New
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
8 students enrolled
Created by Packt Publishing
Last updated 9/2017
English
English [Auto-generated]
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 5.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Discover the principles of functional programming
  • Learn the benefits and drawbacks of functional programming compared to other styles
  • Learn the language constructs of ES6 that are used for functional programming
  • Understand function composition and function sequencing in depth
  • See how to rewrite nested asynchronous callbacks with generator functions in a linear fashion
  • Understand how to model and use infinite sequences with lazy evaluation
  • Use a third-party library that simplifies communication with a server via an API
  • See how to set up your development environment, including automated testing
View Curriculum
Requirements
  • This Learning Path follows a theoretical and practical approach for developing maintainable applications in mostly functional style.
Description

Functional programming is a style of writing programs by simply composing a set of functions. It helps to write a lot of small reusable functions and simply call them one after the other. With regard to JavaScript, we have following features to our advantage:

•    Speed
•    Simplicity
•    Versatility
•    Server Load

If you're looking forward to building maintainable real-world applications by writing code in the functional way? If yes, this then go for this Learning Path.    

Packt’s Video Learning Path is a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

Let's take a quick look at your learning journey. This Learning Path begins with an introduction to functional programming wherein you will understand the principles of writing functional code along with its benefits and drawbacks. You will learn to write code that is easy to understand, test, and debug using ES6. You will then see how to use currying, partial evaluation, map, reduce, filter, recursion, and other functional programming concepts in ES6. Next, you will learn generator functions and the ES2017 sync-await construct which will help you set up communication with a server via an API during implementation of a web application. As you progress, you will learn lazy evaluation to optimize performance of your web application. Finally, you will implement a web application demonstrating the practical usage of most of the features that you've learned throughout this Learning Path.

By the end of this Learning Path, you will have a thorough understanding of functional programming in JavaScript and should be able to build and test your own applications.

About the Author:
For this course, we have the best works of this esteemed author:
 

  • Zsolt Nagy is a web development team lead, mentor, and software engineer living in Berlin, Germany. As a software engineer, Zsolt 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. Until you reach this state, the second best way of learning is to share with others what you learned and how you structure your thoughts.
Who is the target audience?
  • This Learning Path is for developers who would like to improve their skills and expertise by sticking to the highest quality standards when it comes to writing code. Prior knowledge of JavaScript is needed.
Compare to Other Functional Programming Courses
Curriculum For This Course
40 Lectures
05:23:46
+
Deep Dive into Functional JavaScript
22 Lectures 02:47:39

This video gives an overview of the entire course.

Preview 04:50

Our objective is to get a feel of the differences between functional programming and other programming styles such as object oriented programming, via a demonstrated code example.

Preview 10:44

We learn the principles of writing code in functional programming in depth: avoiding side effects by writing pure functions, and using immutable data structure. A code example introduces techniques used in functional programming.

Principles of Writing Code in Functional Style
07:31

We will summarize the advantages and disadvantages of functional programming, and we will also offset some of the disadvantages with some optimization techniques.

Benefits and Drawbacks of Functional Programming
06:34

ES6/ES2015 is introduced from a functional perspective, so that we can build on these fundamentals to write clear, compact functional code.

Getting Started with ES6
11:06

Using immutable data structures is a cornerstone of functional programming. Yet, the JavaScript support for immutability is not that obvious. This video raises awareness on the different types of cloning, and makes sure we don’t end up mutating our data.

Deep and Shallow Cloning in JavaScript
05:46

Functional programming techniques are mixed with other techniques in JavaScript. When it comes to handling events, timeouts, and other callbacks, we have to use techniques to connect functional code with its context. This video demonstrates how context binding is used as a connector.

Context Binding by Example
07:49

Reading pure functional code is often a riddle. We increase readability with object-oriented and functional techniques: chaining and function composition.

Chaining and Function Composition
12:58

JavaScript functions are values. Therefore, functions can be passed to other functions, and they can also be return values of functions. This is how we create higher order functions, giving us a powerful way to write loops and callbacks in functional style. 

What are Higher Order Functions?
05:02

In functional programming, we often use higher order functions on arrays instead of using loops. Therefore, it is beneficial to learn about ways of handling JavaScript arrays.

Handling JavaScript Arrays with Higher Order Functions
08:18

Even though forEach looks like a functional utility, it is not usable when our goal is to write side-effect free code. We should still substitute loops with proper functional constructs. Therefore, it is now time to introduce the map, reduce, and filter operations.

Introducing Map, Reduce, and Filter
08:50

We will take some SQL SELECT statements and translate them to queries written using JavaScript higher order functions such as map, reduce, and filter. You will not only learn how to perform inner joins of two tables but you will also see an example performing a left join. We will also learn how to group our results.

Joins with Map-Reduce
07:26

SQL queries often contain filtering conditions. As we will see filtering in action, we will first implement the filter function using reduce. Then we will apply various conditions on our queries to filter our results. We will filter regular joins as well as aggregated results.

Filtering Examples
06:16

This practical exercise will make you think out of the box a bit for understanding how advanced reduce functions can be implemented. We will use the reduce function to create a tree data structure from an array of nodes.

Converting an Array of Nodes to a Tree
06:08

You will learn some basic definitions and JavaScript constructs that we will use throughout the rest of the section.

Definitions
05:05

When writing higher order functions in functional style, you will often encounter the technique of currying. You will also need to understand currying for the purpose of understanding a partial application.

Deep Dive into Currying
10:44

We will start with a comparison between currying and partial application. We will then implement partial application in JavaScript. After the implementation, we will revisit the bind function of JavaScript for the purpose of partially applying arguments of a function. We will conclude this video with writing a partially applied map function.

Partial Application
11:15

We will use the principles of partial application in this section to implement a template renderer in JavaScript without using any external libraries.

Rendering Templates Using Partial Application
04:15

You will learn what recursion is in mathematics and in software development. You will also find out about different types of recursion. At the end of this section, we will see how to transfer iterative solutions to recursive solutions using accumulator variables.

Recursive and Iterative Solutions in JavaScript
06:49

This section introduces some optimization techniques combating the drawbacks of using recursion. These optimization techniques are mixing functional and non-functional elements of JavaScript, tail call optimization, and memoization.

Optimization Techniques with Recursion
11:14

You will review the main points learned in this volume in order to place them in your functional programming utility belt.

Your Functional Programming Utility Belt
06:28

In this last video, you will construct a learning plan for yourself based on your own goals. You will also get some recommendations that will accelerate your learning curve.

Your Learning Path
02:31
+
Implementing and Testing Applications using Functional JavaScript
18 Lectures 02:36:07

This video gives an overview of entire course.

Preview 04:07

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.

Functors in JavaScript
08:43

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.

Monads
07:05

We will start with the definition of a problem in JavaScript called the pyramid of doom, also known as the callback hell through some examples, and mention ways to get out of it.

Escaping the Pyramid of Doom
09:50

We will introduce ES6 promises to handle asynchronous code in JavaScript. Beyond learning the ins and outs of promises, we will also demolish the pyramid of doom. 

ES6 Promises and Functional Programming
14:10

This video will contain a simplified introduction to generator functions in order to use it for the purpose of handling asynchronous code.

Asynchronous Functional Programming with ES6 Generator Functions
10:57

Promises and generator functions have been sufficient for asynchronous programming, but the code was far too verbose. ES2017 async-await gives you all the tools you need to elegantly and compactly model asynchronous problems in practice in JavaScript.

Functional Programming with Async-Await
07:16

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.

What Is Lazy Evaluation?
10:29

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.

Using ES6 Generator Functions for Evaluating Lazy Sequences
09:21

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.

Introduction
04:41

Let me introduce you to the wireframe of the app we will build in this section. The application itself is called the Weather App.

Weather App
04:22

This video will walk you through the ins and outs of setting up an application including automated testing.

Application Setup
06:05

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.

Bottom-Up Design Using Test Driven Development
12:31

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.

Bottom-Up Design and TDD (Continued) –Parsing the Response
06:41

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.

Handling Timezones
15:19

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.

Getting Weather Data with Promises and Async-Await
11:52

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.

Rendering the Weather App
06:50

The last video of this course summarizes this volume. We will recap the main topics you learned, and you will also receive some pointers on topics worth referring to for the purpose of mastering functional programming in JavaScript.

Course Summary and Next Steps
05:48
About the Instructor
Packt Publishing
3.9 Average rating
8,197 Reviews
58,869 Students
687 Courses
Tech Knowledge in Motion

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.