Ruby Lessons #1 – Introdução

Algumas coisas importantes sobre o Ruby:

#1.1 Origem

Surgiu em 1995, criada pelo japonês Yukihiro Matsumoto. O intuito era criar uma linguagem natural, que facilitasse a leitura e manutenção do código. Para isto, juntou boas características de outras linguagens de programação e criou uma nova que acabou se tornando um grande sucesso. Além disso, é totalmente gratuita para usar, copiar, modificar e distribuir.

#1.2 É uma linguagem interpretada

Necessita da instalação de um interpretador que pode ser encontrado no site oficial. Pulando os detalhes da instalação em cada plataforma, para executar um código Ruby, pode-se utilizar:

  • O shell interativo (IRB) que acompanha a instalação padrão
irb(main):001:0> 'Hello World'
=> "Hello World"
  • Ou salvar os scripts em arquivos .rb e executá-los através do interpretador “ruby” ou “ruby.exe”
$ ruby hello.rb
Hello World
  • Uma outra opção para executar scripts interativamente, com muito mais recursos: Pry

#1.3 É uma linguagem orientada a objetos

Como não poderia deixar de ser. Aliás, tudo em Ruby é um objeto. Isto significa que, além de podermos utilizar todos os recursos da orientação a objetos, podemos chamar métodos ou acessar atributos sobre qualquer coisa, até mesmo constantes literais, como 1 ou ‘foo’:

irb(main):001:0> 1.equal? 2
=> false
irb(main):002:0> 'foo'.upcase
=> "FOO"

Mas o Ruby é flexível o suficiente para permitir diferentes estilos de codificação, se assemelhando à programação funcional ou procedural quando necessário. Para scripts pequenos, por exemplo, é possível escrever algo semelhante a isto:

print 'Digite seu nome: '
nome = gets
puts nome

Onde print, gets e puts são métodos da classe Kernel, embutida no interpretador. Isto fica completamente transparente para o desenvolvedor.

#1.4 É uma linguagem simples e expressiva

Como dito anteriormente, o objetivo era criar uma linguagem natural, fácil de entender. Por consequência, a linguagem é extremamente simples de ler e escrever mas também extremamente poderosa.

#1.5 É uma linguagem dinâmica, fortemente e implicitamente tipada

Não é necessário declarar tipos. Eles são inferidos pelo interpretador. Nem é necessário declarar uma variável para utilizá-la. A simples inicialização é suficiente para que o interpretador saiba qual é o escopo e o tipo do objeto.

irb(main):003:0> numeros = [1, 2, 3]
=> [1, 2, 3]
irb(main):004:0> numeros.class
=> Array

O dinamismo da linguagem também permite adicionar métodos a classes existentes em tempo de execução (metaprogramação). Isto também vale para as classes das bibliotecas padrão:

  class Numeric
    def inverso
      1.0 / self
    end
  end

  # inverso agora é um metodo válido para qualquer número
  print 2.inverso
  0.5

Fortemente tipada porque, apesar de sua tipagem dinâmica, os tipos importam para o interpretador. O que é número, é número. O que é string, é string e assim por diante. Conversões entre tipos não são feitas implicitamente.

#1.6 Gems

Numa linguagem chamada Ruby, é bem sugestivo o nome “gem” (jóia, pedra preciosa) para um pacote de código. Aqui, quando falamos de pacotes, estamos nos referindo quase sempre a uma biblioteca de classes. Também pode ser um aplicativo. Numa gem, todo o código está empacotado para facilitar a distribuição, instalação e manipulação de versões.

O gerenciador de pacotes oficial do Ruby é o RubyGems. Ele é um framework para gerenciamento das gems com um repositório online onde elas são publicadas para serem reutilizadas em qualquer projeto. Depois de instalado o Ruby, é recomendável atualizar o RubyGems para a ultima versão. A maneira mais fácil de fazer isto é pelo comando:

$ gem update --system

Para instalar ou atualizar uma gem, usamos estes comandos:

$ gem install gem_name
$ gem update gem_name

Onde gem_name é o nome da gem, conforme informado pelo desenvolvedor.

Por exemplo, para instalar uma gem para comunicação com o Twitter, o comando seria este:

$ gem install twitter

Lembrando que a gem ‘twitter’ é apenas uma entre as várias existentes.

Para usar o código desta gem num aplicativo, usamos o método require no início do código fonte:

require 'twitter'

Twitter.configure do |config|
  config.consumer_key = YOUR_CONSUMER_KEY
  config.consumer_secret = YOUR_CONSUMER_SECRET
  config.oauth_token = YOUR_OAUTH_TOKEN
  config.oauth_token_secret = YOUR_OAUTH_TOKEN_SECRET
end

Twitter.update("Twittando com #ruby!")

Mais informações sobre como usar o RubyGems, inclusive para criar e publicar novas gems, podem ser encontradas nos guias do RubyGems.

#1.7 Bundler

Para não ter que incluir dentro de cada projeto todas as gems utilizadas e ter sempre as versões corretas das gems, existe o Bundler, um gerenciador de dependências que ajuda a manter um ambiente consistente para a execução dos aplicativos.

Instalando o Bundler (repare queo Bundler também é uma gem!):

$ gem install bundler

As dependências são especificadas no arquivo Gemfile que deve ficar na raiz do projeto. O Gemfile deve conter o endereço da fonte onde buscar as gems, seguido da especificações de cada gem. Exemplo:

source 'https://rubygems.org'
gem 'nokogiri'
gem 'rack', '~>1.1'
gem 'rspec', :require => 'spec'

Para instalar ou atualizar todas as gems necessárias ao projeto, usamos o comando:

$ bundle install

Esta foi a primeira lição. Até a próxima!

Ruby Lessons

Official Ruby logo
Official Ruby logo (Photo credit: Wikipedia)

Esta é uma série de posts sobre a linguagem de programação Ruby. A ideia é registrar, em pequenas textos, os meus estudos sobre a linguagem. Incentivado pela iniciativa da Tecsystem em promover o RubyLab – treinamento em Ruby/Rails – entre a equipe de desenvolvimento, resolvi conhecer mais a fundo o Ruby. Depois vamos estudar, é claro, o framework Rails mas por enquanto é preciso criar bases sólidas nesta linguagem que é nova para todos da equipe, inclusive eu. Por isso, o conteúdo postado aqui será de um iniciante em Ruby. Dicas e sugestões são sempre bem vindas. Talvez possa servir para consulta futura mas o principal objetivo é estudar e compartilhar, fixando os conceitos através de exemplos práticos.

O que possibilita toda essa simplicidade do Rails são os recursos poderosos que Ruby oferece e que deram toda a simplicidade ao Rails. Esses recursos proporcionados pela linguagem Ruby são fundamentais de serem compreendidos por todos que desejam se tornar bons desenvolvedores Rails[…] – Caelum

Formato

Livros e tutoriais ensinando a programar em Ruby existem aos montes. Minha intenção não é criar mais um e sim reunir os pontos que acho mais importantes para se chegar mais rápido ao domínio da linguagem e compartilhar. Então resolvi organizar o conteúdo em pequenas lições. Cada lição vai ter alguns tópicos curtos sobre algum aspecto da linguagem ou das suas bibliotecas. Cada tópico vai ter um trecho de código demonstrando como funciona na prática, usando testes. Acredito que ficará mais intuitivo aprender desta maneira. Todo o código produzido vai estar disponível no GitHub.

Veja as lições já publicadas:

Por que não Delphi?

Antes de qualquer coisa, quero esclarecer que pretendo escrever aqui mais sobre conceitos, metodologias, padrões e coisas afins e menos sobre tecnologias. Estas vão e vem num espaço de tempo relativamente curto e não podemos ficar presos a elas. Os conceitos independem delas e nos ajudam a utilizar melhor todas as tecnologias disponíveis. Contudo, tenho observado como algumas pessoas se demonstram avessas a determinadas linguagens ou frameworks, favorecendo outros. E é exatamente isto que eu não quero fazer. O objetivo aqui não é defender o Delphi, mas lançar a ideia de que todos os recursos que estejam ao nosso alcance podem ser muito bem utilizados em qualquer projeto, desde que a solução atenda aos requisitos. Falo do Delphi por ser a ferramenta com a qual trabalho há muitos anos, embora conheça outras linguagens.

A ideia deste post surgiu justamente por causa da reação de algumas pessoas ao ouvirem falar da ferramenta criada pela Borland. O projeto que desenvolvo hoje é único no segmento no Estado por ter funcionalidades que ainda não foram implementadas em nenhum outro sistema similar. O mesmo poderia ser feito em Java, C#, Python ou qualquer outra linguagem. Isto não é o mais importante.

Depois que surgiram algumas linguagens de programação mais recentes, muitos tendem a dizer que o Delphi está ultrapassado. Eu afirmo que não, por alguns motivos:

Cada desenvolvedor ou empresa pode escolher o que julgar mais adequado para desenvolver seus projetos. A escolha pode ser feita pela afinidade da equipe com determinada linguagem, por querer usar algo mais inovador ou por outros motivos. É uma questão de viabilidade.

Lembro-me que há aproximadamente dois anos, numa palestra na UNES, o então presidente da SOFTES – associação que reúne as empresas de desenvolvimento de software do sul do Espírito Santo – apresentou uma visão geral sobre o mercado de trabalho na região. Ao afirmar que grande parte das empresas associadas ainda utilizava o Delphi em seus projetos, ele enfatizou que os sistemas atendiam muito bem a demanda dos clientes e iriam continuar atendendo por um bom tempo. Isso continua sendo verdade.

Não faz muito tempo, li um artigo que questionava: “O Delphi está morto?”. O autor (cujo nome não me lembro) respondeu que não e que ainda há espaço para ele. Acrescento dizendo que ainda há espaço para todos!

Também vi pessoas que se especializaram em .Net o defenderem como a oitava maravilha do mundo. Eu mesmo tenho estudado muito sobre ASP.Net. É realmente muito confortável desenvolver utilizando as ferramentas da Microsoft, mas há muitas outras opções. Neste momento estou testando o Delphi XE para avaliar os novos recursos. Mesmo que ele não seja adotado como a ferramenta de desenvolvimento no meu trabalho, valeu a pena conhecer a nova versão.

Em resumo, o título lá em cima é a pergunta que eu gostaria de fazer a alguns desenvolvedores. Uma tecnologia pode ser considerada a mais indicada para qualquer tipo de projeto? É justo deixar uma linguagem de lado apenas porque ela não está entre as mais “modernas”? Sou a favor da evolução, mas não sou radical.

Comentem!