In this project, we'll design a single Ruby method to sort large quantities of data in either ascending or descending order.

Ordering Your Library

We noticed in the last lesson that `.sort!` didn't have a built-in way of handling sorting in reverse alphabetical order. Now that we know how to write our own Ruby methods, we can fix that!

What You'll Be Building

Well done! You now have your very own method that adds functionality that Ruby didn't have before.

Building your own methods is great for using code over and over without having to retype things, but it's also great for _abstracting_ or simplifying your program. Once you write `alphabetize`, you don't ever have to think about how it works—you just call it whenever you need it.

You Did It! (For Real This Time)

Let's start with the new bit of code you saw in exercise 1:
```rb
def alphabetize(arr, rev=false)
```
The first part makes sense—we're defining a method, `alphabetize`. We can guess that the first parameter is an array, but what's this `rev=false` business?

What this does is tell Ruby that `alphabetize` has a second parameter, `rev` (for "reverse") that will *default* to `false` if the user doesn't type in two arguments. You might have noticed that our first call to `alphabetize` in exercise 1 was just
```rb
 alphabetize(books)
```
Ruby didn't see a `rev`, so it gave it the default value of `false`.

Default Parameters

Great! Now we need to add the right logic to our method.

```rb
numbers = [1, 2, 3, 4, 5]
numbers.reverse!
puts numbers
```

1. In the example above, we create an array called `numbers`.
2. Then, we reverse the array. Like with `.sort!`, 
the exclamation mark means we modify the actual array.
3. Finally, we print out `5`, `4`, `3`, `2`, and `1`.

Sorting With Control Flow

First, we'll need to define our `alphabetize` method.

Defining Our Method

Great! Now let's add a little logic to our method.

```rb
numbers = [5, 1, 3, 8]
numbers.sort!
puts numbers
```

1. In the above example, we create a new array called `numbers`.
2. Then, we sort the array.
3. Finally, we print out `1`, `3`, `5`, `8`, the sorted array.

In Ruby, there are two sorting methods, `.sort` or `sort!`. The first method, `.sort`, simply returns a sorted array while leaving the original array alone. The second method, `.sort!`, modifies the actual array.