Forem: Dedé Menezes

Parameters VS Arguments with Ruby

Dedé Menezes — Wed, 23 Oct 2024 19:04:27 +0000

In programming, the terms parameter and argument are often used interchangeably, but they have distinct meanings. Understanding the difference is crucial for a developer. Let’s break it down.

Parameters

Parameters are the variables that are listed in the method definition. They act as placeholders for the values that will be passed to the method when it is called.

Example:

def greet(name)
  puts "Hello, #{name}!"
end

In this example, name is a parameter of the greet method. It specifies that the method expects a value to be provided when it is called.

Arguments

Arguments are the actual values that you pass to a method when you call it. These are the concrete instances that replace the parameters defined in the method.

Example:

greet("Alice")

In this line, "Alice" is the argument. When you call greet("Alice"), the argument "Alice" replaces the parameter name in the method definition, allowing the method to execute with that specific value.

Difference between puts and return: A Common Beginner's Confusion

Dedé Menezes — Wed, 23 Oct 2024 16:17:14 +0000

In Ruby, puts and return are two distinct mechanisms used for different purposes. Here's a detailed explanation of the differences between puts and return:

`puts`:

The puts function is used to display information or output to the console. It is primarily used for debugging, providing information to users, or displaying intermediate results during program execution. puts sends the specified values to the standard output (usually the console) and formats them as a string.

def greet(name)
  puts "Hello, " + name + "!"
end

greet("Alice")  # Output: Hello, Alice!

In the example above, the puts function is used to display a greeting message to the console. The output is directly shown on the screen and does not affect the program's control flow or return any value.

`return`:

The return statement is used to exit a function and specify the value that the function should return. It is used to send a computed value back to the caller or to provide the result of a function's operation. When a return statement is encountered, the function terminates and control is passed back to the calling code.

def greet(name)
  return "Hello, " + name + "!"
end

result = greet("Alice")
puts result  # Output: Hello, Alice!

In this example, the greet function takes one parameter and returns the greeting sentence. The returned value is stored in the variable result and can be further used or assigned to other variables.

The key differences between puts and return are:

Purpose: puts is used to display information or output to the console, while return is used to exit a function and provide a result to the calling code.
Effect on Program Flow: puts does not affect the program's control flow; it simply displays the output on the console. On the other hand, return ends the execution of a function and passes control back to the caller.
Value: puts does not produce a value that can be stored or used elsewhere. return explicitly provides a value as the result of a function, allowing it to be used in assignments or as input for other operations.

In summary:

puts is for displaying output, while return is for providing results and controlling the flow of a function. They serve different purposes and should be used according to the desired outcome in your code.

Ruby blocks from the Outside In w\ yield

Dedé Menezes — Thu, 18 Jul 2024 16:54:15 +0000

Ruby programming language if full of blocks. Most of the time we will use blocks but almost never define methods that uses them. So when I sit down to study with a friend I took some time to explain how does it work in the internals.

What is a block?

It can also be called an anonymous method. A method without a name.
Think about this 🤔

def do_your_thing(variable)
  variable.upcase
end

do |variable|
  variable.upcase
end

Okay, okay. It's too different. Instead of def there is a do and instead of () we have ||'s 😅

So, what is the goal with this?

The power on this relies on the fact that block can be passed to methods, including those you define. It is a piece of code, a block of code, bounded to a method. It can also be called in different ways but we won't see any of it in here.

The main point is that we can now pass some extra behaviors to some methods! Cool right?

This is what allows us to have one method called #select and only specify how we want to filter when we CALL the method.

students = ['Bia', 'Samantha', 'Jackie', 'Billie', 'Johnny']
students_with_j = students.select do |student|
  student.start_with?('J')
end
p students_with_j #=> ['Jackie', 'Johnny']

Clever hum? Ruby <3

So, how does it work from Outside In?

Well, let's take a look into a fake #timer example. Here is what we wnat to do ⤵️

# We want to create a method 
# to calculate how long 
# took to perform a task

def timer
  # Obviously we will simulate a very long task ;)
  puts 'Starting task now!'
  # let's get the start time
  start_time = Time.now

  # PERFORMING HUGE TASK!
  puts 'Doing dishes...'
  sleep(3) # proccess sleeps for three seconds
  puts 'Done w\ dishes! zo/'

  # Let's get the end time and calculate the elapsed time
  time_end = Time.now
  elapsed_time = time_end - start_time

  puts "It took us: #{elapsed_time}s"
end

Now, we want to use this method to calculate how long will take to perform another task. In this case, we would need to change the method definition because this new task would take only 0.5 seconds. If we keep changing the method for different tasks then it's better to rename the method hueheuue! this method shoud be called one_point_two_task s😅 Obviously it's a joke

So, how can we make this method CUSTOMIZABLE?!

You got it right! Using a BLOCK!

Yield without parameters

timer do
  # Obviously we will simulate a very long task ;)
  puts 'Starting task now!'
  # let's get the start time
  start_time = Time.now

  # Here I will define what should we do in the task!
  # in our case that is where our sleep(2), sleep(1.2) should be!
  # To run the code inside the block we use the keyword ⤵️
  yield

  # Let's get the end time and calculate the elapsed time
  time_end = Time.now
  elapsed_time = time_end - start_time

  puts "It took us: #{elapsed_time}s"
end

Now, when calling the method, we can specify different tasks to be measured ;)

timer do
  puts 'Cooking lunch...'
  sleep(0.2)
  puts 'Done!'
end

Yield with parameters

Let's create another example, a method to greet someone.

def greet(name)
  "Good morning, #{name}"
end

puts greet('Qin')
puts greet('Pedro')
puts greet('Michael')

What if we want now to be able to greet in different languages? Right now my method can only greet in English. Should we change the method name or make it customizable?

You got it right! We can make it customizable using blocks!

The message now will be defined INSIDE THE BLOCK when calling the method. Like the example below ⤵️

message = greet('Chloe') do |name|
  "Bounjour, #{name.upcase}!"
end
puts message

So to access the name passed as an argument, we need to PASS IT to the yield. Doing that will make it available as the PIPE VARIABLE!

def greet(name)
  yield(name)
end

message = greet('Chloe') do |name|
  "Bounjour, #{name.upcase}!"
end
puts message

Conclusion

Blocks in Ruby are a powerful feature that allow you to add customizable behaviors to your methods. Understanding and utilizing blocks allow you to write more flexible and reusable code. Blocks provide a way to pass additional logic to methods. Keep experimenting with blocks, and you'll discover even more creative ways to enhance your Ruby programs.

That's all folks! I hope you liked it!
Happy coding! :)

Embracing Error Messages in Ruby: A Guide for Beginners

Dedé Menezes — Tue, 30 Jan 2024 18:42:41 +0000

PT-BR

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.

Desenvolvedor comemora nova mensagem de erro

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:

# /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 ⤵️

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:

[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 ''

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 ✌️

Desvendando os mistérios dos erros em Ruby: Um Guia para Iniciantes

Dedé Menezes — Tue, 30 Jan 2024 16:20:29 +0000

EN-US version

Celebrar mensagens de erro pode parecer estranho para muitos, mas no universo da programação, elas são como pistas para desvendar enigmas. Neste artigo, vamos explorar por que os programadores apreciam essas mensagens, como elas podem ser valiosas e, mais importante, como interpretá-las para aprimorar suas habilidades em Ruby.

Desenvolvedor comemora nova mensagem de erro

Embora pareça piada, é assim, como na imagem, que muitos programadores se sentem por trás de cada mensagem de erro obtida, pois sabem que há uma oportunidade de aprendizado. Entender essas mensagens torna-se crucial antes de pensar em correções, e mesmo que no início olhar para o terminal possa parecer chato, a recompensa do entendimento faz valer a pena.

Exemplo prático

Vamos olhar para esse simples script:

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

def cumprimentar(nome)
  puts "Olá, #{name}! Toca ai!\nzo/"
end

cumprimentar('Matsumoto')

Nele definimos um método #cumprimentar e chamamos esse método no final do arquivo. Ao executarmos o script acima, ruby ruby_errors.rb, recebemos a seguinte mensagem de erro ⤵️

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>'

Desmistificando as Mensagens de Erro

Mensagens de erro são verdadeiros guias no caminho da programação, e seu melhor amigo/a/x. Elas contêm informações cruciais como o nome do erro (tipo), uma descrição do problema e o local exato onde o erro ocorreu (nome do arquivo e linha). Aprender a lê-las vai te ensinar muito, ACREDITE! Vejamos abaixo um padrão no formato de como as mensagens são exibidas e entender cada parte:

[nome_do_arquivo.rb]:[LINHA]: in `[CONTEXTO]`: [DESCRIÇÃO] for [CONTEXTO]:[OBJETO] ([TIPO DO ERRO])
[RASTRAMENTO...]

[nome_do_arquivo.rb]: Indica o nome do arquivo Ruby onde o erro foi detectado. Exemplo: ruby_erros.rb
[LINHA]: Representa a linha específica no arquivo onde o erro ocorreu. Exemplo: 2
in [CONTEXTO]: Refere-se ao contexto do erro, geralmente indicando o método ou bloco de código onde o problema foi identificado. Exemplo: in 'my_method'
[DESCRIÇÃO]: Fornece uma descrição do tipo de erro encontrado. Exemplo: undefined local variable or method 'name'
for [CONTEXTO]:[OBJETO]: Indica o contexto e o objeto associado ao erro, ajudando a entender melhor o problema. Exemplo: for main:Object
[STACKTRACE]: Refere-se ao stack trace (rastreamento de pilha), que mostra a sequência de chamadas de métodos até o ponto onde o erro ocorreu. Exemplo: from ruby_errors.rb:5:in '<main>'

O primeiro passo é ler, calmamente, a mensagem de erro. Observar o arquivo e a linha onde o erro ocorreu proporciona contexto. A descrição do erro é como um mapa indicando o problema. Após a leitura, podemos voltar diretamente para a linha do erro ou buscar entender o erro. Sempre vai ser melhor entender o erro do que procurar alguma solução no seu buscador favorito. Os erros vão te ensinar MUITO, acredita!

Nesse caso, observamos que o erro explodiu no arquivo ruby_errors.rb, na linha 2, dentro (no contexto) do método cumprimentar, com a descrição de undefined local variable or method.... Abaixo da sugestão do Ruby DidYouMean, visualizamos o rastreamento de pilha, que mostra o caminho do programa até o erro, from ruby_errors.rb:5:in '<main>'.

Entendendo o Stacktrace

O stacktrace, ou rastreamento de pilha, revela a sequência de execução do código, mostrando a hierarquia de chamadas de método. Entender isso pode ser crucial para identificar a origem de um erro em aplicações maiores. O stacktrace vai nos ajudar a compreender a trajetória do código.

No nosso exemplo, dentro do arquivo ruby_errors.rb, definimos o método #cumprimentar (linhas 1 à 3). Na linha 5, chamamos o método cumprimentar('Matsumoto'). Seguindo a mensagem de erro podemos ver/aprender como Ruby executa um script.

Ao encontrar uma definição de método Ruby guarda o mesmo em memória mas não executa nada até o método ser chamado, o que só acontece na linha 5. Por isso temos from ruby_errors.rb:5 no rastreamento mas o erro propriamente dito, só foi encontrado dentro do método, na linha 2 ruby_errors.rb:2:in [...]

Conclusão

Na próxima vez que se deparar com uma mensagem de erro em Ruby, lembre-se de comemorar. Ela é uma aliada valiosa na jornada da programação, oferecendo insights que podem transformar desafios em oportunidades de aprendizado. Lembre-se das boas práticas, analise as mensagens com cuidado e, antes que perceba, você estará desvendando os mistérios dos erros em Ruby com confiança.

TheBoyWhoLivedAPI - RESTful Harry Potter API

Dedé Menezes — Fri, 15 Jul 2022 19:24:36 +0000

A few weeks ago I released theboywholivedapi.

Everything scraped from HarryPotterWiki.

At the moment you can play with Books, Characters, Wands, Species, Houses and House Members

Source code

Real Time total price with Stimulus

Dedé Menezes — Fri, 03 Jun 2022 03:24:06 +0000

Feature: When the user change the booking date it should update the total price in real time

Steps:

Create Stimlus Controller
Listen to change event on all date inputs
Build date from the inputs field values
Call getTime() on the generated dates
Subtracts start from end
Transform milliseconds into days
Multiply days by price
Display the total price in the browser

Here is the simple_form_for basic structure. There is one new field to display the total price. It was added using the same style as simple_form_for inputs.

<%= simple_form_for([@starship, @booking]) do |f| %>
  <%= f.input :start_date, as: :date, order: [ :day, :month, :year ] %>
  <%= f.input :end_date, as: :date, order: [ :day, :month, :year ] %>
  <div class="mb-3 string">
    <label for="total-price" class='form-label'>Total price</label>
    <p class='form-control'name="total-price" id="totalPrice" data-total-price-target='input'></p>
  </div>
  <%= f.submit class: 'btn btn-primary' %>
<% end %>

First thing we need to do is create the stimulus controller responsible for this behaviour.

touch app/javascript/controllers/total_price_controller.js

Everything will happen in between the form tags. The inputs we need and the tag which we will display the total price are inside the form tags. We should bind our controller to the form opening tag.

<%= simple_form_for([@starship, @booking], data: { controller:"total-price" }) do |f| %>

Make sure your controller is connected

import { Controller } from "stimulus"

export default class extends Controller {
  connect() {
    console.log('Hi from total price stimulus controller!\nzo/')
  }
}

Now, let's listen to the changes on all the dates input fields. In stimulus we use ACTION to bind "microphones" into elements. Here we go:

<%= f.input :start_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { action: 'change->total-price#calculate'} } %>
<%= f.input :end_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { action: 'change->total-price#calculate'} } %>

Make sure your controller is listening to all events

import { Controller } from "stimulus"

export default class extends Controller {
  connect() {
  }

  calculate(event) {
    console.log(event)
  }
}

To calculate the difference in days and get the total price we must build dates using all three input fields values(day, month, year).

Using Date objects we can make the math.

Stimulus makes really easy to retrive HTML elements from the DOM by just creating TARGETS. We can just add data-controller-name-target='TARGETNAME' into our html tag and then we can reference to them all inside our Stimulus Controller.

<%= f.input :start_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { total_price_target: 'startDate', action: 'change->total-price#calculate'} } %>
<%= f.input :end_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { total_price_target: 'endDate', action: 'change->total-price#calculate'} } %>

Make sure all inputs are targets

import { Controller } from "stimulus"

export default class extends Controller {
  static targets = [ 'startDate', 'endDate', 'input']

  connect() {
    console.log(this.startDateTargets)
    console.log(this.endDateTargets)
  }

  calculate() {
  }
}

Let's build dates from those inputs

  // [...]
  calculate() {
    const begin = this.#retriveDateInputAsDate(this.startDateTargets)
    const end = this.#retriveDateInputAsDate(this.endDateTargets)
  }

  #retriveDateInputAsDate(targets) {
    const dateInputs = targets.map((target) => {
      parseInt(target.value, 10)
    })

    return new Date(dateInputs[2], dateInputs[1] - 1, dateInputs[0])
  }
  // [...]

We can now do our math. Let's get the difference in days.

  // [...]

  calculate() {
    // [...]

    const days = this.#dateDifferenceInDays(begin, end)
  }

  #dateDifferenceInDays() {
    const difference = this.end.getTime() - this.begin.getTime();
    return (Math.floor(difference) / (1000 * 60 * 60 * 24))
  }
  // [...]

Now that we have the difference between the start date and the end date in days we can simply multiply by the price per day of our ship. We don't have access to our lovely starship.price method inside our .js files. We need to send this information from the server to the JS part of our application.

How??

Using our own HTML.

Again, Stimulus make easy to retrive values inside your Javascript controller. You can just add the data-controller-name-value-name-value="ACTUAL VALUE YOU WANT TO USE IN THE JS CONTROLLER". We can then reference to them inside our Stimulus Controller using the same syntax as TARGETS. this.valueNameValue

<%= simple_form_for([@starship, @booking], data: { controller:"total-price", total_price_price_value: @starship.price }) do |f| %>

  static values = {
    price: Number
  }
  calculate() {
    // [...]
    const totalPrice = this.priceValue * days
  }
  // [...]

Our last step is to display the total price into the desired place.

Let's add our data target attribute to the HTML element and add the brand new total price we just generated

<p class='form-control'name="total-price" id="totalPrice" data-total-price-target='input'></p>

this.inputTarget.innerText = totalPrice / 100

You should end with something like this, if you didn't adapt anything.

FORM INSIDE YOUR VIEW

<%= simple_form_for([@starship, @booking], data: { controller:"total-price", total_price_price_value: @starship.price }) do |f| %>
  <%= f.input :start_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { total_price_target: 'startDate', action: 'change->total-price#calculate'} } %>
  <%= f.input :end_date, as: :date, order: [ :day, :month, :year ], input_html: { data: { total_price_target: 'endDate', action: 'change->total-price#calculate'} } %>
  <div class="mb-3 string">
    <label for="total-price" class='form-label'>Total price</label>
    <p class='form-control'name="total-price" id="totalPrice" data-total-price-target='input'></p>
  </div>
  <%= f.submit class: 'btn btn-primary' %>
<% end %>

TOTAL PRICE STIMULUS CONTROLLER

import { Controller } from "stimulus"

export default class extends Controller {
  static targets = [ 'startDate', 'endDate', 'input']
  static values = {
    price: Number
  }
  connect() {
    this.calculate()
  }

  calculate() {
    this.begin = this.#retriveDateInputAsDate(this.startDateTargets)
    this.end = this.#retriveDateInputAsDate(this.endDateTargets)

    const days = this.#dateDifferenceInDays(begin, end)
    const totalPrice = this.priceValue * days
    this.inputTarget.innerText = totalPrice / 100
  }

  #retriveDateInputAsDate(targets) {
    const dateInputs = targets.map(target => parseInt(target.value, 10))
    return new Date(dateInputs[2], dateInputs[1] - 1, dateInputs[0])
  }

  #dateDifferenceInDays() {
    const difference = this.end.getTime() - this.begin.getTime();
    return (Math.floor(difference) / (1000 * 60 * 60 * 24))
  }
}

Forem: Dedé Menezes

Parameters VS Arguments with Ruby

Parameters

Arguments

Difference between puts and return: A Common Beginner's Confusion

puts:

return:

The key differences between puts and return are:

In summary:

Ruby blocks from the Outside In w\ yield

What is a block?

So, what is the goal with this?

So, how does it work from Outside In?

So, how can we make this method CUSTOMIZABLE?!

Yield without parameters

Yield with parameters

Conclusion

Embracing Error Messages in Ruby: A Guide for Beginners

Practical example

Demystifying Error Messages

Understanding the Stacktrace

Conclusion

Desvendando os mistérios dos erros em Ruby: Um Guia para Iniciantes

Exemplo prático

Desmistificando as Mensagens de Erro

Entendendo o Stacktrace

Conclusão

TheBoyWhoLivedAPI - RESTful Harry Potter API

Real Time total price with Stimulus

Feature: When the user change the booking date it should update the total price in real time

Steps:

FORM INSIDE YOUR VIEW

TOTAL PRICE STIMULUS CONTROLLER

`puts`:

`return`: