In this lesson, we'll cover how to define our own methods in Ruby, as well as how to use blocks to develop powerful sorting algorithms.

Methods, Blocks, & Sorting

Defining a method is great, but it's not much use to you unless you _call_ it, or tell your program to execute it. For example, if you call a method called `cartoon_fox`, the program will start looking for the method with that name and try to execute the code inside it. 

If the program doesn't find a method called `cartoon_fox`, it will return a `NameError`. We'll cover errors in another lesson.

You call a method just by typing its name. Remember when you saw us type `puts_1_to_10` or `greeting` after our method definition in the last two exercises? That was us calling our methods!

Call It!

What if we wanted to sort the books by title, but from Z – A, or descending order? It appears that Ruby's sort method only works for A – Z, or ascending order. 

The `sort` method assumes by default that you want to sort in ascending order, but it accepts a block as an optional argument that allows you, the programmer, to specify how two items should be compared.

Getting Technical

Most methods that you've worked with have defined names that either you or someone else gave them (*i.e.* [array].sort(), "string".downcase(), and so on). You can think of blocks as a way of creating methods that don't have a name. (These are similar to anonymous functions in JavaScript or lambdas in Python.)

Blocks can be defined with either the keywords `do` and `end` or with curly braces (`{}`).

Blocks Are Like Nameless Methods

There are some differences between blocks and methods, however.

Check out the code in the editor. The `capitalize` method capitalizes a word, and we can continually invoke the `capitalize` method by name. We can `capitalize("matz")`, `capitalize("eduardo")`, or any string we like to our hearts' content.

However, the block that we define (following `.each`) will only be called *once*, and in the context of the array that we are iterating over. It appears just long enough to do some work for `each`, then vanishes into the night.

How Blocks Differ from Methods

Let's go over what we learned about blocks.

```rb
numbers = [5, 2, 8]
sum = 0
numbers.each do |n|
  sum += n
end
puts sum
```

The example above is just a reminder about syntax. We calculate the sum of a list of numbers.

Blocks

Methods are defined using the keyword `def` (short for "`def`ine"). Methods have three parts:

1. The _header_, which includes the `def` keyword, the name of the method, and any _arguments_ the method takes. (We'll get to arguments in the next section)
2. The _body_, which is the code block that describes the procedures the method carries out. The body is indented two spaces by convention (as with `for`, `if`, `elsif`, and `else` statements)
3. The method ends with the `end` keyword.

Here's an example of what the syntax would look like for a simple function, `welcome`, that just prints "Welcome to Ruby!" to the console:
```rb
def welcome
  puts "Welcome to Ruby!"
end
```

Method Syntax

You won't become a Master Method Maker 'til you make a mess of methods. (Say *that* three times fast.)

```rb
def by_five?(n)
  return n % 5 == 0
end
```

The example above is just a reminder of how to define a method.

Practice Makes Perfect

We can also use a new operator called the _combined comparison operator_ to compare two Ruby objects. The combined comparison operator looks like this: `<=>`. It returns `0` if the first _operand_ (item to be compared) equals the second, `1` if the first operand is greater than the second, and `-1` if the first operand is less than the second.

A block that is passed into the `sort` method must return either`1`, `0`,  or `-1`. It should return -1 if the first block parameter should come before the second, `1` if vice versa, and `0` if they are of equal weight, meaning one does not come before the other (*i.e.* if two values are equal)

The Combined Comparison Operator

Finally, let's review what we learned about sorting.

```rb
books.sort! do |firstBook, secondBook|
  firstBook <=> secondBook
end
```

Remember that the above example was how we sorted in alphabetical order.

Sorting

Now it's time for you to build your own method. Remember, the syntax looks like this:
```rb
def method_name
  # Do something!
end
```

Create Your Own

If a method takes arguments, we say it _accepts_ or _expects_ those arguments. We might define a function, `square`, like so:
```rb
def square(n)
  puts n ** 2
end
```

and call it like this:
```rb
square(12)
# ==> prints "144"
```
The _argument_ is the piece of code you actually put between the method's parentheses when you call it, and the _parameter_ is the name you put between the method's parentheses when you _define_ it. For instance, when we defined `square` above, we gave it the parameter `n` (for "number") and passed it the argument `12` when we called it.

You can think of parameters as placeholders the method definition gives to arguments since it doesn't know ahead of time exactly what argument it's going to get.

Parentheses are usually optional in Ruby, but it's a good idea to put your parameters and arguments in parentheses for readability.

Parameters and Arguments

A method can take a block as a parameter. That's what `.each` has been doing this whole time: taking a block as a parameter and doing stuff with it! You just didn't notice because we didn't use the optional parentheses. We are sneaky.

Passing a block to a method is a great way of _abstracting_ certain tasks from the method and defining those tasks when we call the method. Abstraction is an important idea in computer science, and you can think of it as meaning "making something simpler." Imagine if when you wanted to house hunt, you had to say, "Honey, let's go look at configurations of concrete, plywood, and vinyl siding." That'd be crazy! Just like saying "house" simplifies listing its components, using a block to define the task you want the method (like `.each`) to do simplifies the task at hand.

Using Code Blocks

A **method** is a reusable section of code written to perform a specific task in a program. You might be wondering why you need to separate your code into methods, rather than just writing everything out in one big chunk. It turns out there are a few good reasons to divide your programs into methods:

1. If something goes wrong in your code, it's much easier to find and fix bugs if you've organized your program well. Assigning specific tasks to separate methods helps with this organization.

2. By assigning specific tasks to separate methods (an idea computer scientists call **separation of concerns**), you make your program less redundant and your code more reusable—not only can you repeatedly use the same method in a single program without rewriting it each time, but you can even use that method in *another* program.

3. When we learn more about **objects**, you'll find out there are a lot of interesting things we can do with methods in Ruby.

Why Methods?

Let's quickly review how to create a basic Ruby method.

```rb
def double(n)
  return n * 2
end
```

The example above is just a syntax reminder.

Basic Methods

Sorting arrays is a very common problem in computer science, and is well studied for that reason. There are many _algorithms_ —well-defined sequences of steps—each with its own trade-offs and advantages.

Sorting algorithms can be a great introduction to computer science as a theoretical discipline, but for now we'll focus on how to use Ruby's built-in sorting library (which implements a few of these algorithms).

Introduction to Sorting

Good! Now let's make our method a bit more complex by adding arguments and a `return` statement.

```rb
def double(n)
  return n * 2
end
```

Methods With Arguments

If we were to hand you five books and ask you to arrange them, sorted by title, on a shelf, how would you do it?

Most sorting algorithms assume we are sorting an array of items, which involves comparing any two items in the array and deciding which should come first.

For our books example, if for any pair we always chose the book whose title came first in the alphabet, we could devise a strategy for sorting. These "strategies" are the sorting algorithms mentioned in the previous example. Our job is to decide how to compare two items in the list, and let Ruby decide which strategy to use.

Foundations

Sometimes we don't just want a method to print something to the console, but we actually want that method to hand us (or another method!) back a value. For that, we use `return`.

```rb
def double(n)
  return n * 2
end

output = double(6)
output += 2
puts output
```

1. In the example above, we define a new method called `double` that accepts one parameter called `n`.
2. Inside the method, we return two times `n`.
3. After that, we call our new `double` method with an argument of `6` and store the result, `12`, in `output`.
4. Then, we increase `output` to 14 and print it out to the console.

Let's Learn Return

Speaking of not knowing what to expect...

Methods don't know what arguments they are going to receive. Occasionally, methods don't even know how many arguments will be passed into them.

Let's say you have a method, `friend`, that `puts` the argument it receives from the user. It might look something like this:
```rb
def friend(name):
  puts "My friend is " + name + "."
end
```
This is great for just one friend, but what if you want to print out the all of the user's friends without knowing how many names will be provided?

The solution: _splat arguments_. Splat arguments are arguments preceded by an asterisk `*`. This tells the program that the method can receive one or more arguments. 