Learn about functions: what they are, why programmers use them, and where they use them.

Functions

Well done! Functions are a fundamental concept in programming, and learning the basics will serve you wherever your path leads, regardless of language or domain. To review:
* A _function_ is a sequence of instructions that performs a specific task, packaged as a unit. 
* When we _define_ a function, we specify the instructions, inputs, and name of the function. 
* When we _call_ a function, all of its instructions are executed.
* Functions can be executed many times, making its instructions _reusable_.
* Functions can have _parameters_, which accept input values, making its instructions _flexible_.
* Functions organize a program into distinct units, making interchanging and editing them easier. This makes your entire program organized and _modular_.





Review

Instead of giving those instructions for every hamburger, we can group and name them as a single _function:_

```pseudo
function makeHamburger() {
  Add bread
  Add burger patty
  Add pickles
  Add bread
}
```

A function is a named sequence of instructions, packaged as a unit, that performs a specific task.

We've _defined_ the function by giving it instructions and a name, but how do we use it? We use a function by _calling_ it. When we call `makeHamburger()` we expect all of its steps to be executed.


Functions for Reusability

A sandwich wouldn't be complete without fries and dessert!

Here are the instructions to make the complete meal:

* Add bread, Add burger patty, Add fried potatoes, Add pickles, Add bread, Add salt, Add chocolate scoop, Add ketchup, Add vanilla scoop, Add strawberry scoop

Oof. All of the instructions are there, but they're confusing and hard to edit. If you decide to ask for a fruit salad instead of fries, you would have to find all of the fries-related instructions and replace every line. 

To make it easier to read, we'll separate and organize our instructions:

* Add bread, Add burger patty, Add pickles, Add bread

* Add fried potatoes, Add salt, Add ketchup

* Add chocolate scoop, Add vanilla scoop, Add strawberry scoop 

Better... Now let's group these instructions into three functions:

* makeSandwich()
* makeSomeFries()
* makeIceCream()


We can easily substitute one line, `makeSomeFries()`, for a different function, like `makeFruitSalad()`. And if there's an error, we know where to look for the recipe for each part of the meal.

The new instructions are starting to look like a program! By using functions, we made it easier to read, reusable, and _modular:_ each set of related instructions (sandwich, fries, dessert) is grouped into its own function, which we can easily add, remove, and swap to make a diversity of meals.


Functions for organization

Time to get coding! It's okay if you don't recognize all the symbols in this code: we'll walk you through the parts you need to know.

The `makeSandwich()` function is provided in **main.js**. It is defined with two parameters, `topping1` and `topping2`. By reading the instructions inside the function, we can see that it is constructing a string of words that represent the ingredients in the sandwich. For example, the first ingredient is `'bread'`.

Below the function definition, the function is called. When called, the function outputs a string representing a custom sandwich. We say that the function _returns_ a string. The value of that string is stored in the variable `result`.

We've set up the workspace so that the value of `result` is translated to ingredients drawn in the app to the far right. With the below code...
```js
result = makeSandwich('burger patty', 'pickles')
```
...the app will interpret `result` as a bread-patty-pickles-bread sandwich and draw one to the screen.

Putting It All Together

This lesson requires you to know the basics of hamburger-making:
* Place the bread down
* Add the burger patty
* Add the pickles
* Place the bread on top

What if you had to say each step every time you ordered a hamburger? It's tedious. It takes a long time. (How do you fit that on a menu?) And it risks making mistakes.

In this lesson you will learn a solution to that problem: functions. You'll learn how and why they are used in programming and be able to communicate their benefits to other programmers! 

Functions are used throughout programming &mdash; in fact, some styles of programming <a href="https://en.wikipedia.org/wiki/Functional_programming" target="_blank" rel="noopener noreferrer">rely completely on functions</a>. Knowing this information will be useful for anywhere your programming path takes you.

Not everyone wants to eat hamburgers. 

We could write a new function for each new sandwich type, but that takes a lot of work and risks making mistakes. 

Instead, we'll generalize the hamburger function to a sandwich function. This new sandwich function will still make a bread-topping-topping-bread combination, but the toppings may change based on inputs to the function:

```pseudo
function makeSandwich(topping1, topping2) {
  Add bread
  Add topping1
  Add topping2
  Add bread
}
```

We've renamed the function `makeSandwich()` and given it two inputs, or _parameters_. Each time we call the function, we'll give actual values for each input, called _arguments_.

For example, we make a ham-and-cheese sandwich with `makeSandwich("ham", "cheese")`. We call the function with the arguments "ham" and "cheese". Those will be the values for the `topping1` and `topping2` parameters. 

Instead of writing a different function for each type of sandwich, we have one function that can make them all!