/usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"

Then install qt from source, using:

brew install qt --build-from-source

It should work.

Related:

• Qt 4.8 beta and Mac OSX Lion, Phonon error
• changing README to alert users about OS X 10.7 binary incompatibility

ps: esse é um post meu de 2005 que atualizei pra refletir a realidade do framework.

Rails é uma alternativa às soluções padronizadas qualificadas como “empresariais”, que implicam enormes cargas de trabalho sob o custo da compatibilidade com o vicioso ciclo burocrático de consultoria e treinamento que afeta as grandes empresas. Rails tem como proposta remover várias camadas de complexidade, salientando a capacidade individual do desenvolvedor em detrimento dos requerimentos burocráticos de equipe. Isso não deve passar a impressão, entretanto, de que Rails não é adequado para o trabalho em equipe. Rails adere ao padrão MVC de forma pragmática o bastante para promover uma separação clara de papéis, e ainda facilita o emprego de técnicas de Agile e Test-Driven Development.

O objetivo deste texto não é comparar Ruby/Rails com outros frameworks/linguagens, mas sim mostrar as principais vantagens que um desenvolvedor pode ter utilizando este framework. Seguem os pontos:

Produtividade – como o desenvolvedor consegue resolver seu problema de uma forma mais simples, clara e concisa o desenvolvimento se torna mais agradável e rápido.

Simplicidade – esta é uma característica forte em Ruby, pois a solução de um problema, normalmente, é atingida de uma forma extremamente simples e clara, o que facilita o entendimento do código por outros programadores que precisarem fazer manutenção no código.

Convention over configuration – o Rails se baseia no princípio convenção sobre configuração. Ao invés de criar dezenas de arquivos para configuração, basta utilizar algumas convenções pré-definidas e, caso necessário, customizar somente o que for necessário. A configuração é feita através de arquivos YML, um formato simples de declarar configurações. Isso se traduz diretamente para economia de tempo no desenvolvimento.

Code generation – você não precisa criar sempre toda a estrutura de código à partir do zero, o que permite um tempo de startup e time-to-market menor do projeto. A principal vantagem do Rails quando comparada à outras tecnologias é que o código gerado é limpo e conciso, facilitando manutenções futuras. Outros frameworks até possuem geradores de código, mas uma vez gerado, são extremamente complexos e difíceis de receberem manutenção.

DRY principle – Don’t Repeat Yourself é um conceito ‘criado’ por Dave Thomas (autor do livro The Pragmatic Programmer) que parafraseando significa:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

Como sempre foi dada muita importância pra isso, o framework como um todo foi moldado para evitar a duplicação de código.

Maturidade – a linguagem Ruby é bastante madura, foi criada pelo japonês Yukihiro “Matz” Matsumoto em 1993 e teve seu primeiro relase público em 1995(mesmo ano que o Java, por exemplo). Além disso, o framework Rails possui um bom tempo de vida, tendo seu primeiro release público em 2003.

Performance – o framework possui uma série de ferramentas e configurações que permitem excelentes ganhos de performance da aplicação e de uma forma simples, sem necessidade de um trabalho braçal por parte do desenvolvedor.

Segurança – o framework foi feito com uma grande preocupação nesse requisito, oferecendo ferramentas para tratamento das principais questões de segurança que um site precisa, como XSS e SQL-Injection, facilitando a vida do desenvolvedor e garantindo uma maior integridade da aplicação.

Suporte à vários databases – Rails vem com suporte à diversos databases, entre eles os principais bancos de dados do mercado: PostgreSQL, MySQL, Oracle, SQL Server.

IDE’s – já possui uma boa gama de ferramentas, como RubyMine, TextMate, Komodo, Aptana e Sublime Text.

Suporte nativo para Ajax – Ruby on Rails vem por padrão com o framework javascript jQuery, que permite a fácil adição de avançados recursos de interface, tornando mais fácil a criação de interfaces ricas e com melhor usabilidade.

Foco em testes – Ruby on Rails já vem com a ferramenta Test::Unit para automação dos testes da sua aplicação, além de possuir outras ótimas ferramentas como o RSpec.

Curva de aprendizado – aprender como funciona uma aplicação criada com Rails é mais simples que na maioria das outras tecnologias atuais, como Java, PHP, C#/.Net, como também para quem está querendo começar a desenvolver.

Cross-plataform – existe um bom suporte aos principais sistemas operationais do mercado, como Windows, Linux e MacOSX.

OpenSource – possui seu código completamente aberto, assim como a absoluta maioria dos plugins e bibliotecas disponíveis para ele. A comunidade é muito ativa e existem literalmente centenas de desenvolvedores que contribuem com código para melhorar o framework.

Feedback instantâneo – o ciclo de desenvolvimento é instantâneo, uma vez que não requer que o desenvolvedor fique reiniciando seu servidor de aplicação à cada mudança que faz (salvo algumas poucas configurações do framework).

Acredito que os itens acima já tenham sido suficientes para despertar a curiosidade para testá-lo. Se você estiver interessado em fazer alguém testar Ruby on Rails mas não quer ter muito trabalho, recomendo mostrar o vídeo Impressing with Rails 0.13, criado originalmente para ser usado no FISL 6.0, onde David Heinemeier Hansson mostra como criar um blog em 15 minutos ou o vídeo Introducing Rails 3, do Gregg Pollack.

Mas se você ainda não se convenceu que Ruby on Rails pode ser uma boa opção para seu projeto, abaixo seguem alguns links que reforçam o que eu falei:

Ruby on Rails: Making Programmers Happy
Entrevista com David Heinemeier Hansson no site eWeek.

Making programmers more productive
Phil Windley escreve sobre suas impressões sobre Rails.

The BBC’s programme catalogue (on Rails)
BBC está usando Rails para o seu catálogo com alguns milhões de shows.

…BBC have allowed me to rapidly prototype and deploy this 7,000,000-row database-backed site in everyone’s new favourite web framework…

Ruby on Rails and J2EE: Is there room for both?
Aaron Rustad faz uma comparação entre as principais features da arquitetura do Rails com os tradicionais frameworks J2EE

Interview with DHH
Entrevista com David Heinemeier Hansson, criador do Rails.

Get to the point!Development with Ruby and Rails
Apresentação mostrando as principais features da linguagem (Ruby em si, não especificamente do framework Rails). Muito bom pra mostrar para seu chefe(desde que ele seja/tenha sido um progrmador).

Ruby on Rails chases simplicity in programming
Entrevista com David Heinemeier Hansson, criador do Rails (saiu também no ZDnet).

SAP on Rails, and not on the skids
Com apenas algumas linhas de código, Piers Harding mostra como fazer integração com SAP, mostrando um pouco da flexibilidade do framework.

Evaluation: moving from Java to Ruby on Rails for the CenterNet rewrite
Case study muito interessante da migração do CenterNet(um grande aplicação da área de sáude) de Java para Ruby on Rails. E por ter sido feito em 6 vezes menos tempo (8 dias contra 6 semanas do Java) com uma redução de 20:1 para código, eu diria que sim, é uma redução bem relevante. Antes que alguns trolls apareçam criticando, sim, migrar uma aplicação é mais rápido do que desenvolver ela do zero, mas convenhamos, 20:1 é um número incontestável.

Ruby the Rival
Entrevista com alguns desenvolvedores experientes, mostrando sua visão da linguagem Ruby.

Ruby on Rail – Real World Usage
Uma lista com algumas empresas que já estão usando Rails em aplicações reais.

Ruby on Rails Dev Framework on Track for Growth

Fast-track your Web apps with Ruby on Rails
David Mertz demonstra através de uma mini-aplicação algumas vantagens do framework.

E isso pode ser o fim dos outros frameworks, seja Java, .Net, PHP, para desenvolvimento mainstream? Dificilmente. Que todo mundo abandonará Java e migrar para Rails? Com certeza, não.

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 $& + ","}