Okay, let's see if we can set some ground rules and pick up a couple of

theoretical concepts before we get into the nitty gritty of writing code.

The first two are pretty straightforward.

Computation is the evaluation of functions.

This means that we do our work computing values and outcomes all in functions.

We'll try to keep as much of our work inside of discrete functions as possible.

To me, this is easiest to think of as math.

When we're just talking about it, we take two and combine it with another two, and

we get four.

But in programming we'd be using an add function that takes

at least two arguments.

That function then sends back the four.

So our computation was done by evaluating the add function.

This ties neatly into our next rule.

Programming is done with expressions.

We do our work by using expressions,

passing the output of one function into another, either through chaining or

by assigning the output to a variable and then using that variable.

Again, we can go back to math.

If we have an equation of 5 minus 3 times 2, that of course has subtraction and

multiplication in it.

And according to the order of operations in math, we do the multiplication and

use its resulting value in the subtraction to get us our answer of minus 1.

And just like doing the same math problem over and over again will

always get you the same answer, we should have no side effects from computation.

We don't want to change values that are outside of our function's scope.

We have to be careful with this when we're using mutable types like lists and

dictionaries.

Eliminating side effects means that we can run a function with the same

inputs multiple times and nothing else, no other inputs or

values anywhere in the stack will change.

It also means that we can more easily predict the state of the entire program

at any point in time.

Functions are first-class citizens.

In Python, functions can be provided as an argument to a function call or

returned from a function.

Since functions are usable as values just like variables are,

they're considered to be first-class.

To get the most out of functional programming,

a language needs to be able to do more with functions than just call them.

Being able to chain functions together, take functions as arguments, and

return functions as values gives us some fluidity to how we solve a problem.

Functions should be limited in scope and functionality.

We want to make sure our functions have a well-defined purpose.

We want them to achieve a single task and then give us the answer from that task.

By limiting the scope, or amount of data that a function has, and

the functionality of the function, we can keep our code clean, small, and

effective, all great things.

Okay, the next video will actually get us some practice

to go along with all this theory.

I'll see you there in a bit.