Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


This tutorial will introduce you to Ruby, an object-oriented scripting language you can use on its own or as part of the Ruby on Rails web framework.

Introduction to Ruby

Methods are summoned using a `.`. If you have a string, `"I love espresso"`, and take the `.length` of it, Ruby will return the length of the string (that is, the number of characters—letters, numbers, spaces, and symbols). Check it out:
```rb
"I love espresso".length
# ==> 15 
```

(That little line starting with the `#` isn't part of what you need to write—it just shows you the output Ruby will provide. More on this in the next section!)

Taking the length of input can be useful if, for example, you want to make a website that takes credit card payments. Ruby can check to make sure the credit card number appears to be valid.

The '.length' Method

The `print` command just takes whatever you give it and prints it to the screen. `puts` (for "put string") is slightly different: it adds a new (blank) line after the thing you want it to print. You use them like this:
```rb
puts "What's up?"
print "Oxnard Montalvo"
```
No parentheses or semicolons needed!

'puts' and 'print'

Let's try one more method (er, *two* methods). As you might have guessed, the `.upcase` and `.downcase` methods convert a string to ALL UPPER CASE or all lower case, respectively.

'.upcase' & '.downcase'

In Ruby, your information (or data) can come in different types. There are three **data types** in Ruby that we're interested in right now: **Numeric** (any number), **Boolean** (which can be true or false), and **String** (words or phrases like `"I'm learning Ruby!"`).

Computer programs exist to quickly analyze and manipulate data. For that reason, it's important for us to understand the different data types that we can use in our programs.

Reminder: never use quotation marks (' or ") with booleans, or Ruby will think you're talking about a string (a word or phrase) instead of a value that can be true or false. It's also important to remember that Ruby is case-sensitive (it cares about capitalization).

Data Types: Numbers, Strings, Booleans

One of the most basic concepts in computer programming is the **variable**. You can think of a variable as a word or name that grasps a single value. For example, let's say you needed the number 25 from our last example, but you're not going to use it right away. You can set a variable, say `my_num`, to grasp the value 25 and hang onto it for later use, like this:
```rb
my_num = 25
```
Declaring variables in Ruby is easy: you just write out a name like `my_num`, use `=` to assign it a value, and you're done! If you need to change a variable, no sweat: just type it again and hit `=` to assign it a new value.

Variables

Well done! Let's do a little review of string methods. Remember, you call a method by using the `.` operator, like this: `"string".method`.

Strings and String Methods

There are many different kinds of variables you'll encounter as you progress through these courses, but right now we're just concerned with regular old **local variables**. By convention, these variables should start with a lowercase letter and words should be separated by underscores, like `counter` and `masterful_method`. Ruby won't stop you from starting your local variables with other symbols, such as capital letters, `$`s, or `@`s, but by convention these mean different things, so it's best to avoid confusion by doing what the Ruby community does.

Naming Conventions

Ruby isn't limited to simple expressions of assignment like `my_num = 100`; it can also do all the math you learned about in school.

There are six arithmetic operators we're going to focus on:

Addition (`+`)

Subtraction (`-`)

Multiplication (`*`)

Division (`/`)

Exponentiation (`**`)

Modulo (`%`)

The only ones that probably look weird to you are exponentiation and modulo. Exponentiation raises one number (the base) to the power of the other (the exponent). For example, `2**3` is `8`, since `2**3` means "give me `2 * 2 * 2`" (2 multiplied together 3 times). `3**2` is `9` (3 * 3), and so on.

Modulo returns the remainder of division. For example, `25 % 7` would be `4`, since 7 goes into 25 three times with 4 left over.

Math

Great work! For our last review exercise for this lesson, let's go over single- and multi-line comments.

Comments

You can write a comment that spans multiple lines by starting each line with a `#`, but there's an easier way. If you start with `=begin` and end with `=end`, *everything* between those two expressions will be a comment. Take a look at this example:
```rb
=begin
I'm a comment!
I don't need any # symbols.
=end
```
Don't put any space between the `=` sign and the words `begin` or `end`. You can do that with math (`2 + 5` is the same as `2+5`), but in this case, Ruby will get confused. `=begin` and `=end` also need to be on lines all by themselves, just as shown above.

Multi-Line Comments

Ruby is a powerful, flexible programming language you can use in web/Internet development, to process text, to create games, and as part of the popular Ruby on Rails web framework. Ruby is:

* **High-level**, meaning reading and writing Ruby is really easy—it looks a lot like regular English!

* **Interpreted**, meaning you don't need a compiler to write and run Ruby. You can write it here at Codecademy or even on your own computer (many are shipped with the Ruby interpreter built in—we'll get to the interpreter later in this lesson).

* **Object-oriented**, meaning it allows users to manipulate data structures called objects in order to build and execute programs. We'll learn more about objects later, but for now, all you need to know is *everything* in Ruby is an object.

* **Easy to use**. Ruby was designed by Yukihiro Matsumoto (often just called "Matz") in 1995. Matz set out to design a language that emphasized human needs over those of the computer, which is why Ruby is so easy to pick up.

This course assumes no previous knowledge of Ruby in particular or programming/computer science in general.

Overview & Sneak Peek

Because everything in Ruby is an object (more on this later), everything in Ruby has certain built-in abilities called **methods**. You can think of methods as "skills" that certain objects have. For instance, strings (words or phrases) have built-in methods that can tell you the length of the string, reverse the string, and more.

We also promised to tell you more about the **interpreter**. The interpreter is the program that takes the code you write and runs it. You type code in the **editor**, the interpreter reads your code, and it shows you the result of running your code in the **console**.

Everything in Ruby is an Object

You probably saw us use the `#` sign a few times in earlier exercises. The `#` sign is for **comments** in Ruby. A comment is a bit of text that Ruby won't try to run as code: it's just for humans to read. Writing good comments not only clarifies your code for other people who may read it, but helps remind you of what you were doing when you wrote the code days, months, or even years earlier.

The `#` sign should come before your comment and affects anything you write after it, so long as you're on a single line. (We'll show you how to do multi-line comments in a second.) Check out these examples:
```rb
# I'm a full line comment!
"Eric".length # I'm a comment, too!
```
The second example will return `4`, since the comment comes after the code that Ruby will execute.

Single-Line Comments

Let's quickly review how to declare and set variables. Remember, you declare a variable just by saying its name, and you set it using `=`. You can always check the **Hint** below if you need more help.

Variables & Data Types

The `.reverse` method is called the same way `.length` is, but instead of asking Ruby to tell you how long a string is, it spits out a backwards version of the string you gave it. For instance,
```rb
"Eric".reverse
```
will result in
```rb
"cirE"
```
Reversing input can be useful if you want to sort a list of values from highest to lowest instead of lowest to highest. (We'll get to sorting in later lessons.)