Functional Programming: The Big Picture

Functional programming is gaining traction and popularity in the industry. However, it's not always clear why someone should care about it. This course will look at what it is, how it's different, and why it matters.
Course info
Rating
(56)
Level
Beginner
Updated
Nov 21, 2018
Duration
1h 12m
Table of contents
Description
Course info
Rating
(56)
Level
Beginner
Updated
Nov 21, 2018
Duration
1h 12m
Description

Functional programming is not a new concept, but in the past few years, it has seen a sharp growth in usage and general interest. However, it's not always clear why anyone should be interested in functional programming. In this course, Functional Programming: The Big Picture, you’ll learn about what functional programming is, in a language agnostic way, and why functional programming matters. First, you’ll explore basic concepts such as pure functions and why they matter. Next, you’ll discover how immutable data, a key aspect of functional programming, helps reduce bugs. Finally, you’ll learn about some larger applications where functional programming excels. When you’re finished with this course, you'll have a better understanding of what functional programming is, how functional programming is different, and why you should care about functional programming.

About the author
About the author

Nate's first program was written in QBasic on an 8086 clone his dad built. Since then he's written applications in C++, .NET, and Node.js.

More from the author
SinonJS Fundamentals
Intermediate
2h 22m
Jul 2, 2018
Postman Fundamentals
Beginner
2h 40m
Dec 12, 2017
More courses by Nate Taylor
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Nate Taylor, and welcome to my course, Functional Programming: The Big Picture. I am a solutions architect at Aviture in Omaha, Nebraska. As computers continue to run on multi-core CPUs, and as distributed computing in the cloud continues to gain traction, functional programming will continue to see more and more usage in the software world. In this course, we're going to first of all learn what makes functional programming different from other programming paradigms, secondly, see how functional programming can help reduce the number of bugs in your application, third, get a glimpse of how functional programming simplifies horizontal scaling, and fourth, discover a list of possible functional programming languages to learn. By the end of the course, you'll see why functional programming matters, and you'll be ready to start learning a functional language in more depth. Before beginning the course, it would be helpful, but not required if you're familiar with an object-oriented programming language. I hope you'll join me on this journey to learn functional programming with the Functional Programming: The Big Picture course, at Pluralsight.

What Is Functional Programming?
If you're watching this course then you've most likely already heard of functional programming. It could be that you've seen some tweets or blog posts, or possibly you've overheard someone talking about it at a conference or around the office. And while those people sounded convinced of the value of functional programming, they didn't exactly explain what it is. In this module, you'll start to get a basic understanding of functional programming that will be expanded on throughout the rest of the course.

Do One Thing Well
In the last module, you heard Bruce Lee's quote that he feared the man who had practiced 1 kick 10, 000 times. You also heard Alan Perlis' statement that it's better to have 100 functions operate on one data structure than 10 functions on 10 data structures. Both of these quotes emphasize the importance of focus. You also saw a quick explanation of how that type of focus applies to functional programming. Now it's time to move beyond the cursory and see the principle in more depth as you start to learn about the special role functions have in functional programming.

Reducing Bugs with Immutable Data
Bugs are the enemy of every program and every programmer. In the previous module, you learned about making sure each function only focused on one thing. This is often credited as one of the ways that functional programming makes it easier to reason about the problem. However, pure functions are not enough to reduce bugs in and of themselves. Another major factor in simplifying reasoning about software is immutable data. As the name implies, immutable data refers to data that does not or cannot change. Since most developers have not worked with immutable data, this module will cover what immutable data is and show how it can help reduce bugs in your code.

Why Functional Programming Matters
Up until now, the focus of the course has been some of the paradigm shifts that developers must take in order to grasp the core concepts of functional programming, but until the previous module, which talked about reducing bugs with immutable data, there likely wasn't a reason why you should be pursuing functional programming. That'll change with this module, as the focus changes from the paradigm shift to some of the applications of functional programming. In my opinion, the following applications are glowing examples of why functional programming will become more and more important, and also why more and more languages are bringing in functional programming concepts.

Where to Go from Here?
My hope is that by this point you've started to see some of the benefits of functional programming. Perhaps it's memoization, parallelism, or reducing the bugs in your code, or maybe those final applications aren't even your primary motivation. You simply like the ability to use small, well-defined pure functions in your code. Whatever it might be, by this time I hope that you're at least excited to start writing more code using functional programming. It's quite possible that even though you've seen things in this course to peek your interest, you don't feel any closer to being productive with functional programming than when you started. This final module will help you get on the right path by looking at the next steps you can take in order to master functional programming.