Wrapping Up

[00:00:00]
>> Kyle Simpson: All right, we have reached the end of our course and I wanna make sure that we just look over where we've come and give you a road map to going back and reviewing these things. The material that we've gone over in this course is stuff that you can't learn in eight or ten hours.

[00:00:15]
It's gonna take days, weeks, months, even potentially years of working with this stuff. So this hopefully is a course and the book that is a companion to it, is a road map for you to go back and try these things little, by little, by little. What I hope that you get out of this, is that you could take just the concepts in the discussion of functions and the idea of avoiding side effects and the idea of doing some point free style refactorings and just do that in your programming code base.

[00:00:44]
And you would improve things substantially. And then you could later on some closure to start remembering things and using some currying techniques and then you could layer on composition for your data flows and then you could layer on immutability. And the point that I'm trying to make is you don't have to go wholesale entirely, all functional programming.

[00:01:05]
The idea behind functional line, is a ground up, pragmatic and most of all incremental approach to layering these things, using immutability, using the ideas of recursion. Using lists and data structure operations and adapting things for asynchrony over time. Little, by little, by little, you'll refactor your code bases.

[00:01:26]
The truth is, that even several years into this journey of learning function and adapting it to my JavaScript code, I still don't start out writing a functional program. I definitely avoid some problems that I've gotten so comfortable with, that from the very beginning I can write. But for the most part, the way I still write my programs, is I write the imperative form and then I go back and I refactor it to be more functional.

[00:01:53]
And I do that little, by little, by little. And then I'll write another piece of my app and it's very imperative and there's bugs and weird stuff. And little, by little, by little, as I refactor it, I try to make it better and better and better with the principles of functional.

[00:02:06]
And my journey points to the idea that you can't really just go top down at functional. If you learned as an imperative programmer, the way all of us did, you really have to go bottom up. There's no other way to climb the cliff, than one step at a time, you can't just jump to the top.

[00:02:25]
You gotta climb this cliff one step at a time. And I hope what you've gotten out of this course, is now you're not scared of the equipment. Now you understand what the equipment does and as you climb up the mountain, as you figure out that journey, make sure to leave a map for other people to see how you're going as well.

[00:02:42]
Thanks very much for hanging in through a pretty intense course. If your brain is wiped out, my brain is certainly wiped out. So thanks for hanging in for a pretty tough course. I hope that you have learned and most of all, I hope that we've sparked some curiosity for you to see how to apply these functional principles in your code.

[00:03:00]
Thanks a lot.
>> Class: [APPLAUSE]