Check out a free preview of the full Functional-Light JavaScript, v3 course:
The "Course Overview" Lesson is part of the full, Functional-Light JavaScript, v3 course featured in this preview video. Here's what you'd learn in this lesson:

Kyle gives an overview of the course. Topics include: function purity, closure, composition, immutability, recursion, lists/data structures, asynchronous programming, and functional programming libraries. - https://frontendmasters.com/teachers/kyle-simpson/code-is-for-humans/

Get Unlimited Access Now

Transcript from the "Course Overview" Lesson

[00:00:00]
>> Kyle Simpson: What are we in for in this course? What are we looking at? We're gonna start talking about the carabiners, and the ropes, and the knots, and the boots, and all those fundamental equipment things that let us do functional programming. Here's a quick overview of what to expect.

[00:00:19] We're gonna start first with functions cuz any discussion of functional programming, we probably need to understand functions better, and here's a little bit of a hint, you probably don't know what a function is. I certainly didn't until a couple of years ago, I've been doing programming for a long time and I didn't know what a function was, that's kind of basic thing you are gonna start with.

[00:00:39] So we are gonna actually dig in a function way more than we used to probably, we're gonna look at all different sizes. We are gonna look at closure, you've probably heard or given at job interview at some point what is closure. I would venture to say it is impossible to understand functional programming without understanding closure.

[00:00:58] I've heard many people say, I understand functional programming and what they mean is I'll use map and reduce, that is a little piece of it. That is one of the pieces of equipment that we need, but it is not sufficient to climb the mountain, closure is one of the most critical pieces of the equipment, in fact it'll enable almost everything else that we do.

[00:01:20] Now we're gonna look at composition, the way that data flows and is mapped through our applications, we're gonna look at immutability, how we manage the changes to values and state over time, management of state change is one of the big key ideals of all programming. Almost every framework, every programming paradigm, they have some idea of what you ought to do with managing state over time, cuz that's what a program really is.

[00:01:46] It's a state machine, it's managing state over time, functional programming has a very specific way of thinking about that question, so we'll look at immutability. Recursion is one that kind of scares people similar to if I had thrown your regular expressions, [LAUGH] if I said regular expressions, some of you would be like I don't wanna do regular expressions.

[00:02:04] [LAUGH] It's okay, recursion is useful and important. Not that you can solve every problem with recursion, but you shouldn't be scared of it. It's a very useful tool and it's especially useful to the functional programming. Then we will finally actually get to look at the map filter reduce, that thing that everybody calls functional part and we're going to look at that and where it fits in, but you won't understand or appreciate where it fits in, unless you've got these other pieces of equipment ready to go.

[00:02:33]
>> Kyle Simpson: And all of that will have taken us to the question of how do we operate on, in a functional way, how do we operate on values right now, values that we have right now? But guess what? Our programs all have values now, and they all have values they will have at a later time, there's always a time component.

[00:02:51] So how do I apply functional principles over time? How do I do asynchronous programming? And there's lots of ways to answer that question but the one specific way we're gonna answer that in this course, is we're going to look at adapting functional principles over time with observables, okay?

[00:03:11] And we'll end the course by taking a look at just a few, of the libraries that you might choose to use when you wanna go out and start doing your own functional programming and you need a library with helpers to help you do that, and we'll look at a few of those, some of the popular ones and a few others, and that's where we'll end the course.

[00:03:30] So that's what to expect It's a deep journey, okay so buckle your seat belt because there's a lot to get through.
>> Kyle Simpson: Before we jump into the course, you should definitely hear my thoughts on code readability.