É importante não generalizar a linguagem Ruby como se fosse algo que resolverá todos os seus problemas. Ela tem propósito geral, mas será adequada em determinados contexto e outros não, como todas as outras linguagens. O propósito desse post do Kate Cunningham que eu traduzi é mostrar que as características do Ruby são muito harmônicas com as características necessárias em um ambiente efetivo de aprendizado. Isso não quer dizer que o aluno deva estacionar no Ruby. Ele terá o caminho facilitado para o mundo da programação com Ruby, mas isso será só o primeiro passo. Ele deverá sim, aprender outras linguagens, pois é a única forma de se aprimorar como profissional de uma área tão dinâmica. O texto original você encontra aqui. Fique agora com a tradução:

A linguagem Ruby tem recebido muita atenção na última década, especialmente com o advento do Ruby on Rails em 2005. Enquanto a blogosfera está utilizando Ruby a muito tempo, vamos nos perguntar como, exatamente, a linguagem Ruby é propícia para um ambiente educacional.

Copyright (C) 2008 Ruby Association LLC

Claro, podemos ir para a relevância da linguagem Ruby, pois se você está recebendo treinamento em um ambiente educacional para se tornar um programador de computador, e você não sabe o Ruby, então você está ficando cada vez mais fora do circuito. No entanto, linguagens de programação vêm e vão, e educação não é sobre as tendências, é sobre as idéias que sustentam o valor no decorrer dos anos.

Vamos então olhar para a filosofia de linguagem Ruby e ver como é propício à aprendizagem. Por um lado, Ruby é flexível. Ele não tem a rigidez de Java ou PHP. Em um ambiente que maximiza o aprendizado, a flexibilidade é fundamental. E Ruby é tão flexível quanto possível. Yukihiro Matsumoto, o  criador da linguagem Ruby, notou o que ele estava pensando quando ele começou a trabalhar com linguagem de programação: “É engraçado, quando eu usei PHP para desenvolver ou as coisas que eu fiz em Java, eu estava sempre à procura de algo mais.”

Outra grande coisa sobre Ruby é seu reforço da capacidade para a criatividade. Como muitos programadores Ruby notaram, Ruby é mais alinhado com o pensamento humano. Desta forma, é muito fácil de usar. E precisamente porque é mais fácil de usar, é mais versátil quando se trata de ser criativo.

A apresentação de slides sobre a linguagem Ruby explica como Ruby auxilia a criatividade. Afirma que os seres humanos perdem produtividade quando são forçados por “tarefas repetitivas, tarefas desnecessariamente complexas  e resolvendo problemas que não estão dentro do domínio de aplicação.” Desde que Ruby efetivamente se livra dessas tarefas repetitivas e de tarefas voltadas para máquinas, há mais espaço aberto para ser criativo. Com os alunos, especialmente, a produção criativa é a chave para a aprendizagem de forma eficaz.

Um aspecto do processo de aprendizagem que é absolutamente crítico para a eficácia educacional é diversão. Nós geralmente não pensamos sobre a diversão quando nós pensamos sobre a educação. Mas reflita sobre seus próprios anos escolares no passado. Se você pensar bem, você percebe que os assuntos que você aprendeu mais e reteve o conteúdo eram aqueles em que você estava se divertindo. Este divertimento, claro, resulta em parte da criatividade. Quando você está sendo produtivo, você está se divertindo.

Ao contrário de outras linguagens de programação, você pode fazer muita coisa com Ruby, mesmo se você está apenas nos estágios iniciais de aprendizagem. Para os estudantes, o processo de aprendizagem é frustrante e é um pouco prejudicado quando pequenos erros aparecem no caminho de chegar aos conceitos maiores. Linguagens de programação como C++ podem dificultar o aprendizado dos conceitos maiores porque pequenos erros no código sempre aparecem durante o processo. Já usando o  Ruby o aluno não passa por essas pequenas dificuldades quando está iniciando o aprendizado.

Naturalmente, estes são apenas indicações básicas de que Ruby é a melhor ferramenta de aprendizagem para os interessados em programação de computadores, especialmente os iniciantes. No entanto, assim como na educação como um todo, em que mudanças conceituais básicas no processo de aprendizagem levam os alunos para as melhores práticas na aprendizagem,  Ruby oferece a possibilidade de uma aprendizagem fácil, divertida, criativa, por força da simples virtude de que a linguagem foi feita para pragmaticamente funcionar dessa forma. Em análise final, Ruby foi feito para estudantes, jovens e idosos, iniciantes e mais avançados.

Por Kate Cunningham

Esse mini-livro é uma jornada linha a linha, teste por teste, utilizando a técnica do Desenvolvimento Orientado a Comportamento (Behavior Driven Development) em um projeto muito interessante: Simulação dos dados do jogo War!

Eu escrevi esse pequeno livro para aprender BDD e RSpec, por isso eu tinha que falar sobre algo simples e de preferência que fosse divertido. Então eu pensei: Por que não jogar dados! Porque não jogar dados do jogo War!
Então aqui está: Aprenda BDD jogando dados!

A aplicação que nós criaremos juntos usa duas classes: Dice e WarDice. No primeiro capítulo eu construo o arquivo RSpec da classe Dice e a classe Dice simultaneamente e passo a passo até todos os testes tornarem-se verdes.

No segundo capítulo eu continuo o desenvolvimento com a classe WarDice, aquela que fará a simulação de cada dado do jogo war!

Finalmente, no terceiro capítulo eu uso as classes criadas em uma divertida aplicação feita em shoes. A filosofia desse livro é aprender fazendo coisas divertidas. Em uma palavra: Experimentação.

Então eu espero que você aproveite esse livro simples mas também muito instrutivo. Os testes usados nesse livro não são uma solução definitiva. Eles são somente possibilidades no meio de outras. Como eu disse, eu o escrevi para aprender RSpec. Você pode enviar sugestões, clonar o projeto, modificá-lo e codificá-lo de outra forma. Quem sabe não faremos juntos a versão 2.0 desse livro .

Fique agora com o livro:

O código fonte completo da aplicação você pode baixar em:
http://github.com/valeriofarias/shoes-war-dice

O texto completo do livro e o código fonte do gerador de livros você pode baixar em:
http://github.com/valeriofarias/learn-bdd-playing-dice-book

se preferir pode também baixar a versão em inglês do livro:
http://valeriofarias.com/learn-bdd-playing-dice-ebook/

I wrote this tiny book to learn BDD and RSpec for myself. I would want to start with a little example. And if was possible with a funny example too. Then I thought: Why not playing dice! Why not playing war dice! Then there you are: Learning BDD playing dice!

The app that we’ll create together uses two classes: Dice and WarDice.

The first chapter I start to construct the RSpec file of Dice class and the Dice class simultaneously and step by step until all of the tests become green.

The second chapter I go on with the WarDice class, that is a simulation of each dice of war game!

Finally, the third chapter I use the classes in a funny shoes application.

The philosophy of this book is to learn making funny things. In one word: Experimentation. Then I hope you enjoy this simple but also instructive book.

The tests used in this book aren’t a silver bullet. They are only a way between some others. How I told, I made to learn RSpec. You can send suggests, clone the project, modify it and codify in other ways. Who knows we’ll playing together in the 2.0 version of this book .

Now just read the book and have fun!

The complete source code of application you can download in
http://github.com/valeriofarias/shoes-war-dice/tree

The complete ebook text and source code you can download in:
http://github.com/valeriofarias/learn-bdd-playing-dice-book

Quem vem linguagens como C, Java, Delphi, C# e usa a linguagem Ruby pela primeira vez, tende a programar em Ruby do mesmo jeito que programava na linguagem que já era fluente. Lendo o post abaixo você perceberá que linguagens que tem características  funcionais, como o Ruby, possibilitam formas próprias de organizar o código (Jeito Ruby) , mais especificamente nesse texto, escrito por Jon Dahl, você verá as formas mais eficientes de fazer iterações (loops) em Ruby. A versão original você encontra aqui. Fique agora com a tradução:

Se você é um programador, você provavelmente já trabalhou com um ou mais livros que te ensinava a sintaxe de uma nova linguagem. Eu tive essa experiência com uma meia dúzia de linguagens, como C, Javascript e Perl.
Estes livros tipicamente introduzem loops no meio da discussão de sintaxe, depois de tipos de dados e controle de fluxo, mas antes de I/O e de recursos avançados.

Loops são quase sempre apresentadas de acordo com esta fórmula:

Texto introdutório: “E se você quiser fazer uma operação mais de uma vez”?
Introduz o loop while, mostrando a diferença entre do while e while do.
Apresenta o laço for, o primo louco do while.

(Bonus) Introduz o laço foreach se a linguagem é suficientemente de alto nível. E é isso – você sabe como fazer um loop através de código e é hora de seguir em frente.

Não tão rápido. Se você for sortudo o bastante para usar uma linguagem que possui traços de programação funcional, você não deve usar um laço dessa maneira.

O ponto
De agora em diante, eu vou usar Ruby para exemplos, mas este artigo não é sobre Ruby. É sobre a transição de loops primitivos para iterar usando coleções, e sobre a transição de funções genéricas (como each) para funções mais específicas (como map).

De loops para métodos que percorrem a própria lista
Durante os últimos meses, estive trabalhando no Tumblon, uma aplicação Rails de porte médio. Eu trabalhei em 15-20 aplicações Ruby nos últimos três anos, provavelmente, totalizando 50.000 linhas de código Ruby.

Eu só usei um laço primitivo uma vez.

Esse laço primitivo era um loop{} loop, sempre percorrer uma lista tarefas à procura do que executar. Em outras palavras, um laço sem nenhuma condição de saída além de ^C, ou uma falha do servidor.

Eu só usei um loop simples em um caso porque o conceito each geralmente é uma opção melhor. Essa implementação Ruby será familiar para quem já viu código Ruby antes:

["horse", "pig", "cow"].each  do |animal|
puts "Old MacDonald has a #{animal}"
end

(Sim, eu tenho uma criança pequena.)

Isto é muito mais enxuto do que as alternativas usando for e while. Ele representa melhor o que estamos fazendo: não estamos iterando com uma condição de saída, estamos interagindo entre os elementos de uma matriz. Mas e se você quiser fazer algo um número fixo de vezes? Você pode interpretar isso como percorrer a seguinte lista: [1,2,3,4,5,6,7,8,9,10].each{}. Mas claro que Ruby dispõe de uma versão mais simples para isso: 10.times{}.

Portanto, se seu loop rodar através de uma lista de algum tipo, each é a melhor abstração para esse tipo de problema. E, na minha experiência de construção de aplicações Ruby, a maioria dos loops percorrem listas. Parsing XML? Iterando por uma lista. Somando números? Iterando por uma lista. Leitura em um arquivo texto? Lendo o STDIN? Trabalhando com linhas em um banco de dados? Iterando por uma lista. Isso é o que o loop each faz bem.

Além do arr.each
Mas each não é a palavra final. É um passo acima das primitivas for ou while quando trabalha com o conjunto de valores, mas muitos loops each devem ser substituídos por outros métodos de array, como map, inject e select.

Quando each é útil? Simples: quando você quiser criar efeitos externos ao array, como salvar no banco de dados, imprimir um resultado na tela, ou enviar uma chamada de serviço web. Nestes casos, você não está preocupado com o valor de retorno; você deseja alterar o estado na tela, o disco, o banco de dados, ou outra coisa. Dê uma olhada neste código.

User.find(:all).each do |user|
Notification.deliver_email_newsletter(user)
end

Você não necessita que o código acima retorne valor, você só precisa que o e-mail seja entregue.

Mas não use each se você quer extrair algum valor novo de um array. Em vez disso, dê uma olhada em outros três métodos poderosos: map, inject e select.

Para entender vamos analisar o código abaixo que itera por um array e cria um novo array com elementos que correspondem a determinada condição, usando each.

active_users = []
users.each do |user|
active_users << user if user.active?
end
active_users

A primeira e última linhas são feias. Por que você tem que inicializar e retornar active_users? Resposta: porque este é um abuso (má utilização) do método each. Nesse caso é muito melhor você usar select (ou seu equivalente, find_all):

users.select do |user|
user.active?
end

Usando select o código fica menor, mais fácil de entender e menos propenso a erros. E mais importante, ele claramente encapsula um uso comum de each (e looping em geral).

Duas outras funções-chave: map e inject (ou reduce) – complementam select e seguem um padrão semelhante. E não é de surpreender que eles formam a base do paradigma mapreduce para processamento distribuído. Eu escrevi mais sobre map e reduce em outro artigo, e aqui é um atalho para saber quando usar essas funções:

Resumo
Use each para mudar o estado. Caso contrário use métodos funcionais de matriz que retorna um valor. Dessa forma seu código ficará mais limpo e menos propenso a falhas.

Aprendendo a refatorar

1. Inicializar um valor vazio, ou matriz, ou o que quiser (new_arr = [])
2. arr.each, alterando o valor inicializado
3. Devolver o valor (return new_arr)

Sempre que você detectar esse padrão, você sabe que existe um laço each que precisa ser substituído.

• Twitter -> John Nunemaker ( essa é a mais completa )
• Twittery – uma classe bem simplista que faz upload de fotos pela TwitPic’s API. Esse projeto é administrado por Chris Ledet

Eu tomei como base para aprendizado, a classe do projeto Twittery, pois queria uma solução rápida e simples. Apesar dela não ter a segurança do protocolo de autenticação oAuth que já consta no projeto de John Nuremaker.

A idéia foi a seguinte: colocar o código Ruby para ser pré-carregado no arquivo .irbrc toda vez que o irb for acionado via shell.

Depois de vários teste o código final você pode ver abaixo:

# twitting by irb
require 'net/http'

class Object
  def twitter_config(username, password)
    @username = username
    @password = password
  end

# the message must be between 1 and 160 characters
  def twitter(status = nil, format = 'json')
     if status.empty? or status.length > 160
        puts "twitter 'message with spaces'             (IRB)"
        puts "Obs. (The message must been less than 160 characters and cannot be empty)"
     else
        api_url = 'http://twitter.com/statuses/update.' + format
        url = URI.parse(api_url)
        req = Net::HTTP::Post.new(url.path)
        req.basic_auth(@username, @password)
        req.set_form_data({ 'status'=> status }, ';')
        res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
        puts res
     end
 end
alias :twit :twitter
end

twitter_config('username', 'password')

Os dados de usário e senha já são pré-carregados na inicialização do irb. A vantagem é que esses dados ficam ocultos no arquivo .irbrc, dando um pouquinho de privacidade, caso tenha alguém do lado.

Para “twittar” é só usar o seguinte comando, a qualquer momento, dentro do irb:

irb> twitter "mensagem via irb"

ou ainda

irb> twit "outra mensagem via irb"

Obs.: Esse exemplo usa a forma de autenticação mais simples, via HTTP. O twitter está em processo de mudança da autenticação para usar oAuth. A tendência é que a autenticação básica via HTTP deixe de ser usada, mas isso ainda vai demorar um pouco. Enquanto isso não acontece, vou continuar “twittando” por esse script via irb.

Fico por aqui.

Até a próxima.

• acionar o Vi ou o TextMate a partir do irb, permitindo que você escreva ou cole um código rapidamente, salve, feche o editor e já possa testar no irb, sem precisar criar arquivo e salvar em diretório.
• visualizar um histórico de comandos digitando “h”
• abrir o histórico no TextMate ou Vi usando hvi ou hmate
• assista ao screencast do Akita para ver o funcionamento

Até aí tudo bem, mas o grande problema é que eu uso ubuntu com gedit para escrever códigos ruby. E o utility-belt não possui métodos específicos para acionar o gedit. O help do utility belt dá a opção edit_interactively(:gedit), mas é claro que eu não poderia me contentar com esse método, eu queria que funcionasse da mesma forma que funciona para o Vi ou TextMate.

Pesquisando um pouco, achei um artigo que mostra como  abrir o editor nano do linux através do irb, extendendo o utility-belt. A partir dele eu fiz algumas modificações no arquivo .irbrc que vocês verão na sequência do Post.

A primeira etapa é instalar o utility-belt:

git clone git://github.com/akitaonrails/utility-belt.git
cd utility-belt
gem build utility_belt.gemspec
sudo gem install utility_belt-1.0.12.gem

Agora é só editar o arquivo .irbrc no home do seu sistema e acrescentar as seguintes linhas:

require 'rubygems'
require 'utility_belt'

module InteractiveEditing
   def gedit
      edit_interactively(:gedit)
   end
end

class Object
   def history_to_gedit
      handling_jruby_bug do
         file = Tempfile.new("gedit_tempfile")
         get_lines(0..(Readline::HISTORY.size - 1)).each do |line|
            file << "#{line}\n"
         end
         file.close
         system("gedit #{file.path}")
      end
   end
   alias :hgedit :history_to_gedit
end

UtilityBelt.equip(:all)

Depois disso é só salvar e partir para a execução!

Agora você pode usar o comando gedit direto do irb e também abrir o histórico no gedit usando hgedit ou history_to_gedit. Se quiser entender um pouco mais sobre os códigos leia os arquivos: interactive_editor.rb e command_history.rb na pasta: utility-belt/lib/utility_belt$

Para quem não utiliza o gedit, nem o Vi, nem o TextMate,  é só modificar esse código para o seu editor favorito!

Fico por aqui.

Obs.:O primeiro teste que eu fiz não funcionou, pois estava faltando uma dependência no meu sistema. Era o xsel que é responsável para fazer cópias de texto do shell para clipboard. Resolvi esse problema usando: sudo apt-get install xsel
Para saber mais sobre o xsel acesse aqui.

O problema é que o Capitão Morrimento precisou sair de férias do seu batalhão, mas mesmo assim quer garantir que a equipe continue na linha e quer acompanhar os aspirantes para não ter problema com eles no futuro.

Para piorar a situação descobri que o Capitão Morrimento é muito extressado e não quer perder tempo com interface complexa. Ele tem conhecimento dos softwares básicos de escritório (somente o editor de texto). Então ele quer algo que se aproxime o máximo possível de copiar dos registros dos aspirantes que ele tem no seu PC e colocar em um campo que faça a verificação e diagnóstico do Aspira.

Sabendo da necessidade de criar algo simples, resolvi usar os conceitos de DSL (Linguagens Especificas de Domínio) do Ruby e fiz a seguinte classe para que ele pudesse entrar com dados no formato que ele usa no dia-a-dia dele:

def aspirante(nome, &bloco)
		Aspirante.new(nome, &bloco)
end

class Aspirante

	def initialize(nome, &bloco)
		@nome = nome
		@dados = {
			:descricoes => [],
			:numero => nil
		}

		instance_eval(&bloco)

	end

	def descricao(dados)
		@dados[:descricoes] << dados
	end

	def numero(numero)
		@dados[:numero] = numero
	end

	def resultado()

		if @dados[:descricoes].include? "corrupto" then 5.times{ puts "PEDE PRA SAIR!"}

		elsif @dados[:numero] == 2 then 5.times{ puts "PEDE PRA SAIR! SEU 02! Tu e CORRUPTO!"}

		elsif @dados[:descricoes].include? "PM" then 2.times{ puts "NAO VAI SUBIR NINGUEM!"}

		elsif @dados[:descricoes].include? "dorminhoco" then 2.times{ puts "TRAGAM A GRANADA!..."}

		else puts "O senhor e um FANFARRAO seu #{@dados[:numero]}.\n Sera interrogado diretamente pelo CAPITAO."

		end
	end

end

Agora é só salvar esse código num arquivo e carregar (load class_aspirante.rb). Então O Capitão pode usar da seguinte forma:

a1 = aspirante “José dos Azóis” do
numero = 04
descricao = “Disciplinado”
descricao = “Competente”
descricao = “etc”
end

a partir daí é só usar a1.resultado e obtém a resposta que queria.

Bom esse exemplo está em aberto, gostaria de dicas para melhorá-lo, porque, como falei antes, o capitão morrimento é muito esquentado e eu não quero ser chamado de Fanfarrão

Quem puder contribuir com novas dicas de implementação para que a linguagem DSL Caveira fique mais intuitiva e eficiente fique à vontade para comentar.

Até logo.

A minha experiência com primeira linguagem foi em 1997 com Pascal que foi uma linguagem criada em 1970 por Niklaus With com o objetivo principal de encorajar o uso do código estruturado (principalmente para o ensino).

Vamos ver um pequeno exemplo de teste lógico em Pascal:

program Testelogico;

var a,b:integer;

uses crt;

begin
   clrscr;
   writeln ('Digite um número para A');
   readln (a);
   writeln ('Digite o número para B');
   readln (b);

   if (a = b) then
       writeln ('A é igual a B')
   else
       if (a < b) then
           writeln ('B é maior que A')
       else
           writeln ('A é maior que B');
end.

Podemos perceber nesse código a necessidade de aprendizado de vários conceitos voltados para a própria estrutura da linguagem ao invés de se focar no problema. Como exemplo temos a exigência dos parênteses e o ponto e vírgula no final de bloco, além da regra clássica: antes de else não se usa ponto e vírgula, pois o ponto e vírgula é utilizado para finalizar blocos de programação.

Ruby é uma linguagem criada por Yukihiro Matsumoto, projetada para programação em grande escala unido de codificação rápida. Vamos ver o mesmo exemplo anterior feito em Ruby:

print "Entre com o valor de A:"
a = gets

print "Entre com o valor de B:"
b = gets

if a == b
   print "A é igual a B"
elsif a < B
   print "B é maior que A"
else
    print "A é maior que B"
end

Além da quantidade de código diminuir tornando-o mais simples, a curva de aprendizado também tende a ser menor, pois agora não temos mais que garantir regras voltadas para a estrutura da linguagem. o bloco if-else faz o que tem que ser feito sem precisar está se preocupando se está faltando ou não ponto e vírgula.

Podemos ver um exemplo ainda mais convincente com estruturas de repetição com final conhecido. Vejam um exemplo em Pascal que mostra 10 vezes na tela a palavra “teste”:

Program repeticao

var
   i : integer;

begin

   for i:= 1 to 10 do
       writeln("teste");

end

Para fazer esse exemplo simples precisei seguir a burocracia de criar o nome do programa criar a variável e só depois criar a rotina. Vamos ver no Ruby o mesmo exemplo:

10.times do
  puts "teste"
end

Ou ainda:

10.times { puts “teste” }

Deu para perceber a simplificação absurda do código no Ruby? Em algumas rotinas assemelha-se a criação de um texto em inglês (linguagem humana). Ao invés de precisar saber que a repetição será a variação do valor de uma variável i de 1 a 10, simplesmente peço para imprimir 10 vezes a palavra “teste”.

Aliando essa simplicidade à característica de ser totalmente orientada a objetos. Além de, junto com o framework rails permitir a utilização profissional no desenvolvimento de sistemas web. Já acho que são argumentos suficientes para aposentar de vez o Pascal (ainda bastante utilizado no ambiente acadêmico e em cursos técnicos como primeira linguagem de programação complementando a disciplina de algoritmos) e seguir com uma linguagem simples, produtiva, de utilização geral e até divertida como o Ruby.

Lembrando que estou sugerindo como primeira linguagem, para depois continuar com ela ou não. Sempre que possível é muito importante aprender outras linguagens para obter outros pontos de vista.

Um grande abraço e até o próximo Pense nisso!