Embracing Error Messages in Ruby: A Guide for Beginners
Tags: ruby, programming, beginners
Published: 2024-01-30 18:42:41

[PT-BR](https://dev.to/dedemenezes_/desvendando-os-misterios-dos-erros-em-ruby-um-guia-para-iniciantes-2chp)

Celebrating error messages might seem odd to many, but in the programming universe, they're like clues to solving mysteries. In this article, let's dive into why programmers value these messages, how they can be precious, and, most importantly, how to interpret them to level up your Ruby skills.

<figure class="image">
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/of153dkyjgc09v2ycy0t.jpg" alt="Desenvolvedor comemora nova mensagem de erro" style="margin-bottom: 0;">
  <figcaption>Desenvolvedor comemora nova mensagem de erro</figcaption>
</figure>

Although it may seem like a joke, this is how many programmers feel behind each error message because they know there's an opportunity for learning. Understanding these messages becomes crucial before thinking about corrections. Even if, initially, looking at the terminal might seem dull, the reward of understanding makes it worthwhile.

### Practical example

Let's take a look a this script below:

```ruby
# /home/***/***/dedemenezes/dedev-lab-blog/ruby_errors.rb

def greet(name)
  puts "Hello, #{name}! High five! zo/"
end

greet('Matsumoto')
```

In it, we define a method `#greet`. At the end of the file, we call it. When we execute the script above, `ruby ruby_errors.rb`, we receive the following error message ⤵️

```zsh
ruby_errors.rb:2:in `cumprimentar': undefined local variable or method `name' for main:Object (NameError)
Did you mean?  nome
        from ruby_errors.rb:5:in `<main>'
```

### Demystifying Error Messages


Error messages are true guides *(any True Soul here?)* on the path of programming, and your best friend. They contain crucial information like the error name (type), a description about the problem, and the exact location where the error occurred (file name and line). Learning to read them will teach you a lot, TRUST ME! Let's look at the pattern used to format how these messages are displayed and understand each part:

```shell
[file_name.rb]:[LINE]: in `[CONTEXT]`: [DESCRIPTION] for [CONTEXT]:[OBJCET] ([ERRO NAME/TYPE])
[STACKTRACE]
```

- **[file_name.rb]:** Indicates the name of the Ruby file where the error was detected. Example: ruby_errors.rb

- **[LINE]:** Represents the specific line in the file where the error occurred. Example: 2

- *in* **[CONTEXT]:** Refers to the context of the error, usually indicating the method or code block where the problem was identified. Example: in 'my_method'

- **[DESCRIPTION]:** Provides a description of the type of error encountered. Example: undefined local variable or method 'name'

- *for* **[CONTEXT]:[OBJECT]:** Indicates the context and the object associated with the error, helping to better understand the problem. Example: for main:Object

- **[STACKTRACE]:** Refers to the stack trace, which shows the sequence of method calls up to the point where the error occurred. Example: from ruby_errors.rb:5:in '<main>'

The first step is to read, **calmly**, the error message. Observing the file and the line where the error occurred provides context. The error description is like a map indicating the problem. After reading, we can go directly back to the error line or try to understand the error. It's always **better to understand the error** than search for a solution on your favorite search engine. Errors will teach you **A LOT**, believe it!

In this case, we observe that the error happened in the file `ruby_errors.rb`, at line `2`, within (in the context of) the `greet` method, with the description of `undefined local variable or method....` Below the Ruby's *DidYouMean* suggestion, we can see the stack trace, which shows the path of the program to the error, `from ruby_errors.rb:5:in '<main>'`.

### Understanding the Stacktrace

The stacktrace reveals the execution sequence of the code, showing the hierarchy of method calls. Understanding this can be crucial to identify the origin of an error in larger applications. The stacktrace will help us comprehend the code's trajectory.

In our example, within the `ruby_errors.rb` file, we defined the `#greet` method (lines 1 to 3). In line 5, we called the `cumprimentar('Matsumoto')` method. Following the error message, we can see/learn how Ruby executes a script.

When Ruby encounters a method definition, it stores it in memory but **does not execute anything until the method is called**, which only happens in line 5. Hence, we have from `ruby_errors.rb:5` in the stacktrace, but **the error itself** was only found within the method, at line 2 `ruby_errors.rb:2:in [...]`.

### Conclusion

The next time you come across an error message in Ruby, read it. It is a valuable ally in the programming journey, providing insights that can turn challenges into learning opportunities. Remember best practices, analyze the messages carefully, and before you know it, you'll be unraveling the mysteries of errors in Ruby with confidence.

Thank you for reading ✌️