DEV Community: Odinei Ramone

A filosofia coletiva no processo de desenvolvimento de software da Plataformatec

Odinei Ramone — Thu, 27 Apr 2023 11:32:05 +0000

Estava numa reunião de chapter do backend na empresa que trabalho atualmente e eu fui apresentado aos meus colegas backenders. A pessoa que me apresentou informou aos presentes que eu já tinha trabalhado na Plataformatec.

Logo após essa informação, um dos presentes disse algo como "o pessoal da Plataformatec manja muito. Qualquer coisa eles nem codam Elixir, já mexem lá no binário e tal" e isso meio que me incomodou um pouco porque não gosto muito quando pensam que as pessoas na Plataformatec eram muito boas apenas individualmente.

Não me leve a mal, nós éramos sim pessoas programadoras muito boas individualmente mas o nosso "ás na manga" era o poder do coletivo. Aproveitei a deixa para contar para as pessoas presentes como que a força da Plataformatec vinha do coletivo.

Por incontáveis vezes trazíamos um problema de clientes e discutíamos soluções entre duas, três, quatro pessoas. Muitas vezes de diferentes clientes, sempre com diferentes backgrounds e, de repente, a gente tinha uma solução criada a seis, oito, ou até dez mãos!

O cliente via apenas uma unidade de pessoa indo com um problema e voltando com uma solução e isso passava a impressão, eu acho, de que a gente era individualmente muito bom.

Mas, na verdade, a gente era muito melhor trabalhando em equipe!

Isso era bem legal porque a gente aprendia muito. Tudo isso acontecia no meio do escritório e tinha participação de várias pessoas e, mesmo se alguém não participasse da discussão em si, escutava e aprendia. E a gente tinha um ambiente horizontal o suficiente para as pessoas se sentirem a vontade de dar a sua opinião ou expôr sua duvida independente do nível técnico.

Ainda hoje eu estava vendo um corte do João Carvalho no podcast Desce a Letra Show onde ele fala a frase "O indivíduo floresce quando o individualismo morre" da pedagoga russa Nadejda Krupiskaia e essa citação cai como uma luva nessa característica da Plataformatec.

Nós não éramos indivíduos tentando fazer a melhor solução de forma individual. Nós éramos um coletivo tentando fazer a melhor solução de forma coletiva. E plantávamos e colhíamos os frutos disso como um coletivo. E ainda documentávamos tudo e deixar salvo para consultas futuras, o que gerou uma quantidade enorme de posts no blog da empresa.

Saudades Plataformatec ❤️

Equipe da Plataformatec em Fevereiro de 2019

Como fazer um café gostoso (na minha humilde opinião)

Odinei Ramone — Mon, 20 Jun 2022 20:45:30 +0000

Estava no twitter hoje quando me deparei com essa pergunta:

// Detect dark theme var iframe = document.getElementById('tweet-1538935102956249092-705'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1538935102956249092&theme=dark" }

@limowreckk: alguém me ensina a fazer um café gostoso? (de vdd sério)

Eu aprendi a fazer café quando trabalhei na Plataformatec e, modéstia a parte, minha mãe gosta muito do meu café.

Respondi a Júlia numa thread mas quis escrever um texto sobre isso para poder compartilhar com mais pessoas de um jeito mais fácil.

Agora, sem mais delongas, vamo fazer um cafézinho?

// Detect dark theme var iframe = document.getElementById('tweet-986311060931186689-596'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=986311060931186689&theme=dark" }

Ciclope dos X-Men diz "Ai que café gostoso" enquanto saboreia um delicioso cafézinho.

Como escolher um bom café?

Embora você possa seguir todo o texto usando o café tradicional da sua preferência, eu encorajo você a procurar um café de mais qualidade. Qualquer café escrito especial ou gourmet na embalagem já é melhor que os cafés tradicionais.

Sendo bem breve na diferença, os cafés tradicionais encontrados no mercado são torrados com várias "impurezas" como folhas e galhos. E para uniformizar o sabor, as marcas costumam torrar muito o café deixando ele muito escuro e amargo.

Cafés especiais e gourmet usam apenas grãos de café na sua torra além de poderem ser encontrados em torras mais escuras e mais claras.

Uma opção que eu gosto muito e é relativamente fácil de encontrar são os cafés da linha Rituais da Três Corações. O meu preferido é o Mogiana Paulista.

Caso você queira algo mais especial, recomendo muito também os cafés do Por Um Punhado de Dólares. O meu preferido deles é o Fuck Coffee.

Cafés especiais costumam ser um pouquinho mais caros que os cafés tradicionais mas vale muito pagar um pouco mais caro pela qualidade e sabor. E com o café tradicional, caro como está (obrigado presida!) a diferença de preço nem é tanta assim.

Utensílios utilmente úteis

Existem uma quase infinidade de formas de fazer o café mas aqui vamos ser simples. Um coador de plástico Melitta e filtros de papel darão conta do recado.

(inclusive, uma dica para o texto: sempre que eu falar "coador" eu estou me referindo ao suporte de plástico para o filtro e quando eu falar "filtro" eu me refiro ao filtro de papel mesmo).

Caso você geralmente faça poucos cafés, geralmente umas 400ml por vez (vamos falar de medidas mais tarde) eu recomendo comprar o coador e filtros número 102. Mais que isso, recomendo o 103. Caso você faça menos café por vez, há coador e filtros de numero 100.

Quanto a marcas, escolha o que melhor couber o seu bolso. Eu gosto do coador e filtro da Melitta mesmo. Não é caro e funciona bem pro nosso cafezinho.

Fora isso você vai precisar de um recipiente para coar o café, uma leiteira fará bem o papel.

Recomendo também ter uma balança. Se não tiver, procure um conversor de medidas na internet mas uma balança na cozinha salva vidas e você consegue achar boas opções por volta dos 50 pila nas internets da vida.

Proporção aurea do café

Como ponto de partida, podemos usar a proporção de 10mg de pó de café para 100ml de água. A medida do pó segue assim assim até uns 2 cafés. Mais que isso, ele vai ficando mais forte mas ai vai do seu gosto.

Eu uso assim

1 café = 10mg de pó
2 cafés = 20mg de pó
3 cafés = 28mg de pó
4 cafés = 38~36mg de pó
e por ai vai

Importante: essas medida não são regras e eu encorajo muito que você teste fazer seus cafés variando a quantidade de pó até chegar numa proporção que te agrade mais, belezinha?

Importante 2: Coloque um pouco mais de água, por volta de 100ml a mais para escaldar o filtro. Vou falar desse processo mais pra frente.

Importante 3: Pode parecer meio bobo mas usar água filtrada faz diferença 😉.

Mãos à obra!

Bote a água para ferver. Enquanto isso:

coloque o filtro no coador
coloque o coador onde o café vai ser coado
Aprecie sua arte

Passar café é quase uma alquimia e deve ser apreciado.

Importante, não ponha o pó de café no filtro ainda.

Água ferveu? Desligou a água.

Antes de colocar o pó no filtro, escalde o filtro. Isso serve para tirar o gosto de papel do filtro e para encharcar o mesmo assim ele não rouba seu café ;D

Para escaldar o filtro, só jogar água quente nele até ela ficar bem encharcado.

Essa água você joga fora.

Com o filtro devidamente escaldado, coloque a quantidade de pó que você vai usar pra fazer seu cafézinho :D

Depois coloque a água quente que tava descansando no fogo desligado. É importante não colocar a água fervendo pra não queimar o pó e seu café ficar com gosto de queimado.

Colocar a água no café é um caso a parte. Tem gente que recomenda colocar a água de duas vezes. Tem gente que joga tudo de uma vez...

Eu gosto de colocar a água toda de uma vez. Mas o importante mesmo é molhar todo o pó.

Outra polêmica: Tem gente que diz que não deve mexer o pó e a água enquanto tá filtrando; tem gente que diz que não pode mexer com colher de metal...

Eu dou uma mexidinha com uma colher pra ter certeza que a agua vai pegar o pó todo, principalmente se o grão estiver fininho e eu mexo com uma colher de metal porque a minha mãe faz café há mais de 40 anos mexendo com colher de metal e NINGUÉM MORREU (beijo mãe!).

Agora só esperar o café passar todo e aproveitar o cafézinho ☕️

Tem gente que diz que não precisa lavar o coador de plástico toda vez que fizer café para que o detergente não zoe seu café. Eu não lavo por motivos de: preguiça.

Adoçar ou não adoçar o café, eis a questão?

Tem gente que gosta de café doce e tem gente que quase tem um treco ao ouvir de adoçar o café. Eu sou do time que diz que cada pessoa tem que fazer o que achar melhor.

Se você gosta de um café doce, coloque açúcar 😄
Se você gosta de café sem açúcar, não coloque açúcar 😄

O importante é não encher o saco das outras pessoas ❤️

(Só por curiosidade, eu gosto de tomar café sem açúcar e morninho quase frio).

Finalizando

Agradeço a galera da Plataformatec por ter me ensinado a gostar de café e fazer café delícia 😋

Obrigado pela atenção e até a próxima!

☕️

Como desinstalar o Rails?

Odinei Ramone — Fri, 03 Sep 2021 06:45:32 +0000

Bom, nem sempre as coisas acontecem como esperamos e, as vezes, precisamos desinstalar o Rails. Seja para fazer downgrade de versão, para corrigir alguma coisa na instalação ou porque simplesmente não gostamos do framework (#triste).

A idéia de fazer esse post me veio depois que um amigo me perguntou como ele poderia desinstalar o Rails para instalar uma versão mais antiga. Obrigado Moisés por todas as perguntas muito instigantes que você tem me feito durante seu processo de aprender Rails!

E se por acaso você queira instalar a última versão do Rails, você pode seguir o Rails Guides (em inglês).

Aviso antes de zarpar 🚢!

Tudo o que vou fazer aqui foi feito no meu computador pessoal, ele roda o MacOS 10.15.5, Ruby 2.7.1 gerenciado pelo ASDF e o meu terminal é o kitty 🐱💻.

(Para quem não entendeu o porquê de eu ter dado essas informações, acho boa prática dizer qual ambiente eu estou utilizando para realizar os procedimentos e isso não quer dizer que você não vai conseguir seguir esse tutorial se tiver um ambiente totalmente diferente do meu. Caso tenha alguma dificuldade, fique a vontade para postar nos comentários desse post 😊)

Mãos à obra!

Para tentar reproduzir um ambiente com mais de uma versão do Rails, instalei as versões 6.0.3.2, 5.2.4.3 e 4.2.11.3. Você pode checar as versões do Rails usando o seguinte comando:

→ gem list | grep rails
rails (6.0.3.2, 5.2.4.3, 4.2.11.3)

O comando gem list serve para listar todas as gems instaladas no seu computador. Enquanto o comando | grep (a barrinha na vertical se chama pipe e se pronuncia "páip") pega o resultado do comando gem list e pesquisa nele o que eu passar como argumento, o que no nosso caso é a palavra rails.

Para desinstalar uma dessas versões do Rails, podemos usar o comando gem uninstall rails:

→ gem uninstall rails

Select gem to uninstall:
 1. rails-4.2.11.3
 2. rails-5.2.4.3
 3. rails-6.0.3.2
 4. All versions
>

Olha que legal! O comando gem nos leva para uma CLI (command line interface ou interface de linha de comando) onde podemos escolher, de forma interativa, qual versão do rails queremos desinstalar! Agora podemos digitar a posição da versão que queremos desinstalar ou desinstalar todas as versões! No meu caso, vou escolher a opção 2 para desinstalar o Rails 5.2.4.3.

gem uninstall rails

Select gem to uninstall:
 1. rails-4.2.11.3
 2. rails-5.2.4.3
 3. rails-6.0.3.2
 4. All versions
> 2
Successfully uninstalled rails-5.2.4.3

Uhul! Desinstalamos uma versão do Rails 🥳 🎉!

Rodando denovo o gem list | grep rails vemos que ele não lista mais a versão 5.2.4.3:

→ gem list | grep rails
rails (6.0.3.2, 4.2.11.3)

Outra forma de fazer a mesma coisa

Outra forma de desinstalar uma versão de uma gem, é passar o numero da versão direto no comando gem uninstall. Por exemplo, para desinstalar a versão 6.0.3.2 do Rails, podemos usar gem uninstall rails -v 6.0.3.2. Vamos rodar esse comando no terminal:

→ gem uninstall rails -v 6.0.3.2
Successfully uninstalled rails-6.0.3.2

Denovo, checando as versões do Rails instaladas:

→ gem list | grep rails
rails (4.2.11.3)

Uau! Ficamos apenas com uma versão do Rails instalada!

O Rails que me amava

Para finalizar, podemos rodar o comando gem uninstall rails -v 4.2.11.3 (ou usar apenas gem uninstall rails já que só temos uma versão instalada) e desinstalar todas as versões do Rails!

Porém, ao rodar o comando rails -v em vez de vermos uma mensagem de erro, nos deparamos com isso:

→ rails -v
Rails 6.0.3.2

"Como assim????? Eu desinstalei tudo!!!!!" você pode pensar, mas tem um ponto que eu não mencionei: Precisamos desinstalar todos os Railties.

O Railties é a gem responsável por "colar" todas as peças do framework. É ela que faz todo o procedimento inicial para rodarmos um app Rails, nos dá comandos CLI do framework e os generators. Caso se interesse, essa gem está disponível lá no GitHub.

Como o Railties é uma gem, podemos desinstalar ela rodando o comando gem uninstall railties. Como não estamos passando a versão, vamos entrar no modo interativo onde podemos desinstalar todas as versões da gem Railties de uma vez só:

→ gem uninstall railties

Select gem to uninstall:
 1. railties-4.2.11.3
 2. railties-5.2.4.3
 3. railties-6.0.3.2
 4. All versions
> 4
Successfully uninstalled railties-4.2.11.3
Successfully uninstalled railties-5.2.4.3
Remove executables:
        rails

in addition to the gem? [Yn]  y
Removing rails
Successfully uninstalled railties-6.0.3.2

Você pode notar que antes de desinstalar a ultima versão do Rails ele pergunta se você deseja desinstalar o executável de linha de comando "rails". Digite apenas "y" para "yes" (ou "s" para "sim", caso seu esteja em português) para finalizar a desinstalação. E para termos certeza que desinstalamos o Rails de uma vez por todas:

rails -v
asdf: No preset version installed for command rails

Pronto! Rails desinstalado! No seu computador, a segunda linha pode ser um pouco diferente. A minha aparece assim porque utilizo o ASDF para gerenciar as versões das linguagens de programação que uso no meu computador. Caso você não utilize um gerenciador para isso, recomendo que use um :D

Ora, ora! Um Xeroque Rolmes!

Caso você tenha notado, sempre que rodamos o comando gem list | grep rails aparecem outras gems com a palavra "rails" no nome. Essas gems são de funcionalidades descontinuadas nas versões mais novas do Rails que foram extraidas para gems externas para que as versões antigas possam continuar utilizando. Aqui no meu computador, tenho as seguintes gems dessa situação:

→ gem list | grep rails
rails-deprecated_sanitizer (1.0.3)
rails-dom-testing (2.0.3, 1.0.9)
rails-html-sanitizer (1.3.0)
sprockets-rails (3.2.1)

Para desinstalá-las, você pode usar o nosso bom e velho gem uninstall <nome da gem>.

Espero que tenham gostado do texto é até uma próxima! 👋

Fontes

Stack Overflow - Uninstall Rails completely
JetBrains Mono (essa aqui eu uso no Sublime 😆)

Quando usar e quando não usar gems?

Odinei Ramone — Fri, 03 Sep 2021 06:42:43 +0000

Essa pergunta foi feita pelo Leonardo Fragozo lá no canal Ruby Brasil no Telegram e achei bacana postar a resposta em forma de texto para servir de consulta para quem mais tiver esse tipo de dúvida.

Nesse texto eu falo um pouco sobre a minha forma de pensar quando me deparo com essa questão. Não sei se a minha opinião é a opinião da maioria das pessoas na comunidade Ruby porém espero que você termine de ler esse texto e tenha um pouco mais de insumos para te ajudar a decidir quando usar e quando não usar gems.

Um pouco sobre dependência e como decidir qual usar

Usar uma gem significa ter uma dependência no seu projeto. Significa você ficar dependente de um código externo que você não tem muito controle. Logo, é bom pensar em quem mantém as gems que você tá usando. No caso de usar uma gem, é melhor você usar uma que seja atualizada com alguma frequencia e/ou que tenha uma empresa por trás da manutenção dela.

Um lugar legal que pode ajudar muito a ver como anda a "saúde" de uma gem ("saúde" de uma gem seria se a gem recebe updates, se tem muitas issues abertas, etc.) é o Ruby Toolbox!

Dê uma olhada na categoria Background Jobs (processamento em segundo plano). Na página você verá um gráfico comparando o score de cada gem da categoria (sinceramente, não sei como esse score é calculado 😅). Mais para baixo você encontra todas as gems da categoria com informações como quantidade de downloads, quantidade de estrelas no GitHub e algumas badges falando sobre a saúde do projeto:

Usar ou não usar gems, eis a questão

Eu gosto de usar gems quando eu preciso de uma solução que não seja o foco do meu negócio e que seja para algo mais complexo de lidar. Um exemplo bem bom disso é autenticação. Autenticação dificilmente vai ser core no meu negócio, então eu posso delegar isso para uma gem como o Devise, por exemplo ❤️ .

Outra situação onde eu posso usar uma gem é para validação de CPF. Denovo, isso não é o core do meu negócio e eu posso delegar isso para uma gem. Porém validar CPF não é algo tão complexo como autenticação. Eu posso fazer uma validação mais simples, por exemplo, e não ter uma dependência desse tipo no meu projeto.

Vamos ver outro caso aqui: Eu tenho uma loja online e preciso cotar frete nos correios e em empresas de entregas. Isso é parte do meu negócio, posso delegar para uma gem? Posso (apesar de não conhecer nenhuma gem que faça isso), porém eu teria uma dependência externa de um código que eu não tenho muito controle. Se eu fizer essa pesquisa de frete na minha aplicação, eu tenho muito mais controle das consultas e posso utilizar esses dados com mais inteligência e exibir um comparativo das empresas que fazem entregas, por exemplo.

Um pouco mais de lenha na fogueira 🔥

Antes de finalizar, quero puxar um assunto bacana aqui: As vezes, faz sentido reinventar a roda!

As vezes faz sentindo você implementar algo que não faz parte do seu negócio dentro do seu projeto. Principalmente se você estiver estudando novas tecnologias.

É muito fácil pegar o Devise, por exemplo, e botar ele pra funcionar. Ele só funciona e pronto. Mas ai eu te pergunto, você sabe o que tá acontecendo embaixo dos panos ali?

O próprio README do Devise recomenda não usá-lo se você estiver construindo sua primeira aplicação em Rails (eu AMO essa parte desse README)

Tradução: Iniciando com Rails? Se você estiver construindo sua primeira aplicação Rails, nós recomendamos que você não use o Devise. O Devise requer um bom conhecimento do Rails. Nestes casos, nós recomendamos que você começe com uma autenticação feita do zero. Aqui tem algumas fontes que podem te ajudar (fontes em inglês):

O livro do Michael Hartl: https://www.railstutorial.org/book/modeling_users
Railscasts com Ryan Bate: http://railscasts.com/episodes/250-authentication-from-scratch e http://railscasts.com/episodes/250-authentication-from-scratch-revised
Ruby on Rails no Codecademy: Authentication and Authorization: https://www.codecademy.com/learn/rails-auth

Por último, mas de forma alguma menos importante, um grande amigo, o glorioso Paulo Henrique fez uma talk sobre porque, as vezes, é importante "reinventar a roda" e eu recomendo DEMAIS que ela seja assistida:

Concluindo

É um pouco complexo saber quando usar gems ou não. Acho que o que eu escrevi aqui nesse texto pode ajudar mas não deixe de desenvolver seu próprio “faro” para quando usar gems ou não.

Espero que tenham gostado do texto é até uma próxima! 👋

Um comentário sobre comentários de código

Odinei Ramone — Fri, 03 Sep 2021 06:35:14 +0000

Comentários de código foram algo muito confuso para mim por muito tempo. Durante a faculdade, todos os professores de todas as disciplinas que abordavam programação de software sempre diziam que todo o seu código deveria ser comentado. As justificativas sempre eram no sentido de que quando você, ou outra pessoa, precisar voltar naquele trecho, o comentário iria ajudar o programador a compreender melhor o que o código está fazendo. Eu concordo com a faculdade, em partes, mas preciso dizer que acabava sempre fazendo esse tipo de comentário:

  # Public: Return the sum of two numbers.
  #
  # number1 - First number to sum.
  # number2 - Second number to sum.
  #
  # Examples
  #
  #   sum(2, 5)
  #   # => 7
  #
  # Returns the duplicated String.
  def sum(number1, number2)
    number1 + number2
  end

Fora da faculdade, quando comecei a usar linguagens com propostas mais modernas, me deparei com pessoas, livros e posts que diziam que meu código precisava ser limpo, auto-explicativo e qualquer tipo de comentário deveria ser evitado em favor de um código que fosse mais limpo e mais auto-explicativo. Um memória muito boa que tenho disso é do meu bom amigo Arthur comentando sobre um parágrafo do livro Clean Code escrito por Robert C. Martin, mais conhecido como Uncle Bob:

So when you find yourself in a position where you need to write a comment, think it through and see whether there isn’t some way to turn the tables and express yourself in code. Every time you express yourself in code, you should pat yourself on the back. Every time you write a comment, you should grimace and feel the failure of your ability of expression.

Robert C. Martin. Clean Code. Page 54, line 7.

(Tradução livre: Então quando você se ver numa situação onde precisa escrever um comentário, pense se não há uma maneira de contornar e se expressar através de código. Sempre que conseguir se expressar através do código, você deve dar-se um tapinha nas costas. Sempre que não conseguir, você deve fazer uma careta e sentir a falha da suas habilidades de expressão.)

Ok, vamos tentar no mundo real agora

Num belo dia, me pego escrevendo uma função onde eu desejei desde o primeiro caractere que houvesse um comentário para que eu economizasse tempo quando precisasse voltar a ela.

Em vez de explicar o que está acontecendo, vou deixar o código com seu comentário e sugerir um exercício: Imagine que não há comentário documentando o código e tente entender o que a função faz. Acredito que a tarefa será um pouco complicada.

# In some worksheet rows, is returned formula errors that are inside
# an extra cell object, at the end of map process, an array is returned
# with an extra element.
#
# As we are treating that values by this position, this extra element
# in the array beginning causes validations errors when the line is
# persisted on the database.
#
# Examples
#
#  clean_formula_errors_from(['item 1', 'item 2', 'item 3'])
#  # => ['item 1', 'item 2', 'item 3']
#
#  clean_formula_errors_from(['#SomeKindOfError!', 'item 1', 'item 2', 'item 3'])
#  # => ['item 1', 'item 2', 'item 3']
#
# Returns an array without error items
def clean_formula_errors_from(row)
  row.map(&:value)
    .reject { |value| value.to_s.match?(/^\#\w*!$/) }
end

Muito mais simples de entender com o comentário, não?

Comentários valorosos para a sua aplicação são aqueles que, além de explicar o que o seu código faz, explica o por quê do seu código estar fazendo aquilo. Isso não invalida o fato de que você sempre deve manter o seu código o mais limpo e auto-explicativo possível, mas como vimos no exemplo, nem sempre é possível fazer um código totalmente auto-explicativo. Muitas vezes é necessário entender o contexto para que esse trecho de código de código limpo e auto-explicativo faça sentido.

Dicas rápidas

Quando precisar fazer, deixe seus comentários com a linguagem o mais simples possível. Não economize na hora de escrever mas mantenha o bom senso: Se o seu comentário está muito grande considere refatorar seu código. Procure sempre a opinião de um colega de trabalho ou algum desenvolvedor mais sênior, seja pessoalmente ou na hora do Code Review. E sempre que surgir dúvidas sobre documentar ou não, provavelmente é melhor documentar.

Para escrever esses comentários do texto eu utilizei as regras do TomDoc. Vale muito a pena ler não importa qual seja seu nível de experiência em desenvolvimento de software. Embora o TomDoc seja focado em Ruby, há padrões para outras linguagens como JSDoc para Javascript ou as definições da PEP 257 para Python.

Um (muito) breve comentário sobre documentação fora do código

Sobre documentação fora do código para procedimentos e/ou especificidades que não estejam totalmente ligadas ao código: Sim, vale muito a pena pois você compartilha o conhecimento sobre determinada parte do seu sistema com os demais programadores além de facilitar muito para programadores novos entenderem melhor sobre o sistema.

Fui breve aqui pois acredito que alguém possa ficar com dúvidas sobre comentários fora do código. E também por que pretendo abordar esse assunto melhor em post futuro.

Obrigado! 😄

Como funcionam os getters e setters no Ruby?

Odinei Ramone — Fri, 03 Sep 2021 06:26:27 +0000

Há alguns dias um amigo me mandou a seguinte pergunta: O que são e como funcionam os getters e setters?

Fui pensar um pouco nisso para bolar uma resposta e lembrei que eu também tive dificuldade com esse tópico quando comecei a programar e continuei tendo dificuldades com isso quando iniciei no mundo de Ruby 😅.

Assim, mandei um textão para meu amigo explicando o que seriam os getters e setters e achei que seria um ótimo tópico para compartilhar aqui com vocês! Vamos lá?

Getters e setters servem para você manipular atributos do objeto (atributos são informações sobre objeto).

Setters servem para atribuir valores aos atributos do objeto que são guardadas em variáveis de instâncias (variáveis de instância sempre começam com @) e getters leem os valores dessas variáveis nos permitindo acessa-los sempre que necessário.

Em código ruby, um objeto com getters e setters seria assim:

class Humano
  # aqui eu inicializo meu objeto apenas
  # com o atributo nome:
  def initialize(nome)
    @nome = nome
  end

  # aqui eu defino um getter para nome que
  # me permite ler o valor desse atributo:
  def nome
    @nome
  end

  # aqui eu defino um setter para idade que
  # me permite atribuir um valor para esse atributo:
  def idade=(idade)
    @idade = idade
  end

  # aqui eu defino um getter para idade que
  # me permite ler o valor desse atributo:
  def idade
    @idade
  end
end

Podemos usar esse objeto assim:

# aqui eu instancio um novo objeto Humano com
# o valor "odinei" no atributo nome e o atribuo
# à variável "odinei"
> eu = Humano.new('odinei')
=> #<Humano:0x00007fa450006918 @nome="odinei">

# aqui eu chamo o getter nome para que ele me
# devolva o valor do atributo nome do meu objeto
> eu.nome
=> "odinei"

# aqui eu chamo o getter idade para que ele me
# devolva o valor do atributo idade do meu objeto
# como eu não atribui valor à esse atributo, ele
# me devolve nil (nulo) como valor
> eu.idade
=> nil

# aqui eu chamo o setter idade para atribuir à
# esse atributo o valor 28
> eu.idade = 28
=> 28

# aqui eu chamo o getter idade para que ele me
# devolva o valor do atributo idade do meu objeto,
# que agora tem um valor
> eu.idade
=> 28

# aqui eu sobreescrevo o valor anterior do atributo
# idade para o valor 23
> eu.idade = 23
=> 23

# aqui eu chamo o getter idade para que ele me
# devolva o valor do atributo idade do meu objeto,
# que agora tem um valor diferente do anterior
> eu.idade
=> 23

Porém, como eu não defini um setter para nome, eu não consigo trocar o valor do atributo nome do meu objeto:

eu.nome = 'Arthur'
Traceback (most recent call last):
        4: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/bin/irb:23:in `<main>'
        3: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/bin/irb:23:in `load'
        2: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/lib/ruby/gems/2.6.0
                /gems/irb-1.0.0/exe/irb:11:in `<top (required)>'
        1: from (irb):26
NoMethodError (undefined method `nome=' for #<Humano:0x00007fa450006918 @nome="odinei", @idade=23>)
Did you mean?  nome

Aqui temos uma parte interessante do erro:

NoMethodError (undefined method `nome=' for #<Humano:0x00007fa450006918 @nome="odinei", @idade=23>)

O ruby está no dizendo que o nosso objeto não tem o método setter def nome= por isso, não podemos atribuir um valor para o atributo nome do nosso objeto!

A mesma coisa, só que diferente

Em ruby, podemos usar alguns métodos nos nossos objetos para poupar linhas ao escrever nossos getters e setters.
São eles

attr_accessor que cria os métodos de leitura (getter) e escrita (setter) para um determinado atributo.
attr_writer que cria apenas o método de escrita (setter) para um determinado atributo.
attr_reader que cria apenas o método de leitura (getter) para um determinado atributo.

Vejamos um exemplo:

class Humano
  # aqui eu crio um getter para o atributo nome
  attr_reader :nome

  # aqui eu crio um getter e um setter para o atributo idade 
  attr_accessor :idade

  def initialize(nome)
    @nome = nome
  end
end

Esse novo objeto Humano se comporta igual ao objeto que criamos anteriormente! Inclusive dando o mesmo erro ao chamarmos um setter inexistente!

eu = Humano.new('odinei')
=> #<Humano:0x00007fb20d0344b0 @nome="odinei">
> eu.nome
=> "odinei"
> eu.idade
=> nil
> eu.idade = 27
=> 27
> eu.idade
=> 27
> eu.idade = 23
=> 23
> eu.nome = 'Arthur'
Traceback (most recent call last):
        4: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/bin/irb:23:in `<main>'
        3: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/bin/irb:23:in `load'
        2: from /Users/odineiribeiro/.asdf/installs/ruby/2.6.2/lib/ruby/gems/2.6.0
                /gems/irb-1.0.0/exe/irb:11:in `<top (required)>'
        1: from (irb):17
NoMethodError (undefined method `nome=' for #<Humano:0x00007fb20d0344b0 @nome="odinei", @idade=23>)
Did you mean?  nome

Método de escrita, para que te quero?

O attr_writer pode ser um pouco estranho de entender quando usar, afinal, para que eu vou colocar um valor em um atributo do meu objeto sem ter um método para lê-lo?

A resposta é simples: Você pode querer um valor para fazer alguma operação com ele e retorna-lo de uma forma diferente. Vamos ver um exemplo:

> eu = Humano.new('odinei')
=> #<Humano:0x00007fd577a279a8 @nome="odinei">
> eu.nome
=> "odinei"
> eu.ano_nascimento = 1992
=> 1992
> eu.idade
=> 28

No exemplo acima eu calculo a minha idade com base na atributo ano_nascimento que foi criada apenas para leitura!

Em ruby é muito mais comum usar os attr_accessor, attr_reader e attr_writer para criar métodos de leitura e escrita em vez de criar esses métodos "na mão" para termos menos linhas no nossos arquivos 😄!

Quando usar attr_accessor e quando usar getters e setters?

Segundo o livro Ruby Under a Microscope escrito pelo Pat Shaughnessy (leitura recomendadíssima para quem quer entender como as mágicas do Ruby funcionam ;D) o Ruby otimiza o uso do attr_reader, attr_writer e attr_accessor fazendo a criação e acesso à variáveis de instância funcionar mais rápido 🚗💨!

O livro entra em mais detalhes do porquê os attr_accessor serem mais rápidos do que os outros getters e setters mas basicamente o Ruby implementa métodos escritos em C que são especializados no tratamento dos attr_accessors, ou seja, eles não são simples atalhos para os métodos em C que criam os getters e setters.

Caso você queira ler a explicação completa no Ruby Under a Microscope, a parte que trata desses métodos estão na página 97 em "Calling attr_reader and attr_writer" e na página 98 em "Method Dispatch Optimizes attr_reader and attr_writer".

Espero que tenham gostado do texto é até uma próxima! 👋

Fontes

Ruby Under a Microscope
JetBrains Mono (essa aqui eu uso no Sublime 😆)