DEV Community: Marcos Fernandes

PostgreSQL: Dominando os Fundamentos da Administração de Banco de Dados

Marcos Fernandes — Mon, 26 May 2025 17:51:45 +0000

Quando você começa a trabalhar com PostgreSQL em ambiente de produção, rapidamente percebe que existe uma diferença significativa entre simplesmente usar o banco de dados e realmente administrá-lo. É como a diferença entre dirigir um carro e ser um mecânico - ambos são importantes, mas exigem conhecimentos completamente diferentes.

Por Que o psql é Seu Melhor Amigo

Embora existam excelentes interfaces gráficas para PostgreSQL, o cliente de linha de comando psql permanece como a ferramenta fundamental que todo administrador deve dominar. Pense no psql como o canivete suíço do PostgreSQL - ele sempre está disponível, funciona em qualquer ambiente e oferece acesso direto a todas as funcionalidades do banco.

O psql vem com uma rica coleção de meta-comandos, que são atalhos que começam com barra invertida. Por exemplo, o comando \s mostra seu histórico de comandos, enquanto \l lista todos os bancos de dados. Esses comandos são como atalhos de teclado em um editor de texto - uma vez que você os aprende, sua produtividade aumenta exponencialmente.

Configuração: O Coração do Desempenho

Um dos aspectos mais críticos da administração PostgreSQL é entender como modificar o arquivo de configuração postgresql.conf. Imagine este arquivo como o painel de controle do seu banco de dados, onde cada parâmetro ajusta um comportamento específico.

Um exemplo prático é a configuração da extensão pg_stat_statements através do parâmetro shared_preload_libraries. Esta extensão é como um sistema de monitoramento interno que coleta estatísticas sobre todas as consultas executadas no banco. É fundamental para identificar gargalos de performance, mas requer reinicialização do PostgreSQL para ser ativada.

A diferença entre parâmetros que exigem reinicialização versus aqueles que podem ser recarregados é crucial em produção. Parâmetros que requerem apenas um reload são como ajustar o volume do rádio enquanto dirige, enquanto aqueles que precisam de restart são como parar o carro para trocar o óleo.

Observabilidade: Enxergando o Invisível

PostgreSQL oferece uma janela para seu funcionamento interno através dos catálogos do sistema, especialmente pg_stat_activity e pg_locks. Estes catálogos são como painéis de instrumentos que mostram o que está acontecendo em tempo real.

O pg_stat_activity revela todas as consultas ativas, seus usuários, duração e estado. É como ter uma câmera de segurança mostrando toda a atividade do banco. Já o pg_locks mostra conflitos de bloqueio, que são situações onde uma operação precisa aguardar outra terminar.

Gerenciamento de Locks: O Desafio da Concorrência

O sistema de locks do PostgreSQL é baseado em pessimismo controlado - ele assume que conflitos podem acontecer e protege os dados antecipadamente. É como um sistema de semáforos em um cruzamento movimentado, garantindo que apenas uma direção passe por vez.

Existem locks compartilhados (que permitem leitura simultânea) e exclusivos (que bloqueiam tudo). Entender quando cada tipo é usado ajuda a prever e resolver problemas de bloqueio antes que afetem os usuários.

Experimentação Segura: Aprendendo Sem Riscos

Uma característica única do PostgreSQL é o DDL transacional - a capacidade de fazer mudanças estruturais dentro de transações que podem ser desfeitas. Isso permite experimentar com segurança, como ter um botão "desfazer" para mudanças no banco de dados.

Contudo, a experimentação em produção deve ser feita com extremo cuidado. A criação de usuários somente leitura e o uso de ambientes de staging são práticas essenciais para manter a segurança dos dados de produção.

Construindo uma Base Sólida

Dominar estes fundamentos de administração PostgreSQL é como construir uma casa - você precisa de uma fundação sólida antes de adicionar os acabamentos. Cada conceito se conecta com os outros: o psql fornece as ferramentas, a configuração ajusta o comportamento, a observabilidade mostra os resultados, e o entendimento de locks previne problemas.

O caminho para se tornar um administrador PostgreSQL competente passa necessariamente por estes fundamentos. Eles formam a base sobre a qual todo conhecimento avançado será construído, permitindo não apenas reagir a problemas, mas antecipá-los e preveni-los.

Lembre-se: administração de banco de dados é tanto arte quanto ciência. Os conceitos técnicos são importantes, mas a experiência prática e o entendimento dos padrões de uso da sua aplicação são igualmente valiosos.

Active Record: O Coração dos Modelos no Rails

Marcos Fernandes — Fri, 23 May 2025 16:56:09 +0000

O Active Record é uma das joias da coroa do framework Ruby on Rails, funcionando como a camada de mapeamento objeto-relacional (ORM) que conecta os objetos da sua aplicação com as tabelas do banco de dados. Neste post, vamos explorar como o Active Record simplifica o trabalho com dados e permite que você se concentre na lógica de negócio em vez de escrever SQL manualmente.

O que é o Active Record?

O Active Record implementa o padrão de mesmo nome criado por Martin Fowler, onde objetos incluem tanto os dados quanto o comportamento que atua sobre esses dados. No Rails, cada classe de modelo corresponde a uma tabela no banco de dados, e cada instância dessa classe representa uma linha específica na tabela.

Uma das belezas do Active Record é sua convenção sobre configuração. Ao seguir convenções de nomenclatura simples, ele consegue automaticamente inferir relações entre tabelas e mapear colunas para atributos de objetos sem necessidade de configuração adicional.

Definindo Seus Dados

No Active Record, você não precisa declarar explicitamente os atributos dos seus modelos. Ao invés disso, o Rails utiliza introspecção para determinar as colunas da tabela e criar getters e setters automaticamente. Por exemplo:

class Pedido < ApplicationRecord
end

Com apenas essa definição, você já tem acesso a todos os atributos da tabela pedidos. O Rails assume que classes no singular correspondem a tabelas no plural, e automaticamente mapeia Pedido para a tabela pedidos.

Relacionamentos entre Modelos

O Active Record suporta três tipos de relacionamentos:

Um-para-um: Implementado com has_one e belongs_to
Um-para-muitos: Implementado com has_many e belongs_to
Muitos-para-muitos: Implementado com has_and_belongs_to_many ou através de um modelo de junção

Por exemplo, para definir que um pedido pode ter vários itens:

class Pedido < ApplicationRecord
  has_many :itens_pedido
end

class ItemPedido < ApplicationRecord
  belongs_to :pedido
end

Operações CRUD

O Active Record simplifica as operações de CRUD (Create, Read, Update, Delete):

Create (Criar)

pedido = Pedido.new(cliente: "João Silva", email: "joao@exemplo.com")
pedido.save
# ou
pedido = Pedido.create(cliente: "João Silva", email: "joao@exemplo.com")

Read (Ler)

pedido = Pedido.find(1)  # Encontra pelo ID
pedidos = Pedido.where(cliente: "João Silva")  # Encontra pela condição

Update (Atualizar)

pedido = Pedido.find(1)
pedido.cliente = "Maria Silva"
pedido.save
# ou
pedido.update(cliente: "Maria Silva")

Delete (Excluir)

pedido = Pedido.find(1)
pedido.destroy
# ou
Pedido.destroy(1)

Consultas Avançadas

O Active Record oferece uma API fluente para consultas que vai muito além do básico:

# Encontra pedidos recentes, ordenados por data
pedidos = Pedido.where("created_at > ?", 7.days.ago)
               .order(created_at: :desc)
               .limit(10)

Callbacks e Ciclo de Vida

Um dos recursos mais poderosos do Active Record são os callbacks, que permitem executar código em momentos específicos do ciclo de vida dos objetos:

class Pedido < ApplicationRecord
  before_save :normalizar_telefone
  after_create :enviar_email_confirmacao

  private

  def normalizar_telefone
    self.telefone = telefone.gsub(/\D/, '') if telefone.present?
  end

  def enviar_email_confirmacao
    PedidoMailer.confirmacao(self).deliver_later
  end
end

Transações

Para operações que precisam ser atômicas, o Active Record suporta transações:

Conta.transaction do
  conta1.depositar(100)
  conta2.sacar(100)
end

Se qualquer parte da transação falhar (por exemplo, se conta2 não tiver saldo suficiente), toda a operação será revertida, garantindo a consistência dos dados.

Conclusão

O Active Record é uma abstração poderosa que simplifica enormemente o trabalho com bancos de dados nas aplicações Rails. Ele elimina muito do código clichê normalmente associado ao acesso a dados e permite que você se concentre no que realmente importa: a lógica de negócio da sua aplicação.

À medida que você se torna mais familiar com o Active Record, descobrirá que pode expressar consultas complexas de maneira elegante e legível, sem sacrificar a eficiência. E quando precisar, sempre é possível recorrer ao SQL puro para casos específicos.

Que tal compartilhar nos comentários como você tem usado o Active Record nos seus projetos? Você tem alguma dica ou truque interessante para simplificar ainda mais o trabalho com dados no Rails?

A Arte dos Métodos em Ruby: Dominando a Base da Linguagem

Marcos Fernandes — Wed, 21 May 2025 13:51:08 +0000

Quando estamos aprendendo Ruby, rapidamente percebemos como os métodos são fundamentais para a estrutura da linguagem. Diferente de outras linguagens de programação, Ruby trata métodos com uma elegância singular, oferecendo diversas formas de defini-los e chamá-los. Vamos explorar em detalhes como funcionam os métodos em Ruby e algumas técnicas avançadas que podem elevar seu código a um novo patamar.

Definindo Métodos: A Base de Tudo

Em Ruby, definimos métodos usando a palavra-chave def. O corpo do método contém expressões Ruby normais, e o valor de retorno é o resultado da última expressão executada (ou o argumento de um return explícito).

def saudacao(nome)
  "Olá, #{nome}!"
end

puts saudacao("Maria") # Imprime: Olá, Maria!

Uma característica interessante é que podemos redefinir um método sem erros - Ruby apenas emite um aviso e usa a segunda definição. Isso, combinado com a capacidade de reabrir classes, permite modificar comportamentos em tempo de execução.

A Evolução dos Métodos: Ruby 2 vs. Ruby 3 vs. Ruby 3.4

Ruby 2: A Era dos Argumentos Ambíguos

No Ruby 2.x, os argumentos de palavra-chave (keyword arguments) eram tratados internamente como um hash opcional no final da lista de argumentos:

# Ruby 2.x
def buscar(campo, opcoes = {})
  # opcoes é um hash contendo os parâmetros de palavra-chave
  puts "Buscando em #{campo} com #{opcoes}"
end

# Ambas as chamadas eram tratadas da mesma forma
buscar(:titulo, genero: "jazz", duracao_menor_que: 270)
buscar(:titulo, {genero: "jazz", duracao_menor_que: 270})

Esta abordagem era conveniente, mas criava ambiguidades e dificultava a distinção entre um hash regular e argumentos de palavra-chave verdadeiros.

Ruby 3.0: A Separação Completa de Argumentos

Ruby 3.0 introduziu uma mudança fundamental: a separação completa entre argumentos posicionais e argumentos de palavra-chave. Esta não foi apenas uma mudança sintática, mas uma alteração importante no comportamento:

# Ruby 3.0+
def buscar(campo, opcoes = {})
  puts "Buscando em #{campo} com #{opcoes}"
end

# Isso funciona - opcoes recebe o hash
buscar(:titulo, {genero: "jazz", duracao_menor_que: 270})

# Isso gera um ArgumentError em Ruby 3.0!
# Ruby não converte mais automaticamente os keywords em hash
buscar(:titulo, genero: "jazz", duracao_menor_que: 270)

Para manter a compatibilidade com o estilo anterior, você precisa usar o operador de duplo splat para capturar keywords explicitamente:

# Ruby 3.0+ - forma correta
def buscar(campo, **opcoes)
  puts "Buscando em #{campo} com #{opcoes}"
end

# Agora funciona corretamente
buscar(:titulo, genero: "jazz", duracao_menor_que: 270)

Ruby 3.0 também introduziu a sintaxe de "método sem fim" (endless method):

# Ruby 3.0+ - método sem fim
def quadrado(n) = n * n

E a sintaxe de reticências triplas para encaminhar todos os argumentos:

# Ruby 3.0+ - encaminhamento de argumentos
def metodo_intermediario(...)
  metodo_final(...)
end

Ruby 3.2-3.4: Refinamentos em Parâmetros e Padrões

Ruby 3.2 introduziu os parâmetros de dados, permitindo desestruturar argumentos diretamente na definição do método:

# Ruby 3.2+
def processa_usuario(usuario:)
  # Desestruturação do objeto usuário
  { nome:, idade: } = usuario
  "Nome: #{nome}, Idade: #{idade}"
end

Ruby 3.4 aprimorou a inferência de tipos e melhorou o pattern matching nos parâmetros de métodos:

# Ruby 3.4+
def processar_item(item) = 
  case item
  in String => s then s.upcase
  in Integer => i then i * 2
  in [Integer, String] => [num, str] then "#{str}: #{num}"
  else "Tipo desconhecido"
  end

Migração e Compatibilidade

Se você estiver migrando código de Ruby 2.x para Ruby 3.x, especialmente em relação aos argumentos de método, aqui estão algumas dicas importantes:

Use a flag -W:deprecated para identificar código que usa o comportamento antigo de argumentos de palavra-chave.
Declare explicitamente parâmetros de palavra-chave usando a sintaxe parametro: ou **kwargs.
Para métodos que precisam manter compatibilidade com versões mais antigas, considere:

# Compatível com Ruby 2.7+ e 3.0+
def metodo_compativel(arg, **kwargs, &block)
  outro_metodo(arg, **kwargs, &block)
end

Ao chamar métodos de bibliotecas que foram escritas antes do Ruby 3.0, você pode precisar converter explicitamente keyword arguments em hashes usando o operador **{}:

# Forçando keywords a serem tratados como hash
metodo_antigo(:valor, **{opcao1: true, opcao2: false})

Nomes de Métodos: Convenções Importantes

Os nomes de métodos em Ruby devem começar com letra minúscula ou underscore, seguido por uma combinação de letras, dígitos e underscores. Por convenção, os métodos que retornam valores booleanos (predicados) geralmente terminam com ?:

1.even? # => false
2.even? # => true

Métodos "perigosos" ou que modificam o objeto receptor costumam terminar com exclamação !. Estes são frequentemente emparelhados com uma versão "segura" sem a exclamação:

texto = "meu código"
texto.chop   # => "meu códig" (retorna uma cópia modificada)
texto        # => "meu código" (original permanece inalterado)
texto.chop!  # => "meu códig" (modifica o objeto original)
texto        # => "meu códig" (o objeto foi modificado)

Métodos que podem aparecer no lado esquerdo de uma atribuição terminam com sinal de igual =:

class Pessoa
  def nome=(novo_nome)
    @nome = novo_nome
  end
end

p = Pessoa.new
p.nome = "Ana Vitória" # Invoca o método nome=

O Receptor do Método: Self e Além

Em Ruby, cada método é chamado em um objeto receptor. Dentro do método, a palavra-chave self refere-se a esse receptor.

Podemos definir métodos para classes (métodos de classe) prefixando o nome do método com self.:

class Computador
  def self.funcao
    "Receio não poder fazer isso"
  end
end

puts Computador.funcao # Chama o método na própria classe

Também podemos anexar métodos a objetos específicos:

mac = Computador.new
def mac.introducao
  "Eu sou um Mac"
end

puts mac.introducao # => "Eu sou um Mac"

Parâmetros de Método: Flexibilidade em Ação

Ruby oferece várias formas de definir parâmetros, tornando os métodos extremamente flexíveis:

Parâmetros com Valores Padrão

def musico_favorito(arg1="Chico", arg2="Elis", arg3="Caetano")
  "#{arg1}, #{arg2}, #{arg3}."
end

musico_favorito                    # => "Chico, Elis, Caetano."
musico_favorito("Milton")          # => "Milton, Elis, Caetano."
musico_favorito("Milton", "Maria") # => "Milton, Maria, Caetano."

Parâmetros de Tamanho Variável (Splat)

Usando um asterisco antes do nome do parâmetro, podemos capturar múltiplos argumentos em um único array:

def argumentos_variaveis(arg1, *resto)
  "arg1=#{arg1} -- resto=#{resto.inspect}"
end

argumentos_variaveis("um")                 # => arg1=um -- resto=[]
argumentos_variaveis("um", "dois", "três") # => arg1=um -- resto=["dois", "três"]

Parâmetros de Palavra-chave (Keyword Parameters)

def metodo_com_keywords(cidade:, estado:, cep:)
  "Moro em #{cidade}, #{estado} #{cep}"
end

metodo_com_keywords(cidade: "São Paulo", estado: "SP", cep: "01311-000")
# => "Moro em São Paulo, SP 01311-000"

Podemos também coletar palavras-chave arbitrárias usando o operador de duplo splat **:

def varargs(arg1, **resto)
  "arg1=#{arg1}. resto=#{resto.inspect}"
end

varargs("um", cor: "vermelho", tamanho: "G")
# => arg1=um. resto={:cor=>"vermelho", :tamanho=>"G"}

Chamando Métodos: A Execução em Prática

Para chamar um método, você especifica (opcionalmente) um receptor, o nome do método e os argumentos:

arquivo.download_mp3("samba", velocidade: :normal) { |p| mostrar_progresso(p) }

Se omitirmos o receptor, Ruby usa self como receptor padrão. Isso é como os métodos privados funcionam - eles só podem ser chamados implicitamente no objeto atual.

Uma observação importante: ao chamar um método no lado esquerdo de uma atribuição (com nome terminando em =), você deve especificar explicitamente o receptor:

class Pessoa
  def nome=(novo_nome)
    @nome = novo_nome
  end

  def alterar_coisas(novo_nome)
    # Isso cria uma variável local chamada 'nome'
    nome = novo_nome  

    # Para chamar o método, precisamos usar 'self'
    self.nome = novo_nome  
  end
end

Valores de Retorno: O Resultado Final

Todo método retorna um valor - o valor da última expressão executada (ou o argumento de return):

def positivo_ou_negativo(arg)
  case
  when arg > 0 then "positivo"
  when arg < 0 then "negativo"
  else "zero"
  end
end

positivo_ou_negativo(42) # => "positivo"

Você pode usar return para sair do método prematuramente:

def encontrar_quadrado_grande
  100.times do |num|
    quadrado = num * num
    return num, quadrado if quadrado > 1000
  end
end

numero, quadrado = encontrar_quadrado_grande
# numero => 32, quadrado => 1024

Expansão em Chamadas de Método (Splat)

Assim como podemos coletar múltiplos argumentos em um array, podemos fazer o contrário - converter uma coleção em argumentos individuais usando o operador de splat:

def cinco(a, b, c, d, e)
  "Recebi #{a} #{b} #{c} #{d} #{e}"
end

cinco(*[1, 2, 3, 4, 5]) # => "Recebi 1 2 3 4 5"
cinco(1, 2, *[3, 4, 5]) # => "Recebi 1 2 3 4 5"
cinco(*(1..5))          # => "Recebi 1 2 3 4 5"

Da mesma forma, podemos expandir hashes em argumentos de palavra-chave usando o duplo splat:

def metodo_com_keywords(cidade:, estado:, cep:)
  "Moro em #{cidade}, #{estado} #{cep}"
end

dados = {cidade: "Recife", estado: "PE", cep: "50030-150"}
metodo_com_keywords(**dados) # => "Moro em Recife, PE 50030-150"

Passando Blocos como Argumentos

Uma técnica poderosa em Ruby é a capacidade de converter um objeto Proc em um bloco para passá-lo a um método:

["a", "b", "c"].map { |s| s.upcase } # => ["A", "B", "C"]

Existe um atalho muito usado com o operador & quando o bloco apenas chama um método:

["a", "b", "c"].map(&:upcase) # => ["A", "B", "C"]

Isso funciona porque a classe Symbol implementa o método to_proc, retornando um objeto Proc que chama o método correspondente ao símbolo.

Outra aplicação interessante é criar blocos dinamicamente e passá-los aos métodos:

print "Operação ((m)ultiplicação ou (s)oma): "
operador = gets
print "número: "
numero = Integer(gets)

metodo = numero.method(operador.start_with?("m") ? :* : :+)
puts((1..10).map(&metodo).join(", "))

Conclusão: O Poder dos Métodos em Ruby

Os métodos em Ruby são muito mais do que simples funções. Eles formam a base da expressividade e flexibilidade que torna a linguagem tão querida por desenvolvedores em todo o mundo. Com recursos como parâmetros nomeados, expansão de coleções e integração com blocos, os métodos Ruby podem ser adaptados para uma ampla variedade de cenários de programação.

A evolução dos métodos em Ruby, especialmente as mudanças entre as versões 2.x e 3.x, mostra o compromisso da linguagem com a clareza e precisão. Embora essas mudanças possam exigir ajustes ao migrar código antigo, elas resultam em um sistema de tipos mais robusto e menos propenso a erros sutis.

Dominar a arte de definir e chamar métodos em Ruby é essencial para escrever código elegante, expressivo e de fácil manutenção. Ao compreender profundamente os conceitos apresentados neste artigo, você estará bem equipado para criar interfaces de programação intuitivas e poderosas em seus projetos Ruby.

Ruby Para Iniciantes: Entendendo Classes, Objetos e Variáveis

Marcos Fernandes — Wed, 21 May 2025 13:49:23 +0000

Ruby é uma linguagem dinâmica, elegante e poderosa, conhecida por sua sintaxe limpa e expressiva. Um dos aspectos mais importantes de Ruby é seu modelo de programação orientada a objetos, que permite estruturar códigos de forma intuitiva e eficiente. Neste artigo, vamos explorar os fundamentos de classes, objetos e variáveis em Ruby, desvendando a simplicidade e potência desses conceitos.

A Base da Orientação a Objetos em Ruby

Em Ruby, tudo é um objeto. Esta não é apenas uma afirmação retórica - é um princípio fundamental da linguagem. Desde números e strings até as próprias classes, tudo em Ruby é instanciado a partir de uma classe. Esta característica proporciona uma consistência valiosa para quem está aprendendo a linguagem.

Definindo Classes

Vamos começar com um exemplo prático. Imagine que estamos gerenciando uma livraria de livros usados. Precisamos desenvolver um sistema que realize o controle de estoque, processando arquivos CSV que contêm informações como ISBN e preço dos livros.

Uma boa abordagem para design orientado a objetos é identificar os conceitos do domínio. No nosso caso, um conceito fundamental é o livro em estoque. Podemos representá-lo com uma classe:

class BookInStock
  def initialize(isbn, price)
    @isbn = isbn
    @price = Float(price)
  end
end

Esta simples declaração já nos permite criar instâncias:

a_book = BookInStock.new("isbn1", 3)
another_book = BookInStock.new("isbn2", 3.14)

O Método Initialize

O método initialize é especial em Ruby. Quando você chama BookInStock.new, Ruby aloca memória para um objeto não inicializado e então chama o método initialize desse objeto, passando todos os argumentos que foram passados para new.

Isso permite configurar o estado inicial do objeto. No nosso exemplo, o método initialize transfere os parâmetros para as variáveis de instância @isbn e @price. Note o símbolo @ - ele identifica variáveis de instância em Ruby, que são armazenadas com cada objeto e acessíveis em todos os métodos desse objeto.

Objetos e Atributos

As variáveis de instância são encapsuladas nos objetos - são privadas por padrão. Isso é vantajoso, pois garante que o objeto seja responsável por manter sua própria consistência. Porém, precisamos definir métodos que permitam ao mundo exterior interagir com o objeto. Esses aspectos visíveis externamente são chamados de atributos.

Métodos de Acesso

Ruby facilita a criação de métodos acessores através de atalhos convenientes:

class BookInStock
  attr_reader :isbn, :price  # Cria métodos de leitura
  attr_accessor :price       # Cria métodos de leitura e escrita

  def initialize(isbn, price)
    @isbn = isbn
    @price = Float(price)
  end
end

O método attr_reader cria métodos para leitura, enquanto attr_accessor cria métodos para leitura e escrita. Isso permite acessar atributos de forma simples e elegante:

book = BookInStock.new("isbn1", 33.80)
puts "ISBN = #{book.isbn}"        # Lendo um atributo
book.price = book.price * 0.75    # Modificando um atributo

Atributos São Apenas Métodos

Um conceito fundamental em Ruby é que atributos são apenas métodos sem argumentos. Eles não necessariamente precisam apenas retornar ou atribuir valores a variáveis de instância. Você pode implementar lógica mais complexa:

def price_in_cents
  (price * 100).round
end

def price_in_cents=(cents)
  @price = cents / 100.0
end

Isso cria uma variável de instância "virtual". Para o mundo exterior, price_in_cents parece ser um atributo como qualquer outro, mas internamente não possui variável de instância correspondente.

Este princípio, conhecido como "Princípio do Acesso Uniforme", é poderoso - você oculta a implementação do resto do mundo, tendo liberdade para alterá-la no futuro sem impactar o código que utiliza sua classe.

Classes Trabalhando Juntas

Resolver problemas complexos geralmente envolve múltiplas classes trabalhando juntas. No nosso exemplo da livraria, além da classe BookInStock, podemos criar uma classe CsvReader para processar os arquivos CSV:

class CsvReader
  def initialize
    @books_in_stock = []
  end

  def read_in_csv_data(csv_file_name)
    CSV.foreach(csv_file_name, headers: true) do |row|
      @books_in_stock << BookInStock.new(row["ISBN"], row["Price"])
    end
  end

  def total_value_in_stock
    sum = 0.0
    @books_in_stock.each { |book| sum += book.price }
    sum
  end
end

Esta abordagem de dividir responsabilidades entre classes torna o código mais modular, legível e manutenível.

Controle de Acesso

Ruby oferece três níveis de controle de acesso para métodos:

Public: Métodos acessíveis por qualquer código (padrão)
Protected: Métodos acessíveis apenas por objetos da mesma classe ou subclasses
Private: Métodos que só podem ser chamados no contexto do objeto atual

Isso permite controlar quanta exposição sua classe terá ao mundo exterior:

class MyClass
  def method1
    # Método público
  end

  protected def method2
    # Método protegido
  end

  private def method3
    # Método privado
  end
end

Variáveis e Referências

Em Ruby, variáveis não são objetos - são referências a objetos. Os objetos existem em um "pool" (geralmente a heap do sistema operacional) e são apontados por variáveis. Isso tem implicações importantes:

person1 = "Tim"
person2 = person1    # Ambos apontam para o mesmo objeto
person1[0] = 'J'     # Modifica o objeto
puts person2         # Exibe "Jim", não "Tim"

Se quiser evitar esse comportamento, você pode usar dup para criar uma cópia do objeto, ou freeze para impedir modificações.

Reabrindo Classes

Uma característica única de Ruby é a capacidade de reabrir uma definição de classe e adicionar novos métodos ou variáveis a qualquer momento, mesmo para classes da biblioteca padrão:

class String
  def reverso_e_maiusculo
    reverse.upcase
  end
end

puts "teste".reverso_e_maiusculo  # Imprime "ETSET"

Essa técnica, conhecida como "monkey patching", pode ser poderosa, mas deve ser usada com cautela para evitar comportamentos imprevisíveis.

Conclusão

O modelo de objetos em Ruby é simples, consistente e flexível, tornando a linguagem uma excelente escolha para programação orientada a objetos. A sintaxe expressiva e os atalhos convenientes permitem escrever código limpo e elegante, enquanto os conceitos sólidos de OO proporcionam uma base robusta para aplicações complexas.

Se você está começando com Ruby ou buscando aprofundar seus conhecimentos em programação orientada a objetos, explorar esses conceitos fundamentais será um passo valioso na sua jornada de aprendizado.

Convenções de Nomenclatura no Ruby on Rails: A Magia por Trás do Code

Marcos Fernandes — Wed, 21 May 2025 13:43:52 +0000

O que são as convenções de nomenclatura no Rails?

Se você já começou a trabalhar com Ruby on Rails, provavelmente ficou surpreso com a forma como o framework lida automaticamente com a nomenclatura dos elementos. Por exemplo, quando você cria uma classe modelo chamada Person, o Rails sabe que deve procurar por uma tabela de banco de dados chamada people. Isso não é magia, mas sim convenções bem definidas que tornam o desenvolvimento mais fluido.

As convenções de nomenclatura no Rails seguem um padrão chamado "convenção sobre configuração" (convention over configuration), o que significa que, ao seguir essas convenções, você escreve menos código e ganha mais produtividade.

Mixed Case, Underscores e Plurais

No Ruby, tradicionalmente, as variáveis são nomeadas usando letras minúsculas com palavras separadas por underscores (como order_status). Já as classes e módulos seguem o padrão Mixed Case, onde cada palavra na frase é capitalizada sem underscores (como LineItem).

O Rails estende essas convenções de duas maneiras importantes:

Nomes de tabelas no banco de dados: Seguem o padrão de letras minúsculas com underscores, assim como as variáveis.
Pluralização automática: Tabelas são sempre nomeadas no plural. Por exemplo, uma classe modelo Product corresponde a uma tabela products.

Por que usar plurais para as tabelas?

Como explicado por David no documento, isso faz sentido na conversação natural. Quando dizemos "Selecione um Produto de produtos" ou "Um pedido tem muitos itens", a linguagem flui naturalmente.

A intenção é criar uma linguagem de domínio que possa ser compartilhada entre programadores e não-programadores, reduzindo a tradução mental que geralmente ocorre nas discussões técnicas com clientes. Quando um cliente fala sobre "descrição do produto", mas no código está implementado como "corpo da mercadoria", surgem lacunas de comunicação que podem levar a erros.

Benefícios de seguir as convenções

O Rails recompensa os desenvolvedores que seguem suas convenções padrão com configuração automática. Isso significa:

Menos código para escrever
Menos configuração manual
Maior produtividade
Código mais consistente e legível para toda a equipe

Embora seja possível sobrescrever essas convenções usando opções de configuração, fazê-lo significa abrir mão dos benefícios automáticos que o framework oferece.

Conclusão

As convenções de nomenclatura do Rails podem parecer estranhas no início, mas elas foram cuidadosamente projetadas para aumentar a produtividade e melhorar a comunicação entre todas as partes envolvidas no desenvolvimento. Uma vez que você se acostuma com elas, torna-se natural e você começa a apreciar como elas simplificam seu trabalho.

Se você está começando com Rails, meu conselho é: resista à tentação de "fazer do seu jeito" e abrace as convenções. A produtividade que você ganhará vale o pequeno ajuste inicial.

Ruby: Uma Linguagem Puramente Orientada a Objetos

Marcos Fernandes — Wed, 21 May 2025 13:37:01 +0000

Ruby é frequentemente descrita como uma linguagem elegante, expressiva e com uma sintaxe que prioriza a legibilidade e produtividade do desenvolvedor. Mas o que realmente destaca Ruby no universo das linguagens de programação é seu compromisso total com o paradigma orientado a objetos. Vamos explorar o que isso significa e como isso molda a experiência de programação em Ruby.

Tudo em Ruby é um Objeto

Diferentemente de outras linguagens que se dizem orientadas a objetos como Java, JavaScript e Python, em Ruby absolutamente tudo é um objeto. Não existem tipos primitivos ou básicos que se comportam de maneira diferente.

Números, strings, booleanos, até mesmo o valor nil (equivalente ao null de outras linguagens) - todos são objetos completos com seus próprios métodos e comportamentos. Isso significa que você pode fazer algo como:

-1234.abs    # => 1234
42.even?     # => true
"ruby".length # => 4

Essa consistência é o que torna Ruby uma linguagem puramente orientada a objetos.

Classes e Instâncias em Ruby

Em Ruby, você define uma classe para representar um conceito ou categoria. Imagine que estamos criando um sistema para uma jukebox:

class Song
  def initialize(name)
    @name = name
  end

  def play
    puts "Tocando a música #{@name}"
  end
end

song1 = Song.new("Ruby Tuesday")
song2 = Song.new("Enveloped in Python")

song1.play  # Saída: Tocando a música Ruby Tuesday

Cada instância tem seu próprio estado (guardado em variáveis de instância como @name), mas compartilha o comportamento definido na classe.

Sintaxe Limpa e Descomplicada

Ruby foi projetada para ter uma sintaxe concisa e natural:

Sem necessidade de ponto e vírgula no final das linhas
Parênteses são opcionais em chamadas de método (embora recomendados em casos menos simples)
Blocos de código são delimitados por palavras-chave como def e end, não por chaves
Indentação é uma questão de estilo, não de sintaxe (diferente de Python)

Por exemplo, um método simples em Ruby:

def cumprimentar(nome)
  "Olá, #{nome}! Bem-vindo ao mundo Ruby."
end

puts cumprimentar("Maria")  # Saída: Olá, Maria! Bem-vindo ao mundo Ruby.

Strings e Interpolação

Ruby oferece diversas maneiras de criar strings:

Aspas simples ('string'): processamento mínimo
Aspas duplas ("string"): permite sequências de escape (\n) e interpolação

A interpolação é uma característica poderosa que permite inserir expressões dentro de strings:

nome = "João"
idade = 30
puts "#{nome} tem #{idade} anos e #{idade >= 18 ? 'é maior de idade' : 'é menor de idade'}"
# Saída: João tem 30 anos e é maior de idade

Arrays e Hashes: Coleções Fundamentais

Ruby oferece duas estruturas principais para coleções:

Arrays

frutas = ["maçã", "banana", "laranja"]
puts frutas[0]  # Saída: maçã
frutas[1] = "morango"
puts frutas.inspect  # Saída: ["maçã", "morango", "laranja"]

Hashes

instrumento_secao = {
  "violoncelo" => "cordas",
  "clarinete" => "madeiras",
  "bateria" => "percussão",
  "trompete" => "metais"
}

puts instrumento_secao["clarinete"]  # Saída: madeiras

Símbolos: Identificadores Eficientes

Símbolos são um tipo especial em Ruby, semelhantes a strings, mas otimizados para serem usados como identificadores:

# Usando símbolos como chaves em um hash
instrumento_secao = {
  :violoncelo => "cordas",
  :clarinete => "madeiras",
  :bateria => "percussão"
}

# Sintaxe moderna para hashes com símbolos
instrumento_secao = {
  violoncelo: "cordas",
  clarinete: "madeiras",
  bateria: "percussão"
}

puts instrumento_secao[:clarinete]  # Saída: madeiras

Os símbolos são imutáveis e únicos em memória, tornando-os ideais para chaves de hash e identificadores.

Expressões Regulares Integradas

Ruby tem suporte nativo para expressões regulares, tornando a manipulação de texto muito mais poderosa:

if "programando em ruby" =~ /ruby|rust/
  puts "Linguagem de programação mencionada!"
end

texto = "Python é incrível"
novo_texto = texto.gsub(/Python/, 'Ruby')
puts novo_texto  # Saída: Ruby é incrível

Blocos: O Superpoder de Ruby

Os blocos são um dos recursos mais distintivos e poderosos de Ruby. São trechos de código que podem ser passados para métodos:

# Bloco de uma linha com chaves
[1, 2, 3, 4, 5].each { |numero| puts numero * 2 }

# Bloco multilinhas com do/end
[1, 2, 3, 4, 5].each do |numero|
  resultado = numero * 2
  puts "O dobro de #{numero} é #{resultado}"
end

Os blocos são usados extensivamente na biblioteca padrão para operações como enumeração:

animais = ["gato", "cachorro", "cavalo"]
animais.each { |animal| print animal, " " }  # Saída: gato cachorro cavalo 

5.times { print "*" }  # Saída: *****

Estruturas de Controle

Ruby oferece as estruturas de controle tradicionais, mas com uma sintaxe mais limpa:

hoje = Time.now

if hoje.saturday?
  puts "Fazer tarefas domésticas"
elsif hoje.sunday?
  puts "Relaxar"
else
  puts "Ir trabalhar"
end

# Modificadores de declaração para código mais conciso
puts "Perigo, Robinson!" if radiacao > 3000

Entrada e Saída Simplificadas

Ruby facilita a leitura e escrita de dados:

# Saída
puts "Olá, mundo!"  # Com quebra de linha
print "Sem quebra"  # Sem quebra de linha

# Entrada
nome = gets.chomp  # Remove a quebra de linha
puts "Olá, #{nome}!"

# Processando arquivos linha por linha
while (linha = gets)
  puts linha.downcase
end

Conclusão

Ruby é uma linguagem que abraça completamente o paradigma orientado a objetos, proporcionando uma experiência de programação consistente, expressiva e agradável. A sua sintaxe clara e recursos poderosos como blocos, expressões regulares nativas e símbolos a tornam uma escolha excelente para diversos tipos de projetos.

O foco da linguagem na elegância e simplicidade reflete a filosofia do seu criador, Yukihiro "Matz" Matsumoto: "Ruby foi projetado para tornar os programadores felizes." E, de fato, muitos desenvolvedores descobrem uma nova alegria na programação quando começam a explorar o mundo Ruby.

Se você está buscando uma linguagem que combine poder, flexibilidade e elegância, Ruby merece um lugar especial em seu arsenal de ferramentas de desenvolvimento.

Entendendo a Arquitetura MVC no Ruby on Rails: A Base para Aplicações Web Robustas

Marcos Fernandes — Wed, 21 May 2025 13:34:57 +0000

Se você está começando no desenvolvimento web com Ruby on Rails, ou mesmo se já tem alguma experiência, entender profundamente a arquitetura MVC (Model-View-Controller) é fundamental para criar aplicações organizadas, escaláveis e fáceis de manter. Neste artigo, vamos desvendar como o Rails implementa esse padrão de design e por que ele é tão poderoso.

O que é a Arquitetura MVC?

A arquitetura MVC é um padrão de design que separa uma aplicação em três componentes principais:

Model (Modelo): Gerencia os dados e a lógica de negócios
View (Visão): Exibe as informações ao usuário
Controller (Controlador): Orquestra a aplicação, recebendo eventos do mundo externo e coordenando o modelo e a visão

Este "triunvirato" — modelo, visão e controlador — trabalha em conjunto para criar uma separação clara de responsabilidades, resultando em código mais limpo e manutenível.

Como Funciona o MVC no Rails?

O Ruby on Rails é um framework MVC por excelência. Ele impõe uma estrutura para sua aplicação: você desenvolve modelos, visões e controladores como partes separadas de funcionalidade, e o Rails os conecta durante a execução do programa.

Um dos grandes benefícios do Rails é que este processo de integração é baseado no uso de convenções inteligentes, eliminando a necessidade de configurações externas. Como diz a filosofia do Rails: "Convenção sobre configuração".

O Fluxo de uma Requisição no Rails

Vamos entender como uma requisição é processada em uma aplicação Rails:

Roteamento: Quando uma requisição chega (por exemplo, quando um usuário clica em "Adicionar ao Carrinho"), ela é enviada primeiro para o roteador, que determina qual controlador deve ser acionado.
Controlador: O controlador apropriado recebe a requisição e executa a ação correspondente. Por exemplo, o método create() em um controlador de itens de linha.
Interação com o Modelo: O controlador interage com o modelo para acessar ou modificar dados (como adicionar um produto ao carrinho de compras).
Preparação para a Visão: O controlador prepara as informações necessárias para a visão.
Renderização: A visão é renderizada e enviada de volta ao navegador do usuário.

Métodos HTTP no Rails

No Rails, diferentes métodos HTTP são associados a diferentes ações:

GET: Para recuperar informações
POST: Geralmente associado a ações de criação
PUT/PATCH: Para atualizar registros
DELETE: Para remover registros

Por convenção, quando recebemos uma requisição POST para um recurso, o Rails sabe que deve invocar o método create() no controlador correspondente.

O Poder do Scaffolding

Uma das ferramentas mais poderosas do Rails é sua capacidade de gerar "scaffolding" — código básico para modelos, visões e controladores com operações CRUD completas. Isso permite que você comece rapidamente com uma estrutura funcional e a refine conforme necessário.

Conclusão

A arquitetura MVC implementada pelo Ruby on Rails oferece uma estrutura clara e organizada para o desenvolvimento de aplicações web. Ao separar claramente as responsabilidades entre modelo, visão e controlador, o Rails facilita a criação de código modular, testável e manutenível.

Esta abordagem é como construir um arranha-céu com as vigas já no lugar — fica muito mais fácil pendurar o resto das peças quando a estrutura já está lá. E com as convenções inteligentes do Rails, você pode se concentrar em construir recursos exclusivos para sua aplicação, em vez de se preocupar com a configuração da infraestrutura.

Se você está começando com Rails, recomendo fortemente que dedique tempo para compreender profundamente o MVC — este conhecimento será a base sobre a qual você construirá aplicações web robustas e elegantes.

E você, já trabalhou com Ruby on Rails ou outros frameworks MVC? Compartilhe suas experiências nos comentários!