Faz um bom tempo que tenho uma mania chata: gosto de ter tudo sempre atualizado. Confesso que é quase uma frescura (nada de piadinhas sobre gaúchos, ok?), mas automatizando um pouco, é um vício que da pra conviver. Para as apps do Mac OS X eu uso o AppFresh, que funciona muito bem e tem integração com o iUseThis. Mas ainda tinham algumas coisas que eu ainda fazia manualmente: MacPorts e RubyGems eram duas delas.

Depois do post que fiz sobre o rmagick-osx-installer tive a idéia de fazer um script que fizesse o trabalho sujo por mim também. E depois de muita procastinação: update_cadabra!

É basicamente, um script bash que roda os comandos pra atualização do Ruby Gems+gems+MacPorts+ports – e de quebra, ainda faz uma faxina no que está sobrando. Espero que usem, sugiram coisas novas e poupem ainda mais nosso tempo.

Pra usar, é só baixar o script, dar permissão de execução pro script e executá-lo:

chmod u+x update_cadabra.sh
sudo update_cadabra.sh

ps: se você por algum motivo não pode atualizar suas gems, ou ainda tem algumas gems antigas instaladas para algum sistema legado, não recomendo usar o script
ps2: use por sua conta e risco

Mas sendo mais prático preguiçoso, sempre existe uma forma mais fácil e menos dolorosa de fazer as coisas. E foi então que achei o rmagick-osx-installer. Basta fazer download, descompactar e executar

ruby rm_install.rb

E depois de todo processo completo (com um pouco de sorte), você verá um lindo resumo como esse:

Summary: There were 0 failures
libpng 1.2.26 was already installed.
libjpeg was installed successfully
ghostscript was installed successfully
ghostscript-fonts-std was installed successfully
FreeType 9.17.3 was already installed.
libwmf was installed successfully
ImageMagick was installed successfully
RMagick was installed successfully
Removing rm_install_tmp directory...Done

Update: agora também é possível instalar o ImageMagick com o bom e velho ports:

sudo port install ImageMagick

Hoje resolvi fazer uma atualização do Rails e cia aqui e dei de cara com um problema chato de resolver. Além de instalar as versões novas dos gems, queria me livrar as antigas. Mas sempre que tentava fazer o gem cleanup, recebia o seguinte erro:

~ plentz$ sudo gem cleanup
Cleaning up installed gems...
Attempting to uninstall mongrel-1.0.1
ERROR: While executing gem ... (Gem::InstallError)
Unknown gem mongrel = 1.0.1

Depois de fazer um find (find . -iname mongrel* mesmo) no / inteiro, descobri um diretório com vários gems antigos. Ele fica em:

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8

Entrei nele e fiz literalmente um limpa. Apaguei todos arquivos dentro das pastas specifications, doc, cache e gems. Então se quizer deixar sua instalação 100% fresh, rode os comandos abaixo, e caso encontre algum problema, siga a dica acima:

sudo gem update --system
sudo gem update
sudo gem cleanup

Depois confira que você ficou só com as últimas versões rodando: gem list.

Segundo a Wikipedia,

Hot swapping can also refer to the ability to alter the running code of a program without having to interrupt its execution, although only a few languages support it. Those that do include Lisp, Erlang, and Smalltalk. The Java programming language also supports this technology, but only through the Java Platform Debugger Architecture (JPDA) : it is only possible to change the code while the program is in the control of a Debugger. Interactive programming is a paradigm that makes extensive use of hot swapping so that the programming activity becomes part of the program flow itself.

O post do Daniel (Hot Code Replacement), contando como fazer hot swap de classes com o OC4J, me fez pensar numa coisa: será que realmente são poucos que conhecem a “feature” de trocar classes em tempo de execução, sem parar sua aplicação, e nem a VM?

Bom, mesmo sem ter 1/3 de conhecimento sobre VMs que o Rodrigo (louds), por exemplo, vou tentar explicar. Parada para comentário de utilidade pública: se você não assina o blog dele, faça um favor a si mesmo e vai lá. Hoje mesmo ele anunciou que vai liberar os fontes da máquina virtual que ele começou a desenvolver.

Voltando ao assunto, desde a JDK 1.4 (sim, hot swap é relativamente velho), é possível trocar a implementação de métodos sem reiniciar a aplicação. Notem bem, implementação, ou seja, se você trocou qualquer coisa na assinatura de um método, criou algum novo, adicionou uma variável de instância da classe, você precisa parar a VM, compilar a classe, e iniciar novamente.

No entando, linguagens dinâmicas, como Ruby (com site novo), permitem trocar trocar qualquer coisa das suas classes em tempo de execução, seja métodos, atributos, whatever. Parece covardia comparar, né?

Porém, lendo um pouco mais à respeito, fazer com que a JVM suporte isso também é perfeitamente possível tecnicamente (louds!!), mas precisariam ser feitas enormes mudanças no seu funcionamento, e acredito que seja esse, um dos principais motivos de não terem feito nos primórdios do hot swap – JDK 1.4.

O assunto parece estar realmente chamando ateção, pois acabou de sair um artigo no Artima, The JVM as an (Un)Common Language Runtime, e um dos pontos que o autor destaca como sendo um dos principais desafios para a implementação de linguagens dinâmicas na JVM:

Hotswapping: The main idea is to allow code changes on the fly, while they are running. The full capability of hotswapping implies any kind of change to be supported, addition/modification/removal of methods and attributes including changes in inheritance hierarchy.

Se isso não fosse suficiente, existe um tópico na SDN, Hotswap support for schema / shape changes discutindo o assunto, e o bug report 4910812 – Enhance Hot Code Replacement com 300+ votos.

Isso permitiria baixar para praticamente zero o turnaround de desenvolivmento de aplicações, dando um grande fôlego para Java como linguagem, pois já aumentaria significantemente a velocidade de desenvolvimento, evitando a perda de minutos que já estamos acostumados entre parar servidor de aplicação, fazer re-deploy, iniciar aplicação, …

Classloader tricks only take you so far.

irb(main):001:0> def question?
irb(main):002:1> bb || !bb
irb(main):003:1> end
=> shakespeare

F. Meyer ! says:
defina o mainstream que ruby não vai entrar
diego says:
essas empresas recheadas de programadores que estão lá somente porque informática pagava mais que educação física.

Tá, parei.

Ruby (meu):

require 'open-uri'
open('http://www.google.com.br/search?q=ruby').read =~ %r{class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><}m
puts ($2 + "\n" + $1 + "\n" + $3 + "\n").gsub(/<.*?\>/, '')

Java (do Giuliano, bastante melhorada depois pelo Urubatan):

import java.net.URL;
import java.net.URLConnection;
import java.util.Scanner;

public class HTTPSample {
       public static void main(String[] args) throws Exception {
               URLConnection con = new URL("http://www.google.com/search?q=java").openConnection();
               con.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.12) Gecko/20050915 Firefox/1.0.7");
               Scanner sc = new Scanner(con.getInputStream());
               System.out.println(sc.findWithinHorizon("<a>.*?</a>", 0).replaceAll("<a>(.*?)</a>", "$2=$1").replaceAll("", ""));
       }
}

PHP (do Pilger, com ajuste do Fernando):

<?php
  $html = implode('', file('http://www.google.com.br/search?q=php'));
  preg_match_all("|class=l href=\"(.*?)\">(.*?)</a.*?j><font.*?>(.*?)<br><|", $html, $out, PREG_SET_ORDER);
  echo $out[0][1]." ".$out[0][2]." ".$out[0][3];
?>

Python (do Salviato):

 import urllib
 import re

 class AppURLopener(urllib.FancyURLopener):
   version = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1"

 urllib._urlopener = AppURLopener()

 html = urllib.urlopen('http://www.google.com.br/search?q=python').read()
 out = re.search('class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><', html, re.DOTALL)
 print re.sub('<.*?>', '', (out.group(1) + '\n' + out.group(2) + '\n' + out.group(3)))

TCl/TK (do Salviato):

 package require http
 http::config -useragent {Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1}
 set html [http::data [http::geturl {http://www.google.com.br/search?q=tcl}]]
 set out [regexp -inline {class=l href="(.*?)">(.*?)(.*?)< } $html]
 puts [regsub -all {<.*?>} [concat "[lindex $out 1]\n[lindex $out 2]\n[lindex $out 3]"] "" ]

VB (do Giuliano):

   Dim http As New WinHttp.WinHttpRequest
   Dim re As New RegExp, matcher As Match
   Dim texto As String
   http.Open "GET", "http://www.google.com.br/search?q=java", False
   http.SetRequestHeader "User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.12) Gecko/20050915 Firefox/1.0.7"
   http.Send
   texto = http.ResponseText
   re.Pattern = "class=l href=""(.*?)"">(.*?)</a.*?j><font.*?>(.*?)<br><"
   re.Global = True
   re.IgnoreCase = True
   re.MultiLine = True
   For Each matcher In re.Execute(texto)
       Dim strSaida: strSaida = ""
       strSaida = matcher.SubMatches(0) + vbCrLf + matcher.SubMatches(1) + vbCrLf + matcher.SubMatches(2)
       MsgBox strSaida
       Exit For
    Next

Coldfusion (do Kenji)

<cfhttp url="http://www.google.com.br/search?q=coldfusion+mx">
<cfset tmp = REFindNoCase('class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><', cfhttp.filecontent,1,true)>
<cfoutput>#mid(cfhttp.filecontent,tmp.pos[2],tmp.len[2])# #mid(cfhttp.filecontent,tmp.pos[3],tmp.len[3])# #mid(cfhttp.filecontent,tmp.pos[4],tmp.len[4])#</cfoutput>

Buenas, semana passada no meu post “Ruby, less-code”, o Pilger deu a idéia de colocar os códigos lado-a-lado, até pra facilitar a comparação. Bom, conversando com o Giuliano este final de semana surgiu uma idéia: fazer uma espécie de “coding contest”. Claro, não vai valer nada. Todos os “desafios” vão ficar sob a tag “code contest“

A idéia é essa: pegamos um problema qualquer e cada um resolve em uma linguagem. Ajuda a ver algumas vantagens/desvantagens de cada linguagem, e claro, da pra aprender muito também. A versão inicial de cada solução nós fazemos, se alguém sugerir alguma mudança/melhoria alteramos e publicamos(citando o autor, claro). A idéia é criar um problemas por semana em média.

Ah, se alguém tiver interesse de solucionar em alguma linguagem diferente e mandar, será muito bem vinda também. Seja ela Python (Jonas? Carlos?), Lisp (Shoes? Taq?), C/C++(Fernando?), Groovy (Daniel?), PHP (Pilger?), .Net, etc.

Como criar problemas não é nossa especialidade(e sim resolvê-los), sugestões de problemas também são bem vindas, mas por favor, nada de calcular órbitas e bizarrices do gênero. É só pra se divertir mesmo.

Duas ótimas notícias para quem simpatiza com Ruby. A primeira é o lançamento do livro do Taq. Perfeito para quem está querendo começar, mas não tem uma boa base de inglês. Ponto para a comunidade brasileira.

A outra é o lançamento do Rails 1.1. Algumas features que chamam atenção (além é claro, dos 500+ bugfixes e tweaks):

• RJS – JavaScript escrito em Ruby: que tal um bocado de Ajax/Javascript só com Ruby?

  # Chamada para efeitos do script.aculo.us
  page[:cart].visual_effect(@cart.size == 1 ? :appear : :highlight)
  
  # Atualiza um pedaço de html
  page[:cart].replace_html :partial => "cart"
  

• Active Record – Cascading eager loading: busca em cascata.

  # Single database query:
  companies = Company.find(:all, :include => {
    :groups => { :members=> { :favorites } } })
  
  companies[0].groups[0].members[0].favorites[0].name
  

• Active Record – Polymorphic associations and join models: possibilidade de relacionamentos many-to-many mais complexos.

  class Author < ActiveRecord::Base
    has_many :authorships
    has_many :books, :through => :authorships
  end
  
  class Book < ActiveRecord::Base
    has_many :authorships
    has_many :authors, :through => :authorships
  end
  
  class Authorship < ActiveRecord::Base
    belongs_to :author
    belongs_to :book
  end
  

Confira mais novidades no blog do Scott Raymond.

E-mail pra cá, e-mail pra lá… ele mandava algo em Java, eu entendia o problema e respondia com a solução em Ruby. E assim foi por um bom tempo.

Não nos limitamos somente à if/else’s e while’s. Fomos de estrutura de classes à threads, passando por I/O, requisições HTTP, regular expressions, etc.

O resultado foi interessante: em nenhum exemplo o código Java ficou menor. E o código não ficou somente menor, mas a clareza do que estava acontecendo também me agradou muito. O mais próximo que Java chegou foi em um pequeno exemplo em que quase empatou, mas… ficou no quase.

E ontem, estava fazendo umas experiências em casa com Ruby(novidade…) e acabei me lembrando do caso. Pergunta: alguém possui algum código em Java (hum, .net?) que não possa ser escrito de forma mais concisa em Ruby?

RadRails Screencast 28.5mb

open("mail.txt").grep(/\w+@\S+/) {print $& + ","}

public class SingletonBobao{
  private SingletonBobao(){}

  public static SingletonBobao getSingletonBobao(){
    if (ref == null) // ok, pode chamar o construtor
        ref = new SingletonBobao();
    return ref;
  }

  public Object clone()	throws CloneNotSupportedException{
    throw new CloneNotSupportedException();
  }

  private static SingletonBobao ref;
}

E em Ruby…

require 'singleton'
class SingletonBobinho
  include Singleton
end

Hummmmm…

ps: também funciona adicionando o parâmetro -http-proxy URL:

gem install rails -http-proxy endereco_proxy --include-dependencies