Tudo o que eu quero no Natal é o Ruby 3

Quer você comemore o Natal ou não, é difícil não ouvir a clássica música da Mariah Carey, “All I Want For Christmas Is You”, tocando nas lojas de departamento, no rádio ou praticamente em qualquer lugar que você vá. Para os entusiastas da linguagem Ruby, essa época do ano tem um significado totalmente diferente, pois o Natal é quando podemos esperar um novo lançamento importante do Ruby. Este ano não é exceção, e o lançamento principal de 2020 é realmente bastante significativo.

O Ruby 3 está causando grande entusiasmo em todo o universo Ruby e enchendo o coração de cada Rubyista de alegria e expectativa ansiosa. Aqui na Vonage, somos grandes fãs do Ruby. Temos um conjunto completo de ferramentas de código aberto que desenvolvemos em Ruby, incluindo um renderizador de especificações OpenAPI, um renderizador de Markdown e uma ferramenta de plataforma para desenvolvedores. Todas essas ferramentas se somam ao nosso SDK Ruby para as APIs da Vonage e ao nosso SDK Ruby para a Video API da Vonage.

Resumindo: adoramos o Ruby e estamos transbordando de alegria com o lançamento iminente do Ruby 3.

O que nos deixa tão animados? Embora eu não possa falar em nome dos outros programadores Ruby da equipe de Relações com Desenvolvedores da Vonage (temos vários fãs de Ruby na equipe!), posso falar por mim mesmo. Algumas das razões pelas quais estou tão entusiasmado com o dia 25 de dezembro deste ano são:

• Assinaturas Ruby (RBS)

• Ruby Actors (Ractors)

• Mais correspondência de padrões

Vamos analisar cada um deles.

Assinaturas Ruby (RBS)

Há muitos meses que vemos explorando os benefícios de adicionar a verificação de tipos estáticos aos nossos projetos Ruby da Vonage. Foi em fevereiro deste ano que lançamos a versão 6.3.0 do SDK Ruby das APIs da Vonage, que incorporava o Sorbet à biblioteca pela primeira vez. Descrevemos em nossa postagem no blog na época quais foram nossos motivos para fazer isso:

A introdução da verificação de tipos estática no SDK do Ruby visa aumentar a confiança nas chamadas de API que você realiza com o SDK e ajuda tanto a reduzir quanto a identificar erros à medida que eles ocorrem.

Em outras palavras, acreditávamos naquela época e continuamos acreditando hoje que, com uma combinação de tratamento claro de exceções, documentação concisa e tipos definidos para os métodos que encapsulam as chamadas à API, podemos reduzir as dificuldades no uso do SDK para desenvolver aplicativos e serviços de comunicação. Quanto mais complexo for o recurso que você está tentando implementar, maior será a probabilidade de haver parâmetros complexos em sua chamada de API, e queremos que o próprio SDK o oriente sobre como elaborar essa chamada com sucesso, sem que você tenha que bater a cabeça na parede... muitas vezes.

O Ruby 3 leva a verificação de tipos a um nível totalmente novo, incorporando-a diretamente na própria linguagem. Enquanto o Sorbet exigia a adoção de uma gem externa na aplicação, o Ruby agora oferecerá suporte nativo a tipos. Isso será feito por meio do Ruby Signatures, ou RBS, para abreviar. Por exemplo, eis como um método do nosso SDK do Ruby poderia se parecer usando o RBS:

def unicode?: (String, text) -> bool
  !Vonage::GSM7.encoded?(text)
end

Este pequeno método da nossa classe SMS verifica se há um true ou false valor em um String parâmetro. Assim, com o RBS, o parâmetro é tipado com sua definição de String, e o método é tipado para retornar um bool, representando um valor booleano.

A capacidade de adicionar, de forma incremental, a verificação de tipos a todos os nossos projetos em Ruby, utilizando a própria linguagem e sem recorrer a nenhuma outra dependência externa, nos permitirá obter ainda mais benefícios em termos de desempenho e estabilidade para nossas Applications.

Ruby Actors (Ractors)

Programação paralela com segurança de threads em Ruby? Sim, é verdade! Sejam bem-vindos ao maravilhoso e novo mundo experimental do Ruby Actor, ou Ractor, para abreviar. Os Ractors permitem a execução simultânea dentro da sua aplicação Ruby. Esse é um grande avanço para a linguagem Ruby em geral, com muitos casos de uso em potencial. O exemplo fornecido no Notas de Lançamento do Ruby 3.0 Preview 1 resume bem isso:

require 'prime'

# n.prime? with sent integers in r1, r2 run in parallel
r1, r2 = *(1..2).map do
  Ractor.new do
    n = Ractor.receive
    n.prime?
  end
end

# send parameters
r1.send 2**61 - 1
r2.send 2**61 + 15

# wait for the results of expr1, expr2
puts r1.take #=> true
puts r2.take #=> true

No exemplo acima, estamos verificando se um determinado número inteiro calculado é um número primo. O Ractor é inicializado com um #new bloco e, dentro dele, chamamos #receive a classe Ractor. O #receive método, juntamente com seu #send , é por meio dele que as mensagens são transmitidas nos Ractors. Após invocar #receive, a tarefa final no #new bloco é chamar #prime? no número que está sendo recebido pelo Ractor.

O número é enviado ao Ractor para avaliação. Neste exemplo, há dois Ractors inicializados, cada um utilizando o #send método e passando o objeto a ser enviado.

O valor é extraído do Ractor por meio do #take método, que é o que ocorre nas duas últimas linhas do exemplo acima.

Antes, não seria possível fazer isso em Ruby de forma simultânea, mas agora, no contexto do Ruby Actor, tanto r1 e r2 podem ocorrer como duas execuções não bloqueantes e seguras para threads.

Mais correspondência de padrões

Foi na versão 2.7 do Ruby que finalmente ganhamos a correspondência de padrões no Ruby. Para desenvolvedores que já tinham experiência com outras linguagens que utilizam amplamente a correspondência de padrões (como o Elixir, por exemplo), isso foi um grande avanço. O que é correspondência de padrões? Um post no blog de Agnieszka Malszkiewicz explica isso de forma sucinta:

A correspondência de padrões é uma forma de especificar um padrão para nossos dados e, se os dados corresponderem a esse padrão, podemos decompor esses dados de acordo com ele.

Angnieszka prossegue explicando em detalhes como aproveitar a correspondência de padrões no Ruby desde a versão 2.7, com muitos exemplos. Recomendo vivamente que você dê uma olhada no post dela.

A estrutura básica da correspondência de padrões no Ruby é a seguinte:

case expression
in pattern
  do something
in pattern
  do something else
else
  otherwise do this
end

Com o Ruby 3, temos ainda mais funcionalidades adicionadas à correspondência de padrões com a introdução do padrão `find` no Ruby. Para ver como isso funciona, vamos criar um pequeno exemplo.

Talvez tenhamos um objeto que contenha uma matriz com vários elementos, e queiramos fazer uma correspondência de padrões com ele:

today = {weather: 'Sunny', drinks: [{name: 'Espresso', daily_frequency: 3}, {name: 'Cold Brew', daily_frequency: 2}, day: 'Tuesday']}

Se tentássemos fazer uma correspondência de padrão para algo dentro da drinks array, retornaríamos um NoMatchingPatternError. Agora, utilizando o padrão `find`, podemos fazer a correspondência com itens que tenham vários elementos:

case today
in {weather: 'Sunny', drinks: [*, {name: 'Cold Brew', daily_frequency: frequency}, *], *}
  puts "#{frequency} times a day"
end

# => 2 times a day

Correspondência de padrões, Ractors e verificação de tipos integrada são apenas alguns dos novos recursos incríveis e melhorias que chegarão ao Ruby nesta época de festas. O que mais te deixa animado? O que você está ansioso para experimentar e desenvolver? Venha participar da conversa na nossa Slack da Comunidade Vonage ou me mande uma mensagem no Twitter.

Se você tiver curiosidade em conhecer nosso trabalho com Ruby, venha conferir nossas ferramentas de código aberto desenvolvidas em Ruby no GitHub:

• Estação

• Renderizador Markdown da Nexmo

• Nexmo OAS Renderer

• SDK do Ruby para as APIs da Vonage

• Gem Vonage para Rails

• Middleware do Vonage Rack

• Gerador de JWT da Vonage para Ruby

Boa programação e boas festas!