Casa Open

Você "vai" ao Ruby Masters Conf?

2011-02-11T04:13:00.000-08:00

A Ruby Masters Conf foi uma das iniciativas mais legais que vi recentemente na comunidade Ruby. Ela se trata de um conjunto de palestras que serão transmitidas on-line nos dias 25 e 26 de fevereiro de 2011 onde toda a renda será revertida para dois projetos: o RubyInstaller - que é uma ferramenta usada para instalar o ambiente necessário para o Ruby no Windows - e o Passenger - que mudou a forma da comunidade administrar um cluster de Mongrels ou gerenciar processos FastCGI.

Para participar, basta fazer sua inscrição no RubyMastersConf.com por um valor simbólico acima de R$35,00. Após a inscrição, é só esperar por ótimas palestras de pessoas muito conceituadas no mundo Ruby, como por exemplo:

E ai? Nos "encontraremos" na Ruby Masters Conf?

Saiba mais visitando o site RubyMastersConf.com

Um ano de Casa Open

2011-01-27T09:40:00.000-08:00

Este é um dia muito especial para mim pois há um ano atrás o primeiro post, intitulado Ruby on Rails vs Java, do blog, que antigamente chamava-se railsopen.blogspot.com, foi ao ar. Desde então, muita coisa mudou: alterei o layout, o domínio (veja esse post)... mas o que permanece é o foco: Ruby e Rails.

Sim, aprendi muito, errei alguns vezes, conhece pessoas e cresci. Bom, mas para comemorar essa data especial separei os 10 artigos mais lidos deste primeiro ano do Casa Open:

Também não poderia deixar de agradecer aos leitores, aos que fazem comentários, aos assinantes do feed, os seguidores do twitter e a todos que de alguma forma fazem o blog evoluir. Obrigado!

Os railers e suas músicas

2011-01-05T02:12:00.000-08:00

Em quase todos os grandes eventos de Ruby e Rails estamos tendo o privilegio imensurável de desfrutarmos do talento musical dos railers. Como sou uma boa pessoa, não irei privá-lo destes momentos inusitados...
...deixando de lado a ironia, realmente é muito bom ouvir música nos eventos e as que você verá nos próximos vídeos são ótimas!

Regaae do Node
Apresentado na RubyConf Brasil 2010.
By @danicuki, @luizfaias, @ucoaaa e @andrefaria.

Melô do Teste Automatizado e Samba do Akita
Melô do Teste Automatizado e Samba do Akita apresentado no Rails Summit 2009 por Daniel Cukier

Forro do Elomar

Forro do Elomar no Oxente Rails em 2010

Retrospectiva 2010

2010-12-26T04:43:00.000-08:00

Antes de qualquer coisa desejo, sinceramente, a todos os leitores um ótimo 2011. Que seja um ano excelente profissionalmente e pessoalmente. Me vejo também no dever de agradecê-los pelas críticas, elogios e pelos comentários - são eles que me dão forças para continuar.

Salvo os devidos agradecimentos, vamos ao que interessa. Este foi um ótimo ano pra mim e para o blog Casa Open. Foi o ano de estreia do Blog, e tudo que é novo, é especial. Mas para evitar o muito falar, vejam um resumo sobre os artigos mais interessantes - segundo os meus olhos - que aqui foram publicados.

Janeiro
Ruby on Rails vs Java
Arquivos em Ruby

Fevereiro
Gráficos no Rails - CSS Graphs
Traduzindo datas no Rails
Lendo URL's no Ruby

Março
Operador ternário e Ruby
Working with Rails ultrapassa a marca de 17000 programadores

Abril
Tarefas em background - delayed job
Precedência em operadores lógicos

Maio
Interpretador Ruby Online

Junho
Em qual ambiente estamos?

Julho
Project Euler #1
Teste suas expressões regulares na web

Agosto
progzoo.net: Comparando as linguagens de programação

Setembro
Retirando a exceção InvalidAuthenticityToken
Tipagem em Ruby

Outubro
Respostas HTTP
RubyConf Brasil 2010

Novembro
Captura de código ASCII no Ruby

Dezembro
Sockets em Ruby

No mais, tenham um bom final de ano e um 2011 melhor ainda!

Sockets em Ruby

2010-12-15T05:49:00.000-08:00

Este é primeiro de vários artigos que irei publicar sobre Sockets em Ruby. Mas antes de qualquer coisa, é conveniente dizer o que são Sockets:

A grosso modo, são as extremidades de um canal de comunicação bidirecional. Ou seja, você pode utilizar Sockets para fazer comunicação entre processos de uma maquina, entre maquinas diferentes e entre processos de maquinas diferentes.

O que iremos fazer?

Como este é o primeiro artigo sobre o tema, pretendo ir direto ao ponto, mostrando, de forma simples, como implementar uma aplicação Cliente-Servidor. Nesta aplicação o cliente envia uma mensagem para o servidor e este responde. Sendo a comunicação entre cliente e servidor realizada via Socket através do protocolo TCP.
Então, sem mais delongas, vamos aos códigos:

Servidor

# file server.rb
require 'socket' 

server = TCPServer.open(3001)  # Abre socket em escuta na porta 3001  
loop { # o servidor nunca morre, fica sempre executando
  client = server.accept      # aceita conexão do cliente
  msg_cliente = client.recvfrom( 10000 ) # recebe mensagem - 10000 bytes - do cliente

  puts  "Mensagem do cliente: #{msg_cliente}" # imprime a mensagem do cliente no servidor
  client.puts "Ola cliente eu, o servidor, recebi sua mensagem" #envia uma mensagem ao cliente    
  client.close # fecha conexão
}

Cliente

# file client.rb
require 'socket'

server = TCPSocket.open('localhost', 3001) # conecta ao servidor na porta 3001
server.puts "Ola servidor eu, o cliente, estou enviando uma mensagem" # envia mensagem para o servidor

resp = server.recvfrom( 10000 ) # recebe a mensagem -10000 bytes - do servidor
puts resp

server.close # Fecha a conexão com o servidor

Como rodar a aplicação?

Primeiro salve o código do servidor em um arquivo .rb - por exemplo server.rb - e execute o arquivo - ruby server.rb. Neste ponto o servidor está esperando a conexão de um cliente. Agora salve o código do cliente de forma análoga e execute em outro terminal de modo que cliente e servidor sejam rodados ao mesmo tempo. A partir de então o cliente envia uma mensagem ao servidor e o servidor responde.

Conclusões

Este é um exemplo simples do que pode ser feito com Sockets, espero que te ajude em algo.

Referência
http://www.tutorialspoint.com/ruby/ruby_socket_programming.htm

Captura de código ASCII no Ruby

2010-11-30T04:24:00.000-08:00

Existem vários modos para capturar os código ASCII dos caracteres em Ruby, vejamos alguns deles:

puts ?R, ?u, ?b, ?y

puts "R"[0], "u"[0], "b"[0], "y"[0]

"Ruby".each_byte { |x| p x}

Mas se você preferir fazer o caminho inverso, este método resolve:

 puts 82.chr, 117.chr, 98.chr, 121.chr

Referência:

http://en.wikibooks.org/wiki/Ruby_Programming/ASCII1

RubyConf Brasil

2010-10-31T18:39:00.000-07:00

Dois dias intensos de Ruby em São Paulo onde mais de 700 pessoas tiveram o privilegio de conhecer um pouco mais deste mundo que a muitos fascinam. Por lá estive e deixo aqui alguns dos meus pensamentos sobre o evento.

A RubyConf Brasil foi algo que realmente vai deixar saudades, um evento onde pessoas de peso marcaram presença, onde o nível dos palestrantes e palestras foram altíssimos. Estes fatos, sem dúvida, deixam a comunidade cada dia mais orgulhosa de se e dos seus feitos.

Eu e muitos mineiros fomos. Se você foi, garanto que viu alguém com a camisa do grupo Rails-MG. Nisto agradeço ao Gabriel Sobrinho - @sobrinho, que arrumou uma correria para disponibilizar as camisas à todos integrantes do grupo.

Como disse anteriormente, o nível das palestras foi sensacional, mas dentre estas irei falar especialmente de três:

palestra: Desenvolvimento de Aplicações Sociais com Rails

Carlos Brando falou sobre suas experiências no desenvolvimento de aplicações para software social em sistemas como Open Social - Orkut - e FaceBook. Ele mostrou uma forma prática, produtiva e sustentável para desenvolver aplicações sociais em Rails. Sendo a única coisa ruim a notícia de que o framework que facilita o desenvolvimento destas aplicações que o Carlos anda trabalhando não terá o código fonte aberto, pois foi vendido.

Palestra: Integrando o iPhone com Ruby on Rails + Geração de gráficos com Ruby on Rails

Essa palestra realmente me impressionou, Pedro Franceschi, de apenas 13 anos que já impactou o mundo dos iPhones - desbloqueando vários deles, mostrou que idade não é documento palestrando sobre seus conhecimentos em RoR.

Palestra: JRuby: O Melhor dos Dois Mundos

Charles Nutter, mostrou de modo prático como integrar o mundo Java e Ruby. Um ótimo ponto dessa palestra foram as demonstrações desta integração, como por exemplo o uso de bibliotecas gráficas do Java no Ruby, e o humor de Charles.

Esta foi a primeira, de muitas, RubyConf Brasil. Deixo minhas gratificações a todos que contribuíram para o evento em especial ao Fabio Akita e aos patrocinadores: Go Now, thoughtworks, Caelum, Engine Yard, Pay Pal e Infoq.

Mural RubyConf Brasil

Respostas HTTP

2010-10-25T05:39:00.000-07:00

Quando fazemos uma requisição na Web, o servidor busca o que está sendo requisitado e envia uma resposta para quem fez a requisição. Esta resposta pode ser dos seguintes tipos:

1XX: informativas;
2XX: indicam sucesso;
3XX: referem-se a um redirecionamento;
4XX: indicam erros ocorridos no cliente;
5XX: indicam erros no servidor.

Mas como obter estas respostas através do Ruby? O seguinte código responde à essa pergunta:

require 'net/http' 
  resposta = Net::HTTP.get_response(URI.parse("http://www.casaopen.com.br/"))
  puts resposta.code  # retorna qual foi a resposta a requisição HTTP. Ex: 200, 400...

Mas como você não quer problemas caso a URL os tenha, isso ajuda:

require 'net/http' 
begin
  resposta = Net::HTTP.get_response(URI.parse("http://www.casaopen.com.br/"))
  puts resposta.code  # retorna qual foi a resposta a requisição HTTP. Ex: 200, 400...
rescue => ret   # TimeoutError #  Net::HTTP.SocketError,
  puts  "Erro: #{resposta}"
end

Para maiores informações, veja a documentação do Ruby.

Tipagem em Ruby

2010-09-23T17:25:00.000-07:00

Cada linguagem de programação tem sua forma de lidar com tipos, por exemplo: C é uma linguagem fracamente tipada. O que pode ser visto nesse exemplo:

  char a= 'a', b='b';
  float c = a + b;

Exemplo este que mostra o fato de podermos somar dois chars e atribuirmos a um float.
[ Ao longo do texto o conceito de fracamente tipada ficará mais claro. ]

No entanto, Ruby é dinamicamente, implicitamente e fortemente tipada. Vejamos o que cada um destes adjetivos significam:

Dinamicamente tipada

Quer dizer que, a cada interação, o tipo é verificado. Isso fica claro no seguinte exemplo:

x = 100
(1..4).each{ x = x * 100 ;  puts "#{ x.class} #{x}"  }

Que gera o resultado:

Fixnum 10000
Fixnum 1000000
Fixnum 100000000
Bignum 10000000000

Como podemos ver a variável x começa como Fixnum e conforme aumenta passa para Bignum sem a necessidade de uma conversão.

Essa característica gera vários pontos positivos na linguagem, tais como:

Diminui a verbosidade, pois não há a necessidade de fazer conversões;
Tende a facilitar a vida do programador pois não há a preocupação com conversões.

Mas neste contexto nem tudo são flores, vejamos os pontos negativos:

A linguagem tende a ser mais lenta, em tempo de execução, devido ao fato de que, a cada interação, o tipo ser verificado;
Pode confundir o programador pois o mesmo pode não saber exatamente com quais tipos está tratando.

Implicitamente tipada

Continuando no mesmo exemplo, quando fizemos x = 100 não precisamos declarar o tipo de x. Ou seja, não foi necessário fazer algo como: Fixnum x = 100. Isso acontece pelo fato do Ruby detectar o tipo de cada variável em tempo de execução. Uma boa analogia para este fenômeno é pensar nas variáveis como se fossem caixas fechadas e seus dados como fitas coloridas onde o interpretador abre a caixa e verifica as cores das fitas.

Novamente, os pontos positivos e negativos são muito semelhantes aos relacionados a tipagem dinâmica. Veja:

Positivos:

Diminui a verbosidade, pois não há a necessidade de fazer declarações.

Negativos:

A linguagem tende a ser mais lenta pois o tipo é verificado em tempo de execução de acordo com a analogia das caixas e fitas;
Pode confundir o programador pois o mesmo pode não saber exatamente com quais tipos está tratando já que não existe a declaração dos mesmos.

Fortemente tipada

Este é um conceito confuso, mas uma boa forma de explica-lo é dizendo que todas as variáveis devem ter um tipo - ou seja: fazer parte de uma classe no caso do Ruby - e que cada tipo segue a risca seu contrato. Por exemplo:

a = 100
b = "Ruby on Rails"
a + b

TypeError: String can't be coerced into Fixnum
    from (irb):54:in `+'
    from (irb):54

Como você notou, em Ruby não podemos somar um String com Fixnum pois essa operação não está no contrato da classe String e Fixnum.

De fato, o assunto não acaba por aqui, existem alguns materiais na Web e em Livros sobre isso. Em vista disso, e no intuito de incentivar a pesquisa, deixo algumas referencias e até a próxima!

P.S. Os tipos em Ruby na verdade são classes, ou seja: não existem tipos primitivos e sim objetos que pertencem a classes. Ex.:

a = 1 # a pertence a classe Fixnum

Retirando a exceção InvalidAuthenticityToken

2010-09-09T07:22:00.000-07:00

Já tentou enviar formulários fora da sua aplicação? Se sim, certamente você teve problemas!

Esses problemas se devem ao fato de que o Rails 2 insere o campo “authenticity_token” nos formulários no intuito de não permitir envios de forms por terceiros.

Mas se desejar receber tais envios basta colocar:

self.allow_forgery_protection = false

no controller desejado.

progzoo.net: Comparando as linguagens de programação

2010-08-17T07:12:00.000-07:00

O progzoo.net é um ótimo site que mostra códigos com o mesmo propósito em linguagens diferentes - Java, C#, C++, Perl, PHP, Python, Ruby, VB. O site fornece exemplos tais como o Hello World, Convert to Number, Read Text File, Sum an Array entre outros.

E, puxando a sardinha para o Ruby, é impressionante o quanto ele é mais conciso do que a maiorias das outras linguagens.

Sem dúvida vale a pena conferir o site

Teste suas expressões regulares na web

2010-07-28T06:12:00.000-07:00

Vai uma dica de um ótimo site, o Rubular. Com ele você testa suas expressões regulares em Ruby de forma pratica e rápida e ainda pode adquirir um link de seus testes.

Veja um exemplo: http://rubular.com/r/tgTEBeNhzz

Project Euler #1

2010-07-16T05:57:00.001-07:00

O Projeto Euler foi iniciado por Colin Hughes (aka Euler) em outubro de 2001 e consiste em diversos problemas que envolvem matemática e computação, sendo que alguns são possíveis resolver sem o uso da computação e outros não. Segundo a descrição do projeto, este teve como principal motivação oferecer uma plataforma para que mentes curiosas mergulhem em áreas desconhecidas.

Salvo as devidas explicações, irei começar a resolver alguns problemas, de preferência em Ruby, e postar as soluções aqui.

Então... vamos ao problema 1:

Descrição

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Solução

sum = 0
(1..999).each { |x| sum += x if x%3 == 0 or x%5 == 0 }
puts sum

sum = (0..999).inject {|aux, n| ( n%3 == 0 or n%5 == 0 ) ? aux + n  : aux }
p sum

Resposta

233168

Doc da sua aplicação Rails

2010-07-08T13:51:00.000-07:00

Já experimentou o comando rake doc:app ?

rake doc:app

Ele cria uma doc semelhante a documentação do Ruby com todos os arquivos, classes e métodos da sua sua aplicação no diretório /doc/app/ .

Bom, mas existem muitos outros comandos interessantes, para conhecê-los basta rodar:

rake -T


rake db:abort_if_pending_migrations        # Raises an error if there are pending migrations
rake db:charset                            # Retrieves the charset for the current environment's database
rake db:collation                          # Retrieves the collation for the current environment's database
rake db:create                             # Create the database defined in config/database.yml for the current RAILS_ENV
rake db:create:all                         # Create all the local databases defined in config/database.yml
rake db:drop                               # Drops the database for the current RAILS_ENV
rake db:drop:all                           # Drops all the local databases defined in config/database.yml
rake db:fixtures:identify                  # Search for a fixture given a LABEL or ID.
rake db:fixtures:load                      # Load fixtures into the current environment's database.
rake db:migrate                            # Migrate the database through scripts in db/migrate and update db/schema.rb ...
rake db:migrate:down                       # Runs the "down" for a given migration VERSION.
rake db:migrate:redo                       # Rollbacks the database one migration and re migrate up.
rake db:migrate:reset                      # Resets your database using your migrations for the current environment
rake db:migrate:up                         # Runs the "up" for a given migration VERSION.
rake db:reset                              # Drops and recreates the database from db/schema.rb for the current environm...
rake db:rollback                           # Rolls the schema back to the previous version.
rake db:schema:dump                        # Create a db/schema.rb file that can be portably used against any DB support...
rake db:schema:load                        # Load a schema.rb file into the database
rake db:seed                               # Load the seed data from db/seeds.rb
rake db:sessions:clear                     # Clear the sessions table
rake db:sessions:create                    # Creates a sessions migration for use with ActiveRecord::SessionStore
rake db:setup                              # Create the database, load the schema, and initialize with the seed data
rake db:structure:dump                     # Dump the database structure to a SQL file
rake db:test:clone                         # Recreate the test database from the current environment's database schema
rake db:test:clone_structure               # Recreate the test databases from the development structure
rake db:test:load                          # Recreate the test database from the current schema.rb
rake db:test:prepare                       # Check for pending migrations and load the test schema
rake db:test:purge                         # Empty the test database
rake db:version                            # Retrieves the current schema version number
rake doc:app                               # Build the RDOC HTML Files
rake doc:clobber_app                       # Remove rdoc products
rake doc:clobber_plugins                   # Remove plugin documentation
rake doc:clobber_rails                     # Remove rdoc products
rake doc:guides                            # Generate Rails guides
rake doc:plugins                           # Generate documentation for all installed plugins
rake doc:plugins:brazilian-rails           # Generate documentation for the brazilian-rails plugin
rake doc:plugins:human_attribute_override  # Generate documentation for the human_attribute_override plugin
rake doc:plugins:jrails                    # Generate documentation for the jrails plugin
rake doc:plugins:paperclip                 # Generate documentation for the paperclip plugin
rake doc:plugins:will_paginate             # Generate documentation for the will_paginate plugin
rake doc:rails                             # Build the RDOC HTML Files
rake doc:reapp                             # Force a rebuild of the RDOC files
rake doc:rerails                           # Force a rebuild of the RDOC files
rake gems                                  # List the gems that this rails application depends on
rake gems:build                            # Build any native extensions for unpacked gems
rake gems:build:force                      # Force the build of all gems
rake gems:install                          # Installs all required gems.
rake gems:refresh_specs                    # Regenerate gem specifications in correct format.
rake gems:unpack                           # Unpacks all required gems into vendor/gems.
rake gems:unpack:dependencies              # Unpacks all required gems and their dependencies into vendor/gems.
rake jrails:install:javascripts            # Installs the jQuery and jRails javascripts to public/javascripts
rake jrails:update:javascripts             # Copies the jQuery and jRails javascripts to public/javascripts
rake log:clear                             # Truncates all *.log files in log/ to zero bytes
rake middleware                            # Prints out your Rack middleware stack
rake notes                                 # Enumerate all annotations
rake notes:custom                          # Enumerate a custom annotation, specify with ANNOTATION=WTFHAX
rake notes:fixme                           # Enumerate all FIXME annotations
rake notes:optimize                        # Enumerate all OPTIMIZE annotations
rake notes:todo                            # Enumerate all TODO annotations
rake paperclip:clean                       # Cleans out invalid attachments.
rake paperclip:refresh                     # Refreshes both metadata and thumbnails.
rake paperclip:refresh:metadata            # Regenerates content_type/size metadata for a given CLASS (and optional ATTA...
rake paperclip:refresh:thumbnails          # Regenerates thumbnails for a given CLASS (and optional ATTACHMENT).
rake rails:freeze:edge                     # Lock to latest Edge Rails, for a specific release use RELEASE=1.2.0
rake rails:freeze:gems                     # Lock this application to the current gems (by unpacking them into vendor/ra...
rake rails:template                        # Applies the template supplied by LOCATION=/path/to/template
rake rails:unfreeze                        # Unlock this application from freeze of gems or edge and return to a fluid u...
rake rails:update                          # Update both configs, scripts and public/javascripts from Rails
rake rails:update:application_controller   # Rename application.rb to application_controller.rb
rake rails:update:configs                  # Update config/boot.rb from your current rails install
rake rails:update:generate_dispatchers     # Generate dispatcher files in RAILS_ROOT/public
rake rails:update:javascripts              # Update your javascripts from your current rails install
rake rails:update:scripts                  # Add new scripts to the application script/ directory
rake routes                                # Print out all defined routes in match order, with names.
rake secret                                # Generate a crytographically secure secret key.
rake stats                                 # Report code statistics (KLOCs, etc) from the application
rake test                                  # Run all unit, functional and integration tests
rake test:benchmark                        # Run tests for benchmarkdb:test:prepare / Benchmark the performance tests
rake test:functionals                      # Run tests for functionalsdb:test:prepare / Run the functional tests in test...
rake test:integration                      # Run tests for integrationdb:test:prepare / Run the integration tests in tes...
rake test:plugins                          # Run tests for pluginsenvironment / Run the plugin tests in vendor/plugins/*...
rake test:profile                          # Run tests for profiledb:test:prepare / Profile the performance tests
rake test:recent                           # Run tests for recentdb:test:prepare / Test recent changes
rake test:uncommitted                      # Run tests for uncommitteddb:test:prepare / Test changes since last checkin ...
rake test:units                            # Run tests for unitsdb:test:prepare / Run the unit tests in test/unit
rake time:zones:all                        # Displays names of all time zones recognized by the Rails TimeZone class, gr...
rake time:zones:local                      # Displays names of time zones recognized by the Rails TimeZone class with th...
rake time:zones:us                         # Displays names of US time zones recognized by the Rails TimeZone class, gro...
rake tmp:cache:clear                       # Clears all files and directories in tmp/cache
rake tmp:clear                             # Clear session, cache, and socket files from tmp/
rake tmp:create                            # Creates tmp directories for sessions, cache, sockets, and pids
rake tmp:pids:clear                        # Clears all files in tmp/pids
rake tmp:sessions:clear                    # Clears all files in tmp/sessions
rake tmp:sockets:clear                     # Clears all files in tmp/sockets

Em qual ambiente estamos?

2010-06-30T06:16:00.000-07:00

Já teve a necessidade de saber em qual ambiente de trabalho - production, development, test e etc - você está? Acredito que sim! Logo segue algumas dicas para saber isso:

if Rails.env == 'development'
  puts 'Estamos no development'
elsif Rails.env == 'production'
  puts 'Estamos no production'
end

Ou:

puts 'Estamos no development' if Rails.env.development? 
puts 'Estamos no production' if Rails.env.production? 
puts  'Estamos no test' if Rails.env.test?  
puts  'Estamos no whatever' if Rails.env.whatever?

Ou usando a variável de ambientes RAILS_ENV:

if RAILS_ENV == 'development'
  puts 'Estamos no development'
elsif RAILS_ENV == 'production'
  puts 'Estamos no production'
end

Wallpaper Ruby on Rails

2010-06-04T10:48:00.000-07:00

Estava procurando um papel de parede novo e olhe o que encontrei:
[ P.S. basta clicar nas fotos para ser redirecionado aos devidos sites ]

Interpretador Ruby Online

2010-05-13T09:52:00.000-07:00

Já passou pela experiência de querer executar algum algoritmo mas estava sem o devido interpretador ou compilador? Certamente sim! Mas nessas horas o site CodePad é uma ótima saída, com ele você pode interpretar/compilar código fonte de várias linguagens tais com: Ruby, PHP, C, C++, Haskell, Lua, Ocaml, Perl e outras. Além disso, ele disponibiliza o seu código juntamente com a respectiva saída através de uma url curta de forma semelhante as usadas no Twitter.
Sem dúvida esses fatores apontam o CodPad como uma boa maneira para mostrar, de forma rápida, um código simples para alguém.

Interessou? Então entre no site e/ou veja como é o seu funcionamento.

P.S. Fiz alguns testes em Ruby e em todos tive sucesso, veja um deles http://codepad.org/QrVXq8oj.

Precedência em operadores lógicos

2010-04-30T06:41:00.000-07:00

Antes de qualquer coisa, veja os seguintes códigos e seus respectivos retornos:

true and false #=> false
true && false #=> false

true or false #=> true
true || false #=> true

Em vista disso, logo vem a pergunta: Qual a diferença entre "and" e "&&" e entre "or" e "||"?
A resposta é simples, "&&" e "||" possuem maior precedência que "and" e "or". Sendo que o "&&" possui maior precedência que o "||" e o "and" possui a mesma precedência que "or". Veja alguns exemplos:

true or false and false #=> false

Neste caso o código é resolvido da esquerda para a direita, ou seja: primeiro o "or" e em seguida o "and".

true or false && false #=> true

Como o "&&" possui maior precedência ele é resolvido primeiramente e depois o "or".

Tarefas em background - delayed job

2010-04-18T08:01:00.000-07:00

Realizar tarefas em background é uma boa saída para melhorar a resposta da sua aplicação. Geralmente usamos este recurso para tarefas como enviar e-mail, redimensionar imagens, postar algo no twitter... isso, simplesmente pelo fato que estas tarefas não necessitarem de resposta imediata para o usuário continuar usando o sistema.
A verdade é que, para quem utiliza Rails, existem vários plugins e gens que fazem este trabalho. Vejamos alguns:

Introducing Resque
background-fu
Backgroundjob
background_lite
backgroundrb

Porem, na minha opnião, a melhor opção é o Delayed Job. Com ele você armazena os jobs em uma tabela e os realiza quando achar melhor! Sem contar que o Delayed Job está disponível nas formas de plugin e gem. Vejamos o seu funcionamento:

Para instalar:

# instação como plugin 
# rode na raiz da aplicação 
script/plugin install git://github.com/collectiveidea/delayed_job.git

Configurando o banco de dados

Para gerar a tabela onde as tarefas serão salvas use os seguintes comandos no terminal:

 script/generate delayed_job
 rake db:migrate

Isso vai gerar uma tabela no seguintes moldes:

create_table :delayed_jobs, :force => true do |table|
  table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
  table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
  table.text     :handler                      # YAML-encoded string of the object that will do work
  table.text   :last_error                   # reason for last failure (See Note below)
  table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
  table.datetime :locked_at                    # Set when a client is working on this object
  table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
  table.string   :locked_by                    # Who is working on this object (if locked)
  table.timestamps
end

Realizando tarefas em background

Agora já é possível realizar jobs em background, veja um exemplo de envio de e-mail:

# usando o Delayed Job
MeuModelDeEmail.send_later :deliver_MeuEmail, @MeuParametro

# sem usar o Delayed Job:
MeuModelDeEmail.deliver_MeuEmail(@MeuParametro)

Outro exemplo:

@imagem.calculate_size # sem usar o Delayed Job
@imagem.send_later(:calculate_size) # usando o Delayed Job

Mais um exemplo

Outro modo seria passar a(s) tarefa(s) para uma lib onde teríamos um arquivo, por exemplo: lib/mailingenvia.rb, da seguinte forma:

require 'net/smtp'
class Mailingenvia < Struct.new( MeuParametro )
  def perform
   Contato.deliver_MeuEmail( MeuParametro )
  end
end

e chamá-lo assim:

Delayed::Job.enqueue Mailingenvia.new( @MeuParametro )
# P.S. Quando isso é feito o método perform é chamado

Realizando as tarefas que estão na fila de prioridade

Quando fazemos um tarefa pelo delayed job ela é salva na tabela chamada "delayed_jobs" e para rodá-la é necessário o seguinte comando:

 rake jobs:work
# para parar de realizar os jobs: CRTL-C

Se desejar apagar todas as tarefas da fila:

rake jobs:clear

Bom, é isso. Para maiores informações veja a página do daleyd job no github ou asista este screencast que eu recomendo fortimente! Até a proxima!

Working with Rails ultrapassa a marca de 17000 programadores

2010-03-30T14:05:00.000-07:00

Estive lendo um post do Carlos Brando de 21 de agosto de 2007 com o título “Working with Rails ultrapassa a marca de 8000 programadores.” e nesta semana ultrapassamos a casa dos 17000! Ou seja, são mais 9000 desenvolvedores em menos de 3 anos, um crescimento maior que 100%! Impressionante não?
Atualmente os brasileiros estão ocupando o 3º lugar geral em número de desenvolvedores cadastrados no site, perdendo apenas para o Reino Unido e Estados Unidos. Terceiro lugar este que foi conquistado com 874 programadores! O que, na minha opinião, é pouco em vista do que temos. Então nunca é de mais dizer: não deixe de se cadastrar!

Símbolos em Ruby

2010-03-29T08:36:00.000-07:00

São poucas linguagens que possuem símbolos assim como o Ruby. Mas ai vem pergunta: o que são símbolos? Eles são uma forma de representar uma string de modo mais leve, para ser mais especifico são os textos iniciados com ":". Lembrando que, partindo do principio que tudo em Ruby é objeto, isso é muito útil!
Veja alguns exemplos de utilização de símbolos:

redirect_to :action => :index

<% form_tag :action => :enviar_eventos do %>

usuario.update_attribute(:tel, "2222-2222")

Veja isso:

a = :"www.casaopen.com.br"
a.object_id #=> 166478
:'www.casaopen.com.br'.object_id # => 166478

Isso que dizer que os símbolos são de, certa forma, imutáveis ou seja eles permanecem no ciclo de vida do seu projeto.

Símbolos são representações de sequências, veja:

a = :"Ruby On Rails" #=> :"Ruby On Rails" 
a.class #=> Symbol
puts a #=> Ruby On Rails #=> nil
# 'puts a' imprime a sequência de a que é semelhante ao puts em uma String...

b = "Ruby On Rails" #=> "Ruby On Rails"
b.class #=> String
puts b #=> Ruby On Rails #=> nil

Em vista disso, qual é a importância dos símbolos?

Eles são uma ótima forma de representar sequências que não necessitam de alterações em tempo de execução e também não necessitam de todos os métodos da classe String! Dúvida? Execute o seguinte código e veja o resultado.

a = :"Ruby on Rails"
b = "Ruby on Rails"
a.methods.size
b.methods.size

Para maiores informações veja esse post que explica todas as formas possíveis de simbolos.

Explore o mundo em 360 graus

2010-03-22T05:24:00.000-07:00

Gostaria de conhecer o mundo em 360 graus? Nada melhor que visitar o site 360Cities. Para quem não conhece, este reuni uma imensa galeria de fotos panorâmicas de várias regiões do mundo, inclusive de muitas cidades brasileiras – Rio de Janeiro, Belo Horizonte, Ouro Preto e etc. Seu conteúdo é abastecido por fotógrafos de várias cidades do mundo e está em constante crescimento. Sem dúvida este foi um dos melhores sites que conheci recentemente logo, uma ótima pedida.

Veja algumas imagens do 360Cities:

Pão de Açucar - Rio de Janeiro - RG

Igrejinha da Pampulha - Belo Horizonte - MG

Igreja de Nossa Senhora da Conceição de Antônio Dias - Ouro Preto - MG

Operador ternário e Ruby

2010-03-15T18:05:00.000-07:00

O operador ternário é uma ótima forma de deixar o código mais limpo, veja sua sintaxe:

# (condicao) ? resultado_se_condicao_verdadeiro : resultado_se_condicao_falso

Exemplo:

a = true  ? 'a' : 'b' #=> "a"
b = false ? 'a' : 'b' #=> "b"

que é equivalante a:

if true 
    a = 'a' 
else
    a = 'b'
end

Outra opção com resultado semelhante é:

a = (true  && 'a') || 'b' #=> "a"
a = true || 'b' #=> true 

b = (false && 'a') || 'b' #=> "b" 
b = false || 'b' #=> "b"

fonte: http://invisibleblocks.wordpress.com/2007/06/11/rubys-other-ternary-operator/

De casa nova!

2010-03-08T19:04:00.000-08:00

Como vocês já devem ter notado, agora estou de casa nova! Para ser mais especifico de casaopen.com.br. Mas, apesar da nova casa, o prato principal continua sendo o mesmo: Ruby on Rails!
Espero que nessa nova direção possamos crescer juntos afim de que a comunidade RoR venha estar cada dia mais forte!

Viva Rails!

E-mail para vários destinatários

2010-02-24T12:50:00.000-08:00

Recentemente desenvolvi uma aplicação que tinha a necessidade de enviar e-mail para vários destinatários. O que poderia gerar problemas relacionados a quantidade máxima de destinatários - CC, CCo, BCC... - do SMTP. No meu caso o SMTP permitia enviar e-mails para no máximo 500 destinatários em uma única vez via mala direta. Fato é que este detalhe nem sempre é lembrado na hora do desenvolvimento. Então deixo aqui uma sugestão de código para enviar e-mails respeitando o limite de destinatários:

smtp_max = 499 # máximo de destinatários do smtp
  while not destinatarios.empty? # enquanto há destinatários
    begin
      # envia para os primeiros destinatários
      ContatoMailer.deliver_email(destinatarios.first(smtp_max))
    rescue Net::SMTPFatalError, Net::SMTPServerBusy, 
      Net::SMTPUnknownError, Net::SMTPSyntaxError, 
      Net::SMTPAuthenticationError, IOError, TimeoutError
    end
    destinatarios.slice!(0..smtp_max - 1) # retira da lista os destinatários enviados
  end

Neste exemplo assumimos que a variável destinatários é um vetor de e-mails. Ex: ["email1@dominio", "email2@dominio", "email3@dominio"]

Observação: Na minha aplicação, envio os e-mails em background através do plugin delayed job a fim de aumentar o conforto para o usuário e melhorar o desenpelho. Mas como realizar tarefas em background fica para outro post!