Here I've created another file named temp.rb that contains some new Ruby code.

Lines 1, 2, and 3 display a message that we're waiting, pause for

3 seconds, and then print another message that we're done waiting.

Lines 4, 5, and 6 count from 1 to 3.

These are two separate tasks in the same program, but it's hard to tell at a glance

which lines belong to which task, or what task they're supposed to be doing.

It's easy to define your own methods in Ruby.

You start with the def keyword, short for

define, followed by the name of the method you want.

So let's create a new method here named wait.

And next we're going to need a method body, that's one or

more lines of code that will be run when the method is called.

The lines of a method body are usually indented to make it clear that they're

part of the method, although this isn't required by the Ruby interpreter itself.

But it's a very common standard practice.

I would definitely recommend indenting your method lines.

So we're just going to take these first three lines of existing code and

put them inside a wait method.

The end of the method is marked by the end keyword.

And the end keyword should be aligned with the def keyword at the start of

the method.

So we'll convert those first three lines of code to a wait method.

And now let's define a count_to_three method to hold the remaining code.

We'll just take those existing lines of code and

indent them to form the body of the second method.

And again, we'll end the method with the end keyword.

You don't get to use just any character you want in a method name.

Generally speaking, method names should be all lowercase.

You can add numbers into them, but those are rarely used, so try to avoid that.

If there are multiple words in your method name,

you should separate them with underscore characters.

This style is called snake case,

because it makes the name look like it's crawling on the ground.

Now that we've defined the methods, we need to call them so

that they're actually executed.

We do that just like we did the predefined methods,

we simply type the name of the method to call it.

So count_to_three will call the count_to_three method that we've defined,

and wait will call the wait method that we've defined.

Let's hit Command + S to save that, Ctrl + S if you're on Windows.

And click down in the console area to try running it again.

Up arrow to bring up the previous command.

And you can see that our call to count_to_three causes the count_to_three

method to run and print the numbers 1, 2 and 3.

And then the call to wait causes the wait method to run and print the message,

waiting, then sleep for 3 seconds, and then print the message, done.

We can call a method during a program as many times as we want.

So let's add a couple additional calls to count_to_three down here.

I'll just copy the first call and paste it in a couple more times, save my work.

And re-run it from the console.

And you can see that it calls count_to_three once.

It calls wait once and then it calls count_to_three two more times down here.

Now that we understand method calls a little bit better,

let's go back to our widgets.rb file by clicking on it here on the side bar.

And let's implement our welcome message to the user.

We can do that with the single call to the puts method.

We'll pass it a string with the message, Welcome to the widget store!,

close the string with a pair of double quotes and save that.

And then click down here in the console to run it.

We do that with ruby widgets.rb.

And you can see that it prints our welcome to the widget store message.

Our program is displaying a welcome message to the user.

We can cross the first requirement off our list.