Programando sem cafeína

Corrigindo o enconding retornado pelo Net::HTTP do ruby 1.9

2011-03-22T22:56:00.000-03:00

A String retornada pelo Net::HTTP.get no ruby 1.9 sempre é definida com encoding "ASCII-8BIT". Acontece que muitas vezes esse não é o encoding correto da String, e portanto, erros esquisitos podem acontecer. Um exemplo pode ser visto abaixo quando utilizei essa String em um erb:

invalid byte sequence in UTF-8

Ou o seguinte, que acontece ao tentar encodar essa String para UTF-8:

> minha_string.encode("UTF-8")
Encoding::UndefinedConversionError: "\xC3" from ASCII-8BIT to UTF-8

A solução para este problema é antes de encodar, definir o encoding correto da String. Para isso podemos utilizar o header "content-type" retornado na requisição. Se por exemplo ele retornasse 'text/xml; charset=ISO-8859-1', podemos converter a String da seguinte forma:

> minha_string.force_encoding("ISO-8859-1").encode("UTF-8")

Para não ter que fazer isso a cada requisição HTTP, criei uma lib que altera o metodo body do HttpResponse. O código pode ser pego aqui:

http://gist.github.com/882465

Eu até pensei em alterar o metodo force_encoding da String para aceitar o valor do content-type, mas achei que isso seria dar muita responsabilidade para a String. Como o valor de content-type está apenas no ambito do HTTP, faz sentido colocar na classe Net::HttpResponse.

Gem brazilian-rails em versões de rails antigas

2010-11-03T10:36:00.003-03:00

Se você estiver usando uma versão antiga do brazilian-rails é bem provável que ao tentar instalar esta gem ela comece a instalar também versões superiores do rails. Isso porque esta gem possui um conjunto de dependências definidas somente com o operador ">=".

Ou seja, se você tentar instalar a versão 2.1.13 por exemplo, que funciona com o rails 2.3.2, ele tentará baixar a dependência da gem brdinheiro ">= 2.1.13", acabando por baixar a versão 3.0.0, que depende do activerecord 3.0.0, do rails 3. Nem preciso dizer que isso acabará dando merda.

A solução é baixar todos os componentes independentemente sem suas dependências da seguinte forma:

sudo gem install brnumeros --version=2.1.13 --ignore-dependencies
sudo gem install brdinheiro --version=2.1.13 --ignore-dependencies
sudo gem install brcep --version=2.1.13 --ignore-dependencies
sudo gem install brdata --version=2.1.13 --ignore-dependencies
sudo gem install brhelper --version=2.1.13 --ignore-dependencies
sudo gem install brstring --version=2.1.13 --ignore-dependencies
sudo gem install brcpfcnpj --version=2.1.13 --ignore-dependencies
sudo gem install brI18n --version=2.1.13 --ignore-dependencies
sudo gem install brazilian-rails --version=2.1.13 --ignore-dependencies

Solucionando IO bloqueante do mysql no ruby

2010-09-02T11:53:00.004-03:00

Fui a uma palestra muito interessante sobre performance na Oscon. A palestra No Callbacks, No Threads: Async & Cooperative Web Servers with Ruby 1.9, tratava do problema de IO bloqueante do driver do mysql para ruby, e como solução era proposto o uso de recursos como Event Machine e Fibers do ruby 1.9. Contudo, a solução não ficava nada elegante, tornando a manutenção do código muito complicada. Embora hoje haja um esforço para tornar esse trabalho transparente, consegui obter o mesmo resultado em performance basicamente aumentando o número de processos a atenderem as requisições.

Mas antes de explicar a solução é preciso demonstrar o problema. O caso é que embora tenhamos threads no ruby, alguns drivers como o do mysql são bloqueantes, ou seja, quando estão em uma operação de IO eles bloqueiam o processo inteiro, inclusive todas suas threads. Veja por exemplo o seguinte código:

class TestesController < ApplicationController
  def index
    Thread.new { Teste.connection.execute("insert into testes (id) select sleep(2)") }
    render :text => 'ok'
  end
end

Teoricamente ao fazermos a requisição a este controller de teste, a requisição não deveria durar os dois segundos de espera pelo retorno do insert ao mysql. Mas não é isso que acontece. As requisições acabam sendo enfileiradas pois o processo inteiro fica bloqueado a cada execução de query no banco. Isso pode ser comprovado utilizando o Apache Benchmark.

> ab -c 10 -n 10 http://localhost:3000/testes
...
Concurrency Level:      10
Time taken for tests:   20.514 seconds
Complete requests:      10
...

É bom deixar claro que o bloqueio ocorre somente ao usar o método execute do driver, que é responsável por fazer atualizações no banco. Fazendo somente consultas, o bloqueio não ocorre.

Na palestra em questão, foi demonstrado que utilizando Event Machine e Fibers é possivel desbloquear o processo utilizando callbacks. No final o tempo total foi reduzido para 2 segundos e alguns milésimos. Esse mesmo resultado eu obtive configurando um nginx com passenger configurado com 10 forks. Uma solução bem mais limpa. São apenas dois parametros, um do nginx, e outro do passenger:

worker_processes  10;
#...
http {
    passenger_max_pool_size 10;
}

E o resultado do teste:

> ab -c 10 -n 10 http://localhost/testes

Concurrency Level:      10
Time taken for tests:   2.424 seconds
Complete requests:      10

É claro que ainda sim a solução proposta na palestra é mais performática, até porque nela o consumo de memória é bem menor. Resta saber se essa economia vale a pena quando se pesa na balança o custo de manter um código mais complicado e os problemas que a concorrência podem trazer ao seu projeto. E para demonstrar o quão escalável é dividir as requisições em processos, fiz ainda um ultimo teste, com 1000 requisições, sendo 200 simultâneas, configurando o nginx e o passenger para trabalhar com 200 forks:

> ab -c 200 -n 1000 http://localhost/testes

Concurrency Level:      200
Time taken for tests:   13.043 seconds
Complete requests:      1000

Ou seja, o tempo total de teste manteve-se estável. Levando- em conta que dificilmente alguém fará um insert no banco com sleep, acredito que esssa seja uma boa solução para o problema de IO bloqueante. Ao invés de threads, utilizar processos.

Aumento de produtividade por ponto de complexidade

2010-08-09T13:24:00.000-03:00

Tenho ouvido ultimamente muitos amigos da área comentando sobre pressão por aumento de produtividade baseada em pontos de complexidade. Isso me deixa bastante preocupado. Embora seja nobre o desejo de aumentar as entregas da área de desenvolvimento, quantificar isso usando os pontos de complexidade das histórias não quer dizer muita coisa.

Contudo antes de simplesmente reclamar contra a pressão, é preciso analisar as possiveis causas de produtividade baixa que possam estimular esse tipo de pressão. Pensando bastante cheguei a três possibilidades, e com elas, possiveis soluções, que seriam mais eficazes do que estimular aumento desse tipo de numero.

1- Não há confiança de que o time esteja trabalhando em seu máximo. Ou seja, o agente gerador de pressão acredita que os integrantes estão fazendo corpo mole ou gastando o dia com amenidades ao invés de se focar na entrega do projeto. A pressão por aumento de pontos de complexidade pode até resolver esse problema temporariamente, mas também pode ser mascarado por integrantes do time que se sentem coagidos a fazer horas extras para cobrir as entregas esperadas. Ou seja, o problema só se resolve mesmo com conversas francas e com uma presença mais ativa do interessado.

2- O time percebendo folga na iteração aproveita para melhorar a qualidade da entrega ainda mais. Esse tipo de preciosismo costuma acontecer com bastante frequência. Muitas vezes o desenvolvedor por ter mais tempo para pensar aproveita para implementar testes e fluxos mais rebuscados evitando bugs que no futuro tomariam o triplo do tempo, e o designer aproveita para criar e rebuscar as interfaces e assim encantar ainda mais o cliente. Neste caso a pressão pelo aumento de entrega de pontos de complexidade apenas estimula a diminuição da qualidade. Ou seja, embora haja um aumento imediato na velocidade, em pouco tempo ela cairá por causa das correções de bugs e dos ajustes visuais.

3- O time é inexperiente ou não conhece a tecnologia adotada. Neste caso pressionar pelo aumento de entrega de pontos de complexidade de nada adianta. De certa forma, com o tempo, naturalmente as entregas serão maiores, ou em muitos casos menores pois o time começará a estimar com menos pontos, demonstrando assim a ineficácia desse numeros para medir produtividade. Para resolver este problema existem diversas opções como, organizar dojos, estimular programação em par, indicar livros e treinamentos, estimular a experimentação com tempo para projetos pessoais.

Todas três possibilidades acima eu vi acontecer de perto nos times em que trabalhei. E quase sempre o problema foi resolvido sem utilizar os pontos de complexidade como parâmetro de medição. E vocês lembram de alguma outra causa de produtividade baixa? Tem idéia de como solucionar? Qual sua opinião sobre o assunto?

Site de Passione estréia nova plataforma de novelas da Rede Globo

2010-05-17T19:14:00.009-03:00

Entrou no ar hoje a tarde o novo site de Passione, a nova novela das oito da Rede Globo. Mas por trás deste site está muito mais que um site. É o ínicio de uma nova experiência de consumo da dramaturgia da Rede Globo na internet.

Para quem não sabe, depois de quatro anos na equipe de videos da globo.com, me engajei logo no inicio deste projeto no time dedicado a ele. Apesar de ser a mesma empresa, é um mundo totalmente novo. Novas tecnologias, novas formas de gestão, novas pessoas. Tudo novo. Foi e está sendo muito bom.

E agora, com a entrega no prazo, e o feedback de dezenas de pessoas no twitter elogiando nosso trabalho, só tenho a agradecer ao meu time que me acolheu tão bem, e a todos as equipes que nos ajudaram, seja nos dando suporte, seja nos dando dicas, seja nos incentivando. Sem vocês o resultado não seria igual. Parabéns a todos nós!

Objetos fake em diversas linguagens para divertir minha vó

2010-03-03T20:03:00.017-03:00

Quase todas as linguagens que trabalhei possuem ferramentas para criar objetos fakes e assim auxiliar na construção de testes. Mas e se essas ferramentas não existissem? Estaríamos perdidos? Claro que não! Mocks e stubs podem ser criados de diversas formas diferentes nas diversas linguagens.

Esse é um ótimo assunto pra se discutir em um jantar de família. Quer coisa mais divertida que explicar pra sua avó como construir objetos fake em diversas linguagens? Por exemplo um simples stub que conta quantas vezes um método que notifica visualização de um filme em um serviço externo é chamado. Algo similar ao que o código abaixo faz. Diversão garantida!

servico.should_receive(:notificar_visualizacao!).with(filme).once

Em Ruby

Em ruby podemos simplesmente criar uma nova classe em tempo de execução ou adicionar um método a um objeto qualquer. É a maneira mais simples de garantir um sorrisão da sua vó tamanha facilidade. No caso do exemplo abaixo resolvi adicionar métodos a um objeto qualquer e ao final executo o teste utilizando o rspec.

servico_fake = Object.new
servico_fake.instance_eval do
  def notificar_visualizacao!(filme)
    @filme_visualizado = filme
    @quantidade_visualizacoes = quantidade_visualizacoes + 1
  end
  def filme_visualizado
    @filme_visualizado
  end
  def quantidade_visualizacoes
    @quantidade or 0
  end
end

filme = Filme.new
filme.servico = servico_fake
filme.visualizar!

servico_fake.filme.should be_equal(filme)
servico_fake.quantidade.should == 1

Em Python

Em Python é possivel alterar métodos de instancias em tempo de execução, mas não é possivel adicionar métodos a um objeto da classe object. Neste momento minha vozinha fica decepcionada. Para fazer algo semelhante ao que fizemos em ruby teríamos então que instanciar um objeto da classe original e só depois modificar o método. Ficaria mais ou menos assim:

filme_visualizado = None
quantidade_visualizacoes = 0

def notificar_visualizacao_fake(filme):
  global filme_visualizado, filme_visualizado 
  filme_visualizado = filme
  quantidade_visualizacoes += 1

servico_fake = ServicoExterno()
servico_fake.notificar_visualizacao = notificar_visualizacao_fake

Esta opção passa a ser ruim quando o construtor da classe original executa algumas tarefas que são custosas para o nosso teste. Por isso, acho que em python o melhor para o este caso é criar uma classe em tempo de execução, deixando minha vó um pouco mais alegre, conforme exemplo abaixo:

class ServicoFake(object):
  def __init__(self):
    self.filme_visualizado = None
    self.quantidade_visualizacoes = 0
  def notificar_visualizacao(self,filme):
    self.filme_visualizado = filme
    self.quantidade_visualizacoes += 1

servico_fake = ServicoFake()

filme = Filme()
filme.servico = servico_fake
filme.visualizar()

assert servico_fake.filme_visualizado is filme
assert servico_fake.quantidade_visualizacoes == 1

Em Java

Uma forma "simples" de fazer em Java é criando uma nova classe para herdar a original e sobrescrever somente o método desejado. Mas aí cairíamos no mesmo problema que discutimos sobre um possível construtor com código muito custoso na superclasse. E minha vó, que apesar de repetir muitas vezes as mesmas histórias, não gosta de ouvir as nossas repetidas.

Uma alternativa que temos é extrair uma interface da classe original para que em nosso teste a gente possa implementar essa interface da maneira que quisermos. Ficaria mais ou menos assim:

//ServicoExterno.java
public interface ServicoExterno {
  void notificarVisualizacao(Filme filme);
}

//ServicoExternoHTTP.java
public class ServicoExternoHTTP implements ServicoExterno {
  public ServicoExternoHTTP() {
    //Faz um monte de coisas
  }
  public void notificarVisualizacao(Filme filme) {
    //Faz mais coisas ainda
  }
}

Então em nosso teste a gente cria uma classe implementando a interface recém criada:

public class ServicoExternoFake implements ServicoExterno {
  public int quantidade_visualizacoes = 0;
  public Filme filme_visualizado = null;
 
  public void notificarVisualizacao(Filme filme) {
    filme_visualizado = null;
    quantidade_visualizacoes++;
  } 
}

E depois, mesmo que neste ponto minha vó já esteje dormindo, a gente utiliza a classe fake criada no teste:

ServicoExternoFake servicoFake = new ServicoExternoFake();
  
Filme filme = new Filme();
filme.setServico(servicoFake);
filme.visualizar();
 
assertSame(filme,servicoFake.filme_visualizado);
assertEquals(1,servicoFake.quantidade_visualizacoes);

Parece que minha avó não gostou da história. Ela começou tão dinâmica e foi ficando cadas vez mais devagar. Sem dúvida eu deveria ter contato ao contrário.

Upload de arquivo com selenium server no firefox

2010-02-09T17:02:00.003-03:00

Para fazer upload de arquivo com selenium é preciso alterar seu selenium-server.jar liberando permissão para que seja possível manipular campos do tipo file por javascript. Para fazer isso, extraia o selenium-server.jar:

jar -xvf selenium-server.jar

Crie um arquivo chamado user.js no diretório customProfileDirCUSTFF contendo um código semelhante com o exibido abaixo:

user_pref("signed.applets.codebase_principal_support", true);

user_pref("capability.principal.codebase.p0.granted", "UniversalFileRead");
user_pref("capability.principal.codebase.p0.id", "http://localhost");
user_pref("capability.principal.codebase.p0.subjectName", "");

Repare que a liberação de acesso é feita por host. No caso do exemplo estou liberando apenas para o ambiente local. Se desejar liberar outros hosts baixa adicionar outros conforme o exemplo abaixo:

user_pref("signed.applets.codebase_principal_support", true);

user_pref("capability.principal.codebase.p0.granted", "UniversalFileRead");
user_pref("capability.principal.codebase.p0.id", "http://localhost");
user_pref("capability.principal.codebase.p0.subjectName", "");

user_pref("capability.principal.codebase.p1.granted", "UniversalFileRead");
user_pref("capability.principal.codebase.p1.id", "http://globo.com");
user_pref("capability.principal.codebase.p1.subjectName", "");

Feito isso, basta gerar novamente o jar e executá-lo.

jar cvfm selenium-server.jar ./META-INF/MANIFEST.MF -C ./ .
java -jar selenium-server.jar

Já será possivel preencher o path de qualquer arquivo no campo como se ele fosse apenas um campo de textos. Isso no Firefox é claro.

Diferenças entre ruby e python: Que perigo

2010-01-15T14:03:00.001-03:00

Em ruby:

def a(z=[])
  z.push 'a'
end
a   # retorna  ["a"]
a   # retorna  ["a"]
a   # retorna  ["a"]
a   # retorna  ["a"]

Em python:

def a(z=[]):
  z.append('a')
  return z
a()   # retorna ['a']
a()   # retorna ['a','a']
a()   # retorna ['a','a','a']
a()   # retorna ['a','a','a','a']

Utilizando asserts para testar layouts

2009-11-25T18:18:00.006-03:00

Um dos problemas encontrados em nossos testes de aceitação é a impossibilidade de validar a aparência exata do resultado final de uma determinada ação do usuário. Conseguimos validar com o watir se determinada div possui um texto, se determinado link está presente, mas nada impede que eles estejam escondidos, por trás de outro div, ou com letras da mesma cor do fundo. É sempre útil, mas não necessáriamente exato, sendo sempre um ponto de falha. Ainda mais em um sistema como o que estamos trabalhando em que o visual para o usuário tem uma grande importância.

Eu e o quixadá, mestre do javascript e meu par de hoje, trabalhamos em uma correção de bug visual, e como costumamos trabalhar com desenvolvimento outside-in, chegamos ao dilema de como criar um teste para garantir que a falha existia. A solução encontrada foi inserir asserts dentro do código javascript, tal qual a funcionalidade de asserts do java. O código da função assert ficou parecido com o mostrado abaixo:

function assert(mensagem,valorDesejado,valorRecebido) {
 if( valorDesejado != valorRecebido ) {
   var html = '<div class="warning">' + mensagem + '</div>';
   $('body').append(html);
   throw mensagem;
 }
}

Em nosso caso, tinhamos que ter a certeza de que após um clique do usuário a barra de rolagem do elemento mantinha-se da mesma forma que anteriormente. Então o código ficou parecido com o mostrado abaixo:

$.get( url, function ( responseHtml ) {
 var scrollAnterior = $('#opcoes').scrollTop();
 substituiOpcoes( responseHtml );
 assert( 'Deveria manter scroll igual', scrollAnterior, $('#opcoes').scrollTop() );
});

No teste de aceitação verificamos então que o texto 'Deveria manter scroll igual' não deveria aparecer. O código do step do cucumber utilizando o watir pode ser visto abaixo:

Then /^a barra de rolagem deveria permanecer na mesma posição$/ do
 @browser.text.should_not include('Deveria manter scroll igual')
end

Com o teste pronto e falhando, aí sim corrigimos a função javascript substituiOpcoes(html) de forma a manter o scroll anterior.

Não é uma solução perfeita. Estamos pesquisando uma melhor, como pode ser vista no post Testes de aceitação automáticos para Flash com T-Plan Robot do Anselmo. Mas enquanto isso podemos evitar alguns pontos de falha visuais que costumávamos ter que testar manualmente. Dado que nosso sistema possui 100% de cobertura de testes unitários, somados a 152 cenários de teste de aceitação que abragem 1568 passos, acho que estamos indo por um bom caminho.

Web Astrologia: Duvidas, criticas e sugestões

2009-11-09T23:42:00.000-03:00

Utilize esse espaço para publicar duvidas, criticas e sugestões ao site http://webastrologia.com.br Sua contribuição será muito bem vinda.

API rest para OpenSocial do Orkut com ruby

2009-10-30T00:24:00.006-03:00

A documentação da API rest do OpenSocial do Orkut detalha muito bem as opções e formatos de retorno disponíveis porém é um tanto vaga sobre como fazer a autenticação necessária para usá-la. Basicamente lá é explicado os parâmetros a serem enviados e que o protocolo é o OAuth. Então detalho aqui como obter por exemplo os dados de um usuário apartir desta API.

Em primeiro lugar é preciso obter a consumer key e consumer secret de sua aplicação. Isso é feito gerando um token aqui: https://www.google.com/gadgets/directory/verify. Você deve colocar esse token dentro da tag content do xml descritor de sua aplicação e depois fazer a validação provando que é dono da aplicação. Com isso o Google irá lhe informar seu consumer key e consumer secret. Guarde eles com carinho.

Depois, com a gem oauth instalada você deverá executar um código semelhante ao exibido abaixo, com a premissa de que as variaveis consumer_key e consumer_secret estão preenchidas com os correspondentes à sua aplicação. E que a variável id é o id do usuário do Orkut que você está querendo conhecer melhor.

  consumer = OAuth::Consumer.new( 
    consumer_key, 
    consumer_secret, 
    :site => 'http://www.orkut.com',
    :scheme => :query_string,
    :http_method => :get 
  )
    
  request = consumer.create_signed_request(:get, 
    "/social/rest/people/#{id}/@self?xoauth_requestor_id=#{id}")  
  res = Net::HTTP.start('www.orkut.com', 80) do
    |h| h.request(request) 
  end

  puts res.body

TralhaController notificando obervadores por pattern

2009-08-01T03:03:00.003-03:00

TralhaController é uma biblioteca javascript que permite que aplicações web que utilizam requisições assíncronas ofereçam URLs para cada contexto de navegação do usuário. Para saber mais sobre ela basta ler o artigo Mantendo contexto usando ajax que o Bruno Carvalho escreveu recentemente.

Porém uma coisa me incomodava no uso dessa classe. Para cada observador registrado eu precisava dentro do método update verificar se ele precisava agir de acordo com a URL. Isso acaba por tornar o código mais confuso pois obrigava-nos a misturar validações e lógica de negócio. Veja um exemplo abaixo:

var observadorBusca = { update:function(url) {
  if( url.indexOf("#busca=")!=-1 ) {
    //Executa a busca
  }
} };
var observadorLink = { update:function(url) {
  if( url.indexOf("#link=")!=-1 ) {
    //Executa o link clicado
  }
} };
TralhaController.addObserver(observadorBusca);
TralhaController.addObserver(observadorLink);

Para tentar melhorar isso, pus a mão na massa e alterei o TralhaController permitindo registrar observadores que só fossem notificados diante de URLs que tivessem o padrão desejado. Utilizando então a última versão da biblioteca o código acima poderia então ser alterado para ficar da seguinte forma:

var observadorBusca = { update:function(url) { /* Executa a busca */ } };
var observadorLink = { update:function(url) { /* Executa o link clicado */ } };

TralhaController.addObserver("\\#busca\=.*", observadorBusca);
TralhaController.addObserver("\\#link\=.*", observadorLink);

Bem mais simples certo? É claro que há aqueles que não são muito fãs de expressões regulares e vão achar a primeira forma melhor. Para esses não há problema pois a forma antiga continua funcionando. Observadores registrados sem padrões continuam sendo notificados a toda e qualquer modificação de URL.

Roda: Eu também já recriei

2009-07-31T00:02:00.006-03:00

Uma das discussões mais quentes do momento, e também uma das mais antigas, é sobre a mania que nós desenvolvedores temos de reinventar a roda. Eu mesmo já reinventei diversas vezes e hoje olho para trás e vejo quanto tempo poderia ter poupado ao usar alguma ferramenta já pronta, ou apenas ter adaptado uma que não se encaixava perfeitamente aos meus requisitos.

Há claro excessões, em que seu requisito é tão mínimo que reimplementar uma solução é mais rápido do que aprender uma já existente no mercado. Como foi o caso de um sistema que estávamos desenvolvendo em PHP e precisávamos de um framework apenas para separar a lógica da renderização de templates por tema. Validamos rapidamente diversos frameworks MVC e percebemos que era mais fácil criar em meia hora a seguinte classe:

class Renderizador {
    function Renderizador($tema=null) {
     $this->_dir = dirname(__FILE__) . "/templates/" . $this->tema;
    }
    public function put($nome,$obj) {
     $this->$nome = $obj;
    }
    public function show($template) {
     include(  $this->_dir . "/" . $template . ".php");
    }
}

A utilização dela era mais simples ainda. No exemplo abaixo as variáveis inseridas no renderizador ficam disponiveis para o template listagem.php através de $this, que nada mais é do que um arquivo php comum.

$renderizador = new Renderizador('cinza');
$renderizador->put('lista',[1,2,3,4]);
$renderizador->show('listagem');

Simples, sem precisar aprender nenhum framework ou linguagem de marcação nova. Em duas horas o time já estava trabalhando com a lógica separada da apresentação. Contudo essa é a exceção.

Em geral já recriei diversas rodas desnecessariamente desperdiçando muito tempo. Framework de mapeamento objeto relacional, CMS, blog e até mesmo o TimerTask do Java são alguns dos exemplos. Esse último me rendeu uma longa discussão com o Phillip Calçado na época em que ele trabalhava aqui. Felizmente ele foi persistente em me fazer desistir daquela implementação.

De qualquer forma, o importante é a lição aprendida. Hoje tento usar ao máximo ferramentas já disponíveis, e quando alguma não me atende perfeitamente, ao invés de começá-la do zero eu a altero e contribuo, como foi o caso de uma recente alteração que precisei fazer no fakeweb.

Outros membros da equipe também já vem de longe com esta mesma filosofia e estão constantemente contribuindo como Guilherme Cirne ao contribuir com o WillPaginate, o Anselmo também contribuindo com o Fakeweb e o Bruno Carvalho contribuindo com o TralhaController e o ExceptionNotifier.

O importante é aproveitar aquilo que a comunidade já lhe oferece pronto e testado. Economiza tempo seu, e do próximo desenvolvedor, que dará manutenção a algo que é padrão, com muita discussão em fóruns e muitas soluções documentadas.

Dica rápida de charset para projetos rails com mysql

2009-07-18T02:16:00.003-03:00

Se você está trabalhando em um projeto ruby on rails com banco mysql, e o charset definido tanto no servidor como no database.yml é UTF-8, tome o cuidado para que inserções no banco por conta de terceiros também seja feito neste charset.

Um simples insert feito na mão utilizando o cliente padrão do mysql pode te atrapalhar bastante. E o erro ficará bem difícil de encontrar pois este mesmo client exibirá o texto corretamente e só o rails entregará o dado incorreto, fazendo você acreditar que o problema está no ruby.

Para evitar isso, sempre que fizer inserts na mão e de massa de dados execute como primeira linha o seguinte comando:

charset utf8;

Globo Vídeos: Quem viu este vídeo também assistiu

2009-07-09T04:04:00.004-03:00

É com muito orgulho que anuncio que acaba de sair para degustação uma nova funcionalidade do Globo Vídeos. Foi uma alteração que durou apenas um dia de desenvolvimento envolvendo o time inteiro e que ficará no ar por um tempo ainda em versão de teste. Trata-se de uma forma de ofertar vídeos baseada nas preferências de nossos usuários. Chamamos a funcionalidade de "Quem viu este vídeo também assistiu".

Como ainda está em versão "beta", para visualizar a alteração é preciso ter o addon Grease Monkey instalado no seu Firefox, e instalar o script que habilita a funcionalidade beta. Depois basta acessar o Globo Vídeos para poder aproveitar a nova facilidade disponível. E se possível, nos dê feedback dizendo o que achou e se encontrou algum problema na utilização. A opinião de vocês é muito importante para que a gente possa melhorar.

Teste de aceitação automático com múltiplas configurações no rails

2009-07-09T00:23:00.007-03:00

Dado que uma aplicação possua duas maneiras ou mais de funcionar de acordo com alguns parâmetros de inicialização, como proceder com os testes de aceitação automáticos sem ter que iniciar e parar o servidor entre cada cenário ou grupo de cenários?

A solução simples, mas bem funcional que adotamos, foi ter uma task rake para inicializar vários servidores no ambiente local, cada um com um environment e uma porta diferente. Assim, ao testar uma determinada funcionalidade com determinada configuração basta acessar o servidor naquela porta.

A task rake que poderia até mesmo ser um shell script, ficou mais ou menos como mostrado abaixo. Créditos ao Tiago PacMan, mestre em shell, que fez a linha que finaliza os servidores.


desc 'Inicia servidores para teste de aceitação'
task "server:test" do
  system 'script/server -d -e test_conf_1 -p 3001'
  sleep 1
  system 'script/server -d -e test_conf_2 -p 3002'
  sleep 1
  system 'tail -f log/test.log'
  system "ps aux | awk '/3001/{print $2}' | xargs kill -9"
  sleep 1
  system "ps aux | awk '/3002/{print $2}' | xargs kill -9"
  sleep 1
end

Repare que para este caso fizemos uma modificação no environments.rb para unificar os logs de todas os ambientes de teste.

Já no ambiente de integração contínua, onde utilizamos apache com passenger, foi mais simples ainda, bastando definir para diferentes VirtualHosts RailsEnvs diferentes.

Resolvendo o "missing uri map" no mod_jk

2009-07-09T00:01:00.004-03:00

Esses dias instalei o Ubuntu 9 em meu desktop e desde então tenho preparado o ambiente de desenvolvimento de diversas aplicações legadas. Uma delas necessita do apache conectando no tomcat pelo mod_jk. Após fazer a instalação de ambos e ter configurado os pontos de montagem do módulo, tudo de acordo com minha instalação antiga, deparei-me no log com o seguinte erro:

jk_translate::mod_jk.c (3038): missing uri map for tiago.motta:/MeuPathAqui

Descobri em uma grande thread de IRC que o problema ocorre quando o apache possui algum VirtualHost configurado, e que para resolver isso basta habilitar a configuração "JkMountCopy On" no VirtualHost correspondente.

DynamicStream garantindo compatibilidade com flash 9

2009-06-06T05:50:00.006-03:00

Ao implementar o DynamicStream em seu flash, teoricamente pararia de funcionar em clientes com a versão 9, pois algumas das classes e métodos necessários para seu uso só estão disponíveis apartir da versão 10.

Para evitar isso a Adobe disponibilizou um artigo mostrando como integrar o DynamicStream em um player antigo, para que só utilize o recurso novo quando o plugin do cliente estiver na versão 10, garantindo assim a compatibilidade. Este artigo possui até mesmo um exemplo, que embora funcione sem problemas em flash 9, quando integrado em outros projetos não funciona.

O problema é um bug na classe de referência que a Adobe oferece em diversos de seus artigos sobre essa funcionalidade. O erro fica evidente quando utilizamos um flash player debugger de versão 9 sobre o swf gerado, até mesmo os de exemplo da empresa.

verifyError: Error #1053: Illegal override of play2 in DynamicStream.

Esse erro ocorre porque a classe DynamicStream de referência sobrepõe o método play2 de NetStream apenas para anulá-lo. Com isso o plugin fica obrigado a verificar a existência do método play2 em NetStream e acaba dando o erro, pois tal método só está disponível apartir da versão 10.

Removendo esse método da classe DynamicStream de referência, tudo passa a funcionar, pois o acesso aos recursos existentes nas versões maiores ficam restritos ao conteudo dos métodos, que só serão avaliados em tempo de execução.

Não fosse o Bruno FMS me dar a dica do flash player debugger, perderia mais um bom tempo testando diversos artíficios para tentar fazer o código rodar em flash 9.

Iptable para testar fallback para rtmpt no flash

2009-06-02T20:21:00.005-03:00

Para testar se o fallback do seu flash player está funcionando corretamente, e acessando o flash media server pela porta 80 com rtmpt, basta configurar seu iptables para rejeitar ou deletar os pacotes da porta 1935, que é a padrão do FMS:

sudo iptables -A OUTPUT -p tcp --dport 1935 -j REJECT

sudo iptables -A OUTPUT -p tcp --dport 1935 -j DROP

Sem esquecer de ao finalizar seus testes limpar o iptables para continuar seus testes:

sudo iptables -F

Padrões de URLs com expressões regulares no Fakeweb

2009-05-11T18:32:00.006-03:00

Ao usarmos o Fakeweb aqui onde trabalho encontramos a necessidade de registrar grupos de URLs de acordo com um padrão. Inspirado no Anselmo Alves, colega de minha equipe que corrigiu um bug nesta mesma gem, alterei-a de forma a permitir o registro de URLs utilizando regex.

Com essa alteração, se por exemplo você quiser que todas as chamadas a um determinado host sejam respondidas com uma determinada string, basta registrar como o mostrado abaixo:

FakeWeb.register_uri(:get, /programandosemcafeina\.blogspot\.com/, :string => "Meu blog")

O principal desafio no desenvolvimento dessa nova funcionalidade foi não quebrar compatibilidade com o uso anterior. Dessa forma, os registros de URLs absolutas passaram a ter uma prioridade maior independente da ordem em que forem registradas. Ou seja, os retornos de acordo com as expressões regulares só são executados se a URL absoluta solicitada não estiver registrada. Veja o exemplo abaixo:

FakeWeb.register_uri(:get, "http://programandosemcafeina.blogspot.com/search/label/rails", :string => "Label Rails")
FakeWeb.register_uri(:get, /programandosemcafeina\.blogspot\.com/, :string => "Meu blog")
FakeWeb.register_uri(:get, "http://programandosemcafeina.blogspot.com/search/label/ruby", :string => "Label Ruby")

Net::HTTP.get(URI.parse("http://programandosemcafeina.blogspot.com/search/label/rails"))
=> "Label Rails"

Net::HTTP.get(URI.parse("http://programandosemcafeina.blogspot.com/search/label/ruby"))
=> "Label Ruby"

Net::HTTP.get(URI.parse("http://programandosemcafeina.blogspot.com/search/label/rmagick"))
=> "Meu blog"

Já solicitei ao Chris Kampmeier a integração do meu fork, mas enquanto ela não é feita, você pode utilizar a gem gerada diretamente do meu repositório no Github. Basta intalar da seguinte forma:

gem sources -a http://gems.github.com
sudo gem install timotta-fakeweb

Undefined method request_uri com HTTParty

2009-05-04T19:19:00.003-03:00

Dica rápida para quem está utilizando HTTParty: Se por um acaso você se deparar com o seguinde erro:

undefined method `request_uri' for #<URI::Generic:0xb03919c>
/mnt/apps/filmes/vendor/gems/httparty-0.3.1/lib/httparty/request.rb:56:in `setup_raw_request'
/mnt/apps/filmes/vendor/gems/httparty-0.3.1/lib/httparty/request.rb:39:in `perform'
/mnt/apps/filmes/vendor/gems/httparty-0.3.1/lib/httparty.rb:153:in `perform_request'
/mnt/apps/filmes/vendor/gems/httparty-0.3.1/lib/httparty.rb:119:in `get'
/mnt/apps/filmes/app/models/Filme.rb:25:in 'com_tags'

Não se desespere, URI:Generic realmente não possui o método request_uri. O problema é na incialização do HTTParty. Se base_uri estiver nulo qualquer requisição utilizando a classe obterá esse erro. Teste você mesmo algo como:

class A
  include HTTParty
  base_uri nil
  format :xml
end

A.get('/search/label/ruby')

Ao corrigir a inicialização de base_uri o erro deixa de acontecer:

class A
  include HTTParty
  base_uri 'http://programandosemcafeina.blogspot.com'
  format :xml
end

A.get('/search/label/ruby')

O problema é passível de ocorrer principalmente se base_uri for configurável de acordo com o ambiente em que a aplicação estiver rodando.

Esperando o resultado de uma chamada assíncrona no Watir

2009-04-16T17:20:00.003-03:00

Em alguns casos quando uma determinada requisição assíncrona demora para retornar, o teste de aceitação implementado com Watir pode falhar. Principalmente quando os testes estão rodando em alguma ferramenta de integração contínua.

Para evitar essa falha irritante, o usual é colocar alguns sleeps após as ações que disparam as chamadas ajax. Contudo, isso não garante que o teste não vá falhar, especialmente se o sleep for baixo. Em contrapartida se forem colocado muitos sleeps altos poderá haver uma demora muito grande para rodar todos os testes.

Uma solução possível é esperar que um determinado elemento html seja inserido ou removido da página para então continuar executando os testes. Para isso implementei um método genérico que recebe um bloco de verificação. Veja o exemplo de uso dele:

espera { @browser.text.include? 'Ajax retornado' }

O código do método é bem simples e está descrito abaixo. Ele recebe um bloco assumindo que quando este retornar verdadeiro significa que a espera deve terminar, caso contrário ele continuará esperando e verificando, com um timeout de 30 segundos.

def espera
  Timeout::timeout(30) do
    while not yield
      sleep 1 
    end
  end
end

Nomes de métodos e variáveis devem ser no idioma do cliente

2009-03-16T13:50:00.001-03:00

Recentemente Carlos Brando escreveu um excelente artigo em seu blog sobre nomes de métodos e variáveis. Dentre as diversas dicas, uma eu não concordei, comentei lá sobre isso, e o argumento de resposta não me foi convincente.

O ponto de discordância dizia respeito a necessidade de evitar código bilingue. Segundo ele, já que a maioria das linguagens de programação são em inglês, nada mais correto do que escrever o nome das classes e metódos também em inglês. Para começar vou contar uma pequena historinha:

Experiência própria: Laboratório geológico

Há um bom tempo atrás trabalhei em uma empresa que desenvolvia um sistema para um laboratório geológico. Um dia, um dos desenvolvedores do time ligou para tirar duvidas com o cliente e fez a seguinte pergunta "Quando um sample alcança um result no segundo stage em determinado job, ele pode parar os próximos stages ou deve seguir até a conclusão de todos".

O rapaz na outra ponta ficou completamente confuso. Era novo no laboratório, conhecia toda cadeia de análises de amostras mas não conhecia os estranhos termos que a equipe de desenvolvimento vira e mexe falava. Sample, result e stage não eram palavras de domínio do laboratório, e sim os seus similares em português. Mas como o sistema estava sendo desenvolvido com os termos em inglês, constantemente os membros do time de desenvolvimento, eu incluso, os citava, atrapalhando a comunicação e o entendimento dos problemas.

Eis então a pergunta: Será que um código que mistura termos em inglês e português causa mais problemas que os ruídos na comunicação com o cliente? Pode-se alegar que o código nem será mostrado ao usuário, mas na hora em que o desenvolvedor precisa se comunicar com o cliente, na mente dele ele não está trabalhando com amostras, ele está trabalhando com samples.

Mas o mais interessante é que dentre o domínio do laboratório geológico, um item era em inglês, o Job. Eles falavam amostras, estágio, resultados, mas falavam Job. Isso então nos leva a uma conclusão.

O idioma como ferramenta

A grande questão é que o idioma é apenas uma ferramenta para a comunicação. O primeiro item do manifesto ágil fala "Indivíduos e interação entre eles mais que processos e ferramentas". No caso, acredito que a interação entre os individuos, no caso a comunicação, é mais importante do que a ferramenta, que no caso é o idioma. Portanto eu prefiro priorizar a comunicação independente do idioma. Se meu cliente possuir termos em seu negócio em francês e outros em alemão, eu prefiro utilizá-los no meu sistema para que ao conversar com ele eu não me confunda com os termos usados na programação.

Um contra-argumento muito usado é dizer que utilizar termos em português em uma linguagem de programação em inglês torna o código sujo. Mas será que isso é realmente verdade?

Código limpo depende do idioma?

Antes de discutir é preciso definir o que é um código limpo. Em minha concepção código limpo é aquele fácil de entender. As técnicas apresentadas pelo Carlos Brando são realmente importantes. Mas será que o seguinte código é complicado de entender?

amostras = Amostra.obter_amostras_com_resultado_positivo
amostras.each do |amostra|
  puts amostra.produto.sigla
end

Será que o fato de utilizarmos inglês misturado com o português tornou mais dificil o seu entendimento? Eu não só creio que não, como acredito que por conta das expressões utilizadas pelo cliente serem idênticas ao do programa, o entendimento fica mais fácil ainda.

Dizer o contrário é o mesmo que defender o uso de arcabouço e chamada de retorno ao invés de framework e callback, em trabalhos acadêmicos somente por uma questão de purismo idiomático. É nesse público que políticos como o deputado Aldo Rebelo se mira, tentando aprovar projetos de lei perigosos.

Mas e o mercado internacional?

Outro ponto levantado para defender o uso de termos diferentes dos do domínio do cliente é a possibilidade de venda do software ao exterior em algum remoto dia. Ao meu entender isso é um pouco de síndrome do mapa de calor. Um problema comum em empresas de desenvolvimento que não seguem o manifesto ágil. Este tipo de argumento futurista era muito utilizado para defender que aplicações fossem escritas em Java. Coisas do tipo "E se um dia quisermos colocar esse software numa geladeira".

O interessante é que na resposta que recebi, foi citado que para não haver confusão nas conversas com o cliente poderíamos fazer as especificações em português. Mas oras, quando um software é vendido, as especificações vão juntas. Se for vendido para o exterior teríamos o mesmo problema. E pior ainda, as especificações, que dizem exatamente o que o sistema faz estariam em uma lingua diferente da do cliente.

O fato é que a possibilidade de se vender um sistema ao exterior em algum futuro remoto não deve se tornar um empecilho na comunicação com o cliente local, que é quem vai gerar receita mais brevemente. Se um dia realmente a venda for uma possibilidade real faz-se um refactory.

Só para constar, a desculpa para desenvolver o sistema exemplificado no ínicio do post em inglês foi exatamente esta. Hoje, 6 anos depois o foco da empresa mudou totalmente, nenhum outro sistema de laboratório foi vendido ou criado. Somente este continua em manutenção. Dos outros que desenvolvi em Java nenhum precisou trocar de sistema operacional ou mesmo ser instalado em geladeiras.

Enfim a conclusão

O que defendo não é programar em um idioma e não em outro. Defendo que deve-se programar o mais próximo da realidade. Se o seu cliente tiver todos os termos do seu negócio em inglês, ótimo, programe em inglês. Fora isso, vejo apenas dois outros motivos para basear sua programação no idioma britânico: O software que você está desenvolvendo é uma biblioteca ou framework open-source; Ou a maioria dos membros da sua equipe só fala inglês.

Alias e functions para seu dia-a-dia com git

2009-03-12T21:54:00.011-03:00

Embora o Git seja uma poderosa ferramenta de controle de versão, a quantidade de passos que é necessário para executar alguns procedimentos básicos pode dificultar um pouco o dia-a-dia do desenvolvedor. Principalmente se o projeto em questão não requer todas as funcionalidades que o git oferece para compartilhar código entre grandes equipes espalhadas.

Felizmente é possível criar alguns alias e functions para facilitar o seu uso. Dessa forma podemos utilizar o git de maneira mais simples, e quando houver a necessidade de usar um dos seus recursos avançados, basta não usar esses atalhos. Segue abaixo os que tenho utilizado:

gitshazam

Adiciona todos os arquivos criados, modificados, deletados e depois comita para o repositório local com a mensagem informada.

alias gitshazam='git add -u && git add . && git commit -m'

Exemplo de uso:

gitshazam 'Minha mensagem de commit'
git push

gitcoleradodragao

Sincroniza com o repositório remoto as informações dos branchs existentes e os exibe, mostrando também em que branch você está desenvolvendo atualmente.

alias gitcoleradodragao='git fetch && git branch -a -v'

gitpodediamante

Cria um branch local com o nome informado e o associa ao branch de mesmo nome no repositório remoto.

function gitpodediamante() { git checkout --track -b $1 origin/$1; }

Exemplo de uso:

gitpodediamante 'historia-22'

gitmeteorodepegasus

Baixa as ultimas atualizações no master e no branch indicado no parâmetro, e posteriormente faz o merge do master dentro deste branch.

function gitmeteorodepegasus() { git checkout master;git pull;git checkout "$1"; git merge master; }

Exemplo de uso:

gitmeteorodepegasus 'historia-22'

Agradecimentos especiais à galera da minha equipe que tem me ajudado bastante com o git e aguentado minhas reclamações.

Duck typing e os testes de aceitação automáticos

2009-02-26T17:27:00.000-03:00

Uma discussão frequente em minha equipe é sobre maneiras de garantir que nossos sistemas estejam funcionando adequadamente por meio de testes automáticos. Em nossos ultimos projetos temos conseguido alcançar 100% de cobertura de testes unitários, e nos sistemas legados temos aumentado a cobertura aos poucos.

No entanto, estamos cientes de que nem 100% de cobertura de testes unitários garantem a ausência de bugs. Isso nos remete aos testes de aceitação automáticos, não só por causa do funcionamento das telas e fluxos de navegação, mas também dos possíveis problemas que um refactoring com um pouco menos de atenção pode causar em uma linguagem baseada em duck typing.

Darei um exemplo em ruby para ilustrar um bug que pode ser introduzido sem que seus testes unitários percebam. Digamos que você tenha as seguintes classes:

class Filme < ActiveRecord::Base do
  def alugar
    self.estoque.remover self
  end
end
class Estoque < ActiveRecord::Base do
  def remover(filme)
    # ...
  end
end

No seu spec que verifica o método alugar da classe Filme você colocaria um mock mais ou menos como mostrado abaixo:

@estoque = mock_model(Estoque)
@estoque.should_receive(:remover).with(@filme).once

Um dia você percebe que o nome do método remover não está explicando muito bem o significado, e resolve fazer um refactoring renomeando-o para remover_fita_do_filme.

Você altera os testes da classe Estoque, renomeia o método e logo depois recebe uma ligação de uma empresa de telefonia te oferecendo serviços excepcionais que você nunca precisou. Puto da vida você desliga o telefone, roda os testes e todos passam! Serviço feito!

Perceberam o problema? Sem um teste de aceitação automático ou no mínimo um teste manual, você não perceberia que a classe Filme continua referenciando o método antigo, remover, da classe Estoque. Esse tipo de problema não passaria em uma linguagem que não segue duck typing, pois a etapa de verificação de código da compilação serviria como uma espécie de teste unitário de tipos e nomes.

Um problema mais evidente seria um método que recebe um objeto que precisa ter determinado método, ou seja implementar determinada interface. Veja o exemplo abaixo, que mostra que ao alugar um item, no caso um Filme, adiciona-se todas as tags dele às tags preferenciais do cliente:

class Cliente < ActiveRecord::Base do
  def alugar(item)
    #...
    adiciona_tags_preferenciais item.tags
  end
end
class Filme < ActiveRecord::Base do
  def tags
    # ...
  end
end

Se mudarmos o nome do método tags em Filme e também corrigirmos o uso de dele no método alugar da classe Cliente tudo funcionará bem. Mas, como usamos duck typing não temos como garantir que outros objetos, digamos alugáveis, tenham sido alterados. Se por exemplo esta locadora também alugas livros, teríamos um erro evidente:

class Cliente < ActiveRecord::Base do
  def alugar(item)
    #...
    adiciona_tags_preferenciais item.tags_principais
  end
end
class Filme < ActiveRecord::Base do
  def tags_principais
    # ...
  end
end
class Livro < ActiveRecord::Base do
  def tags
    # ...
  end
end

Esse tipo de erro só seria pego num teste manual se lembrássemos de testar o aluguel de livros também. Por isso é tão importante o teste de aceitação automático em uma linguagem com duck typing. Em Java por exemplo, que a interface precisa ser explícita, o erro seria pego no que poderíamos considerar o teste unitário que a compilação executa. As classes Filme e Livro implementariam a interface Alugavel por exemplo:

public interface Alugavel {
  List tagsPrincipais();
}

Mas é claro que o uso de uma liguagem menos dinâmica não remove a necessidade de testes de aceitação automáticos. O valor desse tipo de testes é independente da linguagem, e sua implementação é importantíssima para garantir fluxos de navegação e integração entre os diversos componentes do sistema.

Plugin do rails para copiar erros de um model para outro

2009-02-19T18:01:00.005-03:00

Em um projeto pessoal precisei desenvolver uma maneira de copiar os erros de um model para outro. Como é uma funcionalidade que outrora já havia precisado, aproveitei para criar um plugin e disponibilizá-lo para quem mais tiver esse mesmo problema.

O plugin está disponível no GitHub pelo endereço http://github.com/timotta/copy_errors_from/tree/master. Para instalar no seu projeto basta rodar a seguinte linha:

script/plugin install git://github.com/timotta/copy_errors_from.git

Após instalar todos os seus models terão o método copy_errors_from, que pode ser utilizado como mostrado abaixo:

> filme = Filme.new :titulo => 'Corra que a polícia vem aí'
> ator = Ator.new
> filme.atores.push ator
> filme.save #return false
> filme.errors.entries #return []
> ator.errors.entries #return [['nome','Não pode ser vazio']]
> filme.copy_errors_from ator
> filme.errors.entries #return [['ator_nome','Não pode ser vazio']]
> filme.errors.on(:ator_nome) #return 'Não pode ser vazia'

Cuidado ao cachear named_scope no Rails

2009-01-23T10:02:00.013-03:00

Deve-se tomar cuidado ao cachear o acesso a um named_scope pois ele tem um carregamento de forma preguiçosa, o famoso lazy load. Assim, o código abaixo gravaria no cache não os atores femininos, mas sim todos os atores.

class Filme
    #...
  def atores_femininos_cacheado
    Rails.cache.fetch("#{self.id}:atores-principais") { self.atores.femininos }
  end

class Ator
  #...
  named_scope :femininos, :conditions => { :sexo => 'F' }

Se você observar o log, verá que o rails executará a query sem as condições definidas na classe Ator para o named_scope :femininos. E que após ser cacheado, será essa a query que deixará de ser executada.

A query para buscar atores femininos do named_scope só será realmente executada quando algum método do objeto retornado pelo método .atores.femininos for chamado. Veja no exemplo abaixo:

@filme = Filme.find_by_id 10
filme.atores_femininos_cacheado.last

Ou seja, o cacheamento não está servindo ao propósito definido. Uma solução para isso é cachear diretamente o resultado de um find, como pode ser visto abaixo:

class Filme
    #...
  def atores_femininos_cacheado
    Rails.cache.fetch("#{self.id}:atores-principais") do
      Ator.find_all_by_filme_id self, :conditions => { :sexo => 'F' }
    end
  end

PGError com Rails no Heroku

2009-01-21T10:58:00.005-03:00

Essa dica é para quem utiliza o Heroku Garden para desenvolver suas aplicações rails. Ao rodar os specs diretamente da interface web do Heroku pode ser que um dia você se depare com o seguinte erro:

PGError: ERROR: relation "filmes" does not exist
: SELECT a.attname, format_type(a.atttypid, a.atttypmod),
d.adsrc, a.attnotnull
FROM pg_attribute a LEFT JOIN pg_attrdef d
ON a.attrelid = d.adrelid AND a.attnum = d.adnum
WHERE a.attrelid = 'filmes'::regclass
AND a.attnum > 0 AND NOT a.attisdropped
ORDER BY a.attnum

O erro acontece porque o link para rodar as migrations, que aparece na interface do heroku, não as executa no ambiente de testes. Portanto, é preciso abrir a tela do rake e executar as seguintes linhas antes de rodar seus specs.

db:migrate
db:test:prepare

UPDATE

Descobri outro problema do Heroku. O schema.rb é criado e alterado no diretório tmp. Dessa forma para que o PGError não dê novamente em outra atualização do banco, você precisa copiá-lo para o diretório db e então no console do rake rodar:

db:test:clone

Imagem de fundo no captcha gerado pelo simple_captcha

2008-10-09T09:09:00.003-03:00

O simple_captcha, plugin de geração de captcha para rails, não possui opção para colocar um imagem de fundo na imagem gerada. Mas fazer isso não é nenhum bicho de sete cabeças, basta alterar algumas partes chaves do plugin utilizando um pouco de rmagick. Vou mostrar aqui mais ou menos como fiz isso em um recente projeto.

No arquivo simple_captcha_image.rb basta alterar o método generate_simple_captcha_image para que na criação da imagem seja colocado o fundo desejado. Veja o exemplo de código abaixo:

def generate_simple_captcha_image(options={})  #:nodoc

  fundo = Magick::Image.read(url_da_imagem_de_fundo).first
  preenchimento = Magick::TextureFill.new(fundo)
      
  @image = Magick::Image.new(197, 45, preenchimento) do 
    self.format = 'JPG'
  end

  # ...

Repare que existe ali uma chamada ao método url_da_imagem_de_fundo que no caso é um método que pega o path de uma imagem aleatória. Dessa forma o captcha poderá ter vários fundos diferentes. Veja um exemplo de como pode ser a implementação desse método:

  def url_da_imagem_de_fundo
    "#{RAILS_ROOT}/vendor/plugins/simple_captcha/assets/imgs/picture_" + (rand(9)+1).to_s + ".jpg"
  end

Foi preciso também comentar a chamada ao método que aplica estilo e distorção à imagem, mas não sei bem se isso é necessário. Como fiz isso, precisei alterar o método append_simple_captcha_code que escreve o texto na imagem, de forma a utilizar diversos tamanhos, posições e fontes diferentes.

Validação no lado cliente com form_remote_tag

2008-10-08T19:30:00.004-03:00

Para fazer validações de formulário no lado cliente basta informar ao método form_tag ou ao form_for, utilizando o parâmetro :onsubmit, o código javascript que se deseja executar para validá-lo. Veja no exemplo:

  <% form_tag "/entrar", :onsubmit => 'return valida(this)' do %>
      <h1>ok</h1>
  <% end %>

Contudo para a tag form_remote_tag e form_remote_for não há a possibilidade de utilizar o parâmetro :onsubmit. Isso porque o formulário gerado pelo rails já possui a ação onsubmit definida com o código que fará o acesso remoto. Para colocar então sua validação antes deste código deve-se usar o parâmetro :before como é mostrado no exemplo:

  <% form_remote_tag :url => "/entrar", 
        :update => 'meu_div', 
        :before => 'if( !valida(this) ) return false' do %>
      <h1>ok</h1>
  <% end %>

Repare que é importante que haja o "return false" no caso de não ter sido validado, caso contrário ele executará o restante do código colocado pelo rails no onsubmit.

Impedindo redeclaração de objetos javascript

2008-10-02T22:48:00.004-03:00

Ao importar duas vezes um mesmo arquivo .js em uma página, as funções, protótipos e objetos são redeclarados. Se for necessário que um determinado objeto mantenha seu estado durante as iterações assíncronas dessa página, perde-se este estado na segunta importação do arquivo .js.

Veja por exemplo o objeto abaixo, que nada mais é que um repositório de outros objetos. Tá ta ta, não é um exemplo que tenha tanta utilidade, mas vá lá, é só pra explicar o mecanismo.

var Repositorio = {
    sequencia:0,
    lista:[],
    registrar:function(obj) {
        var id = ++this.sequencia;
        this.lista[ id ] = obj;
        return id;
    },   
    recuperar:function(id) {
        return this.lista[ id ];
    }
}

Agora estando esse código num arquivo por exemplo repositorio.js teríamos o problema relatado com o código a seguir:

<script src="repositorio.js"></script>
<script>
    Repositorio.registrar( new Object() );
    Repositorio.registrar( new Object() );
</script>
<script src="repositorio.js"></script>
<script>
    alert( Repositorio.recuperar( 1 ) );
</script>

Para impedir essa redeclaração do objeto, e os possíveis erros que ela pode causar, basta tentar utilizá-lo dentro de um bloco try e fazer sua declaração dentro do bloco catch. Ou seja, ele só será declarado caso haja um erro na tentativa de usá-lo. Veja:

try{ Repositorio.existo(); }
catch(e) {
    Repositorio = {
        sequencia:0,
        lista:[],
        existo:function(){},
        registrar:function(obj) {
            var id = ++this.sequencia;
            this.lista[ id ] = obj;
            return id;
        },   
        recuperar:function(id) {
            return this.lista[ id ];
        }
    }
}

Mas aí você poderia me dizer: Pô pra que tudo isso, basta não importar duas vezes o javascript. Acontece que se você está criando uma biblioteca para ser distribuída para diversos sites e blogs, você não deve subestimar a "criatividade" dos utilizadores dela. Então, o melhor é se precaver.

Cópia exclusiva de coleção

2008-09-18T19:58:00.006-03:00

Por serem de díficil identificação, problemas de concorrência acabam indo pra produção sem sequer serem notado em ambiente de testes e desenvolvimento. Erros acabam ocorrendo de maneira intermitente, causando dores de cabeça e acessos de insanidade nos desenvolvedores. Martin Fowler em seu livro Patterns of Enterprise Application Architecture identifica algumas soluções para evitar problemas de concorrência relativos a integridade de dados. Contudo há um outro problema que não está catalogado neste livro: A concorrência de informações na memória.

Ao guardar objetos em uma coleção que é compartilhada por outras threads, é necessário tomar providências para que não sejam lançadas exceções inesperadas. A medida básica é garantir que os pontos de acesso às coleções compartilhadas devem obter exclusividade sobre seu uso com a diretiva synchronized. Veja abaixo um exemplo de classe que torna o uso de uma lista à prova de erros de concorrência:

public class ListaSegura {
    private List lista = new ArrayList();
    public void adiciona(Object objeto) {
        synchronized (lista) {
            lista.add(objeto);
        }
    }
    public void remove(Object objeto) {
        synchronized (lista) {
            lista.remove(objeto);
        }
    }
    public void listar() {
        synchronized (lista) {
            for (Object o : lista) {
                System.out.println(o);
            }
        }
    }
}

É uma solução simples e que resolve em parte o problema. Contudo na maioria das vezes não podemos obter a exclusividade para iterar sobre uma coleção. No caso mostrado acima isso é possível pois estamos apenas imprimindo o objeto. Mas existem alguns casos em que obter essa exclusividade para a iteração nos traria alguns problemas. Esses casos estão descritos abaixo:

1- Alteração da coleção: No caso de você iterar pela coleção para remover ou adicionar algum objeto a ela. A exclusão ou adição ocorreria no meio da iteração e com isso seria lançada uma exceção de concorrência.Um exemplo simples disso são classes que gerenciam cache e precisam periodicamente remover objetos expirados.

2- Iteração prolongada: Quando a coleção possui objetos demais ou o processo executado durante a iteração é lento, tornando o tempo de exclusividade total muito longo. Isso faria com que o restante do sistema que precisasse utilizar essa coleção ficasse muito tempo aguardando pela exclusividade terminar. Um exemplo comum é a execução de métodos que acessem banco de dados dentro da iteração de um objeto exclusivo.

Para resolver esses dois casos identifiquei o padrão de desenvolvimento Cópia Exclusiva de Coleção. A idéia é obter a exclusividade da lista somente para fazer uma cópia dos itens em outra coleção e então poder iterar sobre esta cópia sem muitas preocupações. Abaixo mostro um exemplo de uma classe Armario que possui muitas Coisas. Se alguma coisa for lixo, ela deve ser removida na execução do método removeLixo.

public class Armario {
    private List coisas = new LinkedList();
    public void removeLixo() {
        List copia = lista();
        for (Coisa coisa : copia) {
            if (coisa.isLixo())
                remove(coisa);
        }
    }    
    public List lista() {
        List copia = null;
        synchronized (coisas) {
            copia = new ArrayList(coisas.size());
            copia.addAll(coisas);
        }
        return copia;
    }
    public void adiciona(Coisa coisa) {
        synchronized (coisas) {
            coisas.add(coisa);
        }
    }
    public void remove(Coisa coisa) {
        synchronized (coisas) {
            coisas.remove(coisa);
        }
    }
}

Com isso o tempo de exclusividade fica restrito ao tempo da cópia para a outra coleção, que ocorre no método lista. Dessa forma temos uma folga no tempo de iteração total e a possibilidade de rearranjar a coleção, adicionando ou removendo itens a ela. É importante ressaltar que o melhor jeito de evitar o calafrio de receber um java.util.ConcurrentModificationException é evitar a utilização de objetos compartilhados entre threads. Quando isso não é possível, o jeito é utilizar um padrão como Cópia Exclusiva de Coleção.

On-demand javascript com PHP

2008-09-16T20:48:00.005-03:00

A técnica de script on-demand serve para compartilhar dados entre domínios. A idéia dela é driblar as restrições da classe XMLHttpRequest, que só permite requisições no mesmo domínio, e a restrição do iframe que no máximo permite comunicação entre sub-domínios de um mesmo domínio.

Basicamente consiste em adicionar um script à página quando uma informação é necessária. Esse script proverá a informação necessária chamando uma função de callback ao solicitador. Uma explicação mais detalhada sobre a técnica pode ser encontrada em On-Demand_Javascript - AjaxPatterns.

Com PHP fica ainda mais fácil desenvolver o script provedor de dados. Digamos por exemplo que você queira obter a lista de livros de uma biblioteca, seu javascript ficaria assim:

var Livros = {
    listar:function() {
        var s = document.createElement('script');
        s.type = 'text/javascript';
        s.src = 'listaDeLivros.php?callback=Livros.onload_listar';
        document.getElementsByTagName('head')[0].appendChild(s);
    }
    onload_listar:function(html) {
        document.getElementsByTagName('lista').innerHTML = html;
    }
}

A função listar insere um javascript à página informando a ele a função javascript de callback. No PHP informaremos o html gerado chamando a função enviada no parâmetro callback. Mais ou menos como mostrado abaixo:

<?php echo $_REQUEST['callback']; ?>("<h1>Lista de livros</h1>");

Mas é claro que normalmente o html gerado não será de apenas uma linha. Além disso ele poderá ter diversos dados com aspas e outros caracteres que poderiam causar erros de javascript. Ficar se preocupando com esse tipo de coisa na diagramação do html é trabalhoso e passível de muitos erros.

Para evitar isso podemos utilizar a função ob_start, que faz com que tudo o que for escrito no output seja guardado em buffer e ao final remetido a uma função de callback do PHP. Nesta função então pode-se tratar o html e enfim escrever no real output para o cliente. Veja como ficaria:

<?php 
function captura_buffer($html) {
    $html = addslashes($html);
    $html = str_replace("\n", '\n', $html);
    $html = str_replace("\r", '\r', $html);
    return  $_REQUEST['callback'] . '("' . $html .  '");';
}
ob_start('captura_buffer');

$livros = funcao_ficticia_para_obter_livros();

foreach($livros as $livro) {
?>

<p>
<?php echo $livro->id ?> - 
<b><?php echo $livro->titulo ?></b> - 
<?php echo $livro->autor ?>
</p>

<?php } ?>

KeyDown e KeyUp para applets java

2008-09-03T13:50:00.003-03:00

Um grande problema da interface KeyListener do Java é não possuir uma maneira de saber se uma ou mais teclas estão pressionadas ao mesmo tempo, e quando elas realmente são soltas. Quando você mantém uma tecla pressionada os eventos keyPressed e keyReleased são ativados consecutivamente, e se você pressiona e segura outra tecla, o keyReleased da tecla anterior para de ser notificado, seguido por uma notificação consecutiva do keyPressed e keyReleased da nova tecla. Isso é facilmente demonstrado no applet abaixo:

public class ComProblema extends Applet implements KeyListener {
    @Override
    public void init() {
        addKeyListener(this);
    }
    public void keyPressed(KeyEvent e) {
        System.out.println("Pressionou: " + e.getKeyCode());
    }
    public void keyReleased(KeyEvent e) {
        System.out.println("Soltou: " + e.getKeyCode());
    }
    public void keyTyped(KeyEvent e) {}
}

Ao executarmos esse applet clicando e segurando a tecla "a" por alguns segundos, depois apertar e segurar a "w" por outros tantos e ao final soltar as duas, teremos o seguinte resultado:

Pressionou: 65
Soltou: 65
Pressionou: 65
Soltou: 65
Pressionou: 65
Soltou: 65
Pressionou: 65
Soltou: 65
Pressionou: 65
Soltou: 65
Pressionou: 65
Soltou: 65
Pressionou: 65
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 87
Pressionou: 87
Soltou: 65
Soltou: 87

Encontrei em diversos fóruns pessoas com o mesmo problema e nenhuma solução. Então, para resolvê-lo implementei uma espécie de KeyAdapter para facilitar a notificação de quando uma tecla é apertada e quando ela é solta. O uso de exemplo dela ficaria como o mostrado abaixo:

public class SemProblema extends Applet {
    @Override
    public void init() {
        super.init();
        addKeyListener(new CumulativeKeyAdapterImpl());
    }
}
class CumulativeKeyAdapterImpl extends AcumuladorKeyAdapter {
    @Override
    public void keyDown(KeyEvent e) {
        System.out.println("Down: " + e.getKeyCode());
    }
    @Override
    public void keyUp(KeyEvent e) {
        System.out.println("Up: " + e.getKeyCode());
    }
}

O resultado fazendo a mesma combinação de teclas apertadas no teste anterior neste outro applet, seria como o mostrado a seguir:

Down: 65
Down: 87
Up: 65
Up: 87

Você também pode ver outros exemplos de applets utilizando o AcumuladorKeyAdapter aqui. Para utilizar esse recurso basta baixar os fontes e binários da timotta-api e colocar o timotta-api-applet.jar no atributo archive da sua tag applet, como demonstrado no exemplo abaixo:

<applet code="br.com.timotta.applet.MostraTeclas" 
    archive="timotta-api-applet-exemplos.jar,timotta-api-applet.jar"
    width=256 height=256 >
</applet>

Passagem de array como parâmetro em subrotinas de Perl

2008-08-18T17:25:00.000-03:00

Passar um array como parâmetro em uma subrotina de Perl pode ser muito complicado sem saber todos os conceitos da linguagem. Veja abaixo um exemplo de uma função recebendo arrays de cinco maneiras diferentes:

sub faz_nada_util
{
        print "(" . $_[0] . "," . $_[1] . ")";
}

my @array_1 = (1,2); 
my @array_2 = [3,4];

faz_nada_util @array_1;
faz_nada_util \@array_1;
faz_nada_util @array_2; 
faz_nada_util (5,6);
faz_nada_util [7,8];

A saída será:

(1,2)
(ARRAY(0x81536b4),)
(ARRAY(0x815360c),)
(5,6)
(ARRAY(0x8176f5c),)

O importante no exemplo é verificar que quando criamos um array utilizando colchetes [] estamos retornando na verdade não o array, mas a referência a este array. Dessa forma o primeiro item de @_ seria a referência ao array. Isso é mostrado na terceira e na última linha do resultado.

Quando criamos com o uso de parênteses () temos na váriavel o array em si. Então quando passamos esta lista à subrotina, os itens são copiados um a um no array @_. Isso é demonstrado na primeira e na quarta linha do resultado. Usando a contra-barra \ indicamos no segundo print que queremos enviar a referência do array criado com parênteses.

Mas e se você fizer uma função que receba como parâmetro um texto e um array como parâmetros? Você pode fazer da seguinte maneira:

sub continua_fazendo_nada_util
{
        my $nome = shift;
        print $nome . ": \n";
        foreach $nome ( @_ ) {
                print "- " . $nome . "\n";
        }
}
continua_fazendo_nada_util("tiago", (1,2,3,4));

É como se a função recebesse como parâmetro um único grande array. Esse tipo de solução funciona bem quando o último parâmetro é o array, pois podemos dar shift dos parâmetros iniciais e iterar com os restantes. Num caso por exemplo em que a função deva receber dois arrays, podemos fazer a passagem de parâmetro pela referência.

sub nada_pra_fazer_aqui
{
        my @array_1 = @{$_[0]};
        my @array_2 = @{$_[1]};

        print "array1: \n";
        foreach $a (@array_1) {
                print "- $a\n";
        }
        print "array2: \n";
        foreach $a (@array_2) {
                print "- $a\n";
        }

}
nada_pra_fazer_aqui [1,2,3], [4,5,6];

Web Democracia: críticas e sugestões

2008-08-14T01:07:00.000-03:00

Utilizem o espaço dos comentários para postar suas críticas e sugestões

Installed, but unpackaged files found em um RPM

2008-08-12T14:47:00.006-03:00

Você pegou um projeto antigo, adicionou um diretório e um arquivo e alterou a sessão %install de seu SPEC para instalar esse arquivo, mas ao rodar o rpmbuild o seguinte erro é obtido:

Checking for unpackaged file(s): /usr/lib/rpm/check-files /var/tmp/MeuPrograma-1.0.7-tiago
error: Installed (but unpackaged) file(s) found:
   /usr/local/MeuPrograma/etc/configuracao.properties

No caso o diretório novo é etc e o arquivo novo é configuracao.properties. A resolução desse problema é simples, basta adicionar o novo diretório à sessão %files, para que o rpmbuild o empacote, da seguinte forma:

%files
# ... outros arquivos aqui
/usr/local/MeuPrograma/etc

Erro esotérico ao inserir clobs e blobs no oracle

2008-06-17T16:16:00.007-03:00

A mensagem de erro do Oracle "table or view does not exist" é simples e direta. O problema acontece quando você está fazendo uma série de inserções em uma tabela, utilizando a mesma String de SQL para todas, e lá pela sexta inserção a mensagem de erro aparece:

java.sql.SQLException: ORA-00942: table or view does not exist

Até que você descubra que pode haver algum problema com o sexto registro da tabela, você perde um bom tempo tentando encontrar algum problema de lógica ou alguma desatenção sua. Até mesmo bufa de raiva achando que é algum bug do Oracle. E de certa forma é.

No meu caso descobri que o erro acontecia quando inseria textos grandes demais em uma coluna clob. Encontrei então um documento da oracle explicando como gravar clobs no oracle utilizando JDBC. O macete é configurar o JDBC com o parâmetro SetBigStringTryClob, assim:

Properties propriedades = new Properties();
propriedades.put("user", "meuUsuario" );
propriedades.put("password", "pensaQueVouTeContar?");
propriedades.put("SetBigStringTryClob", "true");
return DriverManager.getConnection("jdbc:oracle:thin:@meuserver.com:filmes", propriedades);

Fazendo isso o estranho erro parou de acontecer. De certa forma acredito que este é um bug do Oracle, pois no mínimo a mensagem de erro deveria ser algo informando que o tamanho do valor excede o permitido na coluna. Ou até informando que não foi possivel inserir devido a erros no preenchimento da coluna tal.

Contudo, essa não foi a unica vez que este erro aconteceu comigo. Ao inserir dados em um campo blob o maldito "table or view does not exist" deu as caras novamente. No caso eu errei o tipo de dado utilizando setString. Mas dessa vez eu já estava calejado, então bastou verificar que para inserir blobs bastaria fazer algo como o mostrado abaixo:

byte[] arr = new byte[] {0,1};
ByteArrayInputStream b = new ByteArrayInputStream(arr);
statement.setBinaryStream(i, b, b.available() );

Mas que fique bem claro que o fato de eu estar inserindo clobs e blobs no banco não quer dizer que eu ache isso uma boa prática e que eu recomende. Ao contrário, acredito que seja melhor na maioria das situações que esses dados fiquem no sistema de arquivos.

Cálculo da variância com Ruby

2008-06-07T15:08:00.002-03:00

No blog Kodumaro foi publicado uma comparação de cálculos estatísticos entre linguagens imperativas, como C, e linguagens funcionais, no caso o Lisp. Os cálculos utilizados como exemplificação foram os de variância da população e variância da amostra. Como estou estudando ruby, me empolguei e resolvi fazer a versão desses cálculos nessa linguagem.

Veja como o código ficou:

class Array
  def acumula()
    acc = 0
    each { |a| acc += yield(a) }
    acc
  end
  def media()
    total = acumula { |a| a }
    total / length
  end
  def numerador_de_variancia()
    m = media
    acumula { |a| (a - media)**2 }
  end
  def variancia_populacional()
    numerador_de_variancia / length
  end
  def variancia_da_amostra()
    numerador_de_variancia / (length-1)
  end
end

O que fiz foi criar novos métodos na classe Array para fazer todos os cálculos necessários. O interessante é que não encontrei na documentação do Ruby nenhum método que iterasse sobre um array e retornasse um acumulo dos valores calculados por um bloco. Para suprir isso criei então o método acumula.

Apesar do código ter ficado um pouco mais verboso que o código em lisp exibido no Kodumaro, o uso ficou mais simples. Como são novos métodos, para obter a variância da amostra em um array basta por exemplo fazer [2,4,6].variancia_da_amostra. Veja abaixo um exemplo de uso desses métodos:

array = [2,4,6]
puts "Media: #{array.media}"
puts "Numerador de variancia: #{array.numerador_de_variancia}"
puts "Variancia populacional: #{array.variancia_populacional}"
puts "Variancia da amostra: #{array.variancia_da_amostra}"

Mas é importante ressaltar o perigo dessa alteração de classe. Veja que não faço nenhum tratamento sobre o tipo de dado do array. No caso, estou assumindo que todo array que vá utilizar esses métodos tenham sempre todos os indices preenchidos por numeros.

EDS: Excell Driven Scrum

2008-06-07T04:22:00.001-03:00

Para quem não sabe, EDS é o Excell Driven Scrum. Ou vocês achavam que siglas com a palavra mágica Driven serviam somente para Development? Estavam enganados. O EDS ocorre quando o P.O. elabora previamente um planejamento, sprint a sprint, do que deve ser feito pelo time para um longo período de tempo. Este planejamento é então gravado em um arquivo excell read-only.

Pelo pouco que entendo de Scrum, esse padrão é uma maneira muito equivocada de se pôr em prática um ambiente de desenvolvimento ágil. Isso porque a definição dos sprints deveria ser feita com a particiação do time. E mesmo se esse tal planejamento anual fosse feito com o time, ainda sim eu consideraria errado, pois é impossivel prever com muita antecedência fatores ambientais que fatalmente mudam as necessidades e problemas que precisam ser resolvidos.

Além disso, o fato de termos escopos definidos para cada sprint, faz o sprint planning 1 ficar engessado. O time perde a liberdade de sugerir histórias prioritárias que garantam a qualidade do sistema. Isso acaba causando um desgaste durante a reunião, o time não entendendo como o P.O. pode ignorar os possiveis problemas da aplicação e os riscos que eles podem causar, e o P.O. sem entender porque o time não aceita seguir o planejamento anual.

Acontece que muitas vezes o uso deste padrão não é culpa do P.O., é uma parte da cultura anterior à adoção do Scrum que ainda não foi possivel mudar. Contudo, não se pode fechar os olhos para este problema. Para acabar com o EDS, é preciso que o P.O. brigue corajosamente contra ele. O time também precisa bater o pé o máximo possivel para mudar esta cultura. E a briga não é apenas para mudar a cabeça de quem está acima hierarquicamente, é também para mudar suas próprias mentes.

Portanto, apesar de ter pouca experiência com scrum, acredito que utilizar o padrão EDS não é uma boa alternativa de implantação dele. Pela minha vivência de menos de um ano e a participação em apenas um curso, me parece que um dos principais benefícios que o Scrum traz é a liberdade que o time tem para identificar problemas e resolve-los para garantir a qualidade do produto. Com o EDS isso não é possivel.

Como obter a URL do SWF

2008-06-06T19:45:00.002-03:00

Essa aqui é básica, mas eu procurei bastante no Google e não encontrei. Acabei só achando no help do próprio flash. Caso você precise obter no seu aplicativo flash qual é o caminho completo do seu SWF, basta utilizar a propriedade loaderURL do objeto loaderInfo contido no seu MovieClip. Veja abaixo:

package {
    public class Main extends MovieClip {
        function Main() {   
            trace( "URL do SWF: " + this.loaderInfo.loaderURL );
        }
    }
}

FullScreen do flash não funciona em players abaixo de 9.0.28, e agora?

2008-05-15T18:02:00.003-03:00

Desde a versão 9.0.28 do flash é possível definir seu swf para rodar em tela cheia de maneira bem simples. Também é possivel definir um listener para ser notificado quando o modo de exibição do flash é alterado de normal para fullscreen e vice-versa. Contudo, se você colocar essas funcionalidades, seu swf não rodará em versões anteriores a 9.028.

O jeito então é alterar seu ActionScript para só setar a o fullscreen quando a versão for compatível. Veja abaixo como isso pode ser feito:

import flash.display.StageDisplayState;

public class Main extends MovieClip {

    //...

    function suportaTelaCheia():Boolean {
        //Verifica versao >= que 9.0.28
    }
    function onBotaoTelaCheiaClique(event:MouseEvent):void {
        if( suportaTelaCheia() ) {
            stage.displayState = StageDisplayState.FULL_SCREEN;
        }
    }
    function onBotaSaiTelaCheiaClique(event:MouseEvent):void {
        if( suportaTelaCheia() ) {
            stage.displayState = StageDisplayState.NORMAL;
        }
    }

    //...
}

Apesar da classe flash.display.StageDisplayState não existir no player com versão menor que 9.0.28, a importação dela não trará erro, pois o flash só executa a importação de uma classe quando faz uso dela. Portanto a seleção da versão feita com o método suportaTelaCheia impede seu uso e consequente importação.

O problema maior é quando precisamos definir um listener para sabermos quando o swf entrou em modo fullscreen e quando saiu. Normalmente isso é necessário quando precisamos redimensionar, ou adicionar elementos ao stage. No caso o código, sem o tratamento de versão, ou seja, o que daria erro nas versões de flash anteriores a 9.0.28 ficaria assim:

import flash.events.FullScreenEvent;

public class Main extends MovieClip {

    //...

    private function onStage(event:Event):void {
        stage.addEventListener( FullScreenEvent.FULL_SCREEN, redrawFullScreen );
    }

    //...

    function redrawFullScreen(event:FullScreenEvent):void {
        if( event.fullScreen ) {
            //Posicionar elementos para tela cheia
        } else {
            //Posicionar elementos para tamanho normal
        }
    }

    //....

}

O grande problema disso é que o uso da classe FullScreenEvent está na definição do método redrawFullScreen e portanto não é possivel defini-lo somente quando for uma versão ou outra. O jeito então então é mudar a assinatura do método, para ao invés de receber um FullScreenEvent receber um Event. Com essa correção o código ficaria assim:

import flash.events.FullScreenEvent;

public class Main extends MovieClip {

    //...

    function suportaTelaCheia():Boolean {
        //Verifica versao >= que 9.0.28
    }

    private function onStage(event:Event):void {
        if( suportaTelaCheia() ) {
            stage.addEventListener( FullScreenEvent.FULL_SCREEN, redrawFullScreen );
        }
    }

    //...

    function redrawFullScreen(event:Event):void {
        if( event['fullScreen'] ) {
            //Posicionar elementos para tela cheia
        } else {
            //Posicionar elementos para tamanho normal
        }
    }

    //....

}

Repare que além de ter mudado a assinatura do método, mudei também o uso do objeto event. Isso foi feito porque a classe Event não possui o atributo fullScreen declarado, então utilizar event.fullScreen daria erro de compilação. Mas como sabemos que ali há este atributo, podemos utilizá-lo usando a notação event['fullScreen'].

Como instalar o flash 9.0.16 para testar seu swf

2008-05-14T18:24:00.005-03:00

É muito importante que ao criar um swf complexo, como um player de vídeo por exemplo, você execute testes em todas as versões de flash player que você deseja que ele suporte. Para isso a Adobe oferece em seu site diversas versões antigas do flash player para download. Contudo, se você está no Windows XP e deseja intalar a versão 9.0.16, mas já possui uma versão mais nova instalada, é preciso seguir os seguintes passos.

Primeiro é preciso desinstalar a versão atual do flash player executando o programa uninstall_flash_player.exe encontrado na página How to uninstall the Adobe Flash Player plug-in and ActiveX control. Depois de executar isso é preciso acessar o regedit e remover a seguinte chave: HKEY_LOCAL_MACHINE\SOFTWARE\Macromedia\FlashPlayer.

Feito isso, reinicie o computador. Ok ok, paciência, estamos lidando com Windows portanto todo cuidado é pouco. Mãos a obra: Iniciar > Reiniciar (Heim?).

Após reiniciado basta instalar a versão 9.0.16 que pode ser baixada em Archived Flash Players available for testing purposes. Nesse link podem ser encontradas diversas outras versões do flash player e é bem possível que o escrito aqui sirva para instalar essas outras versões.

Undefined method *_path no uso do form_for

2008-05-06T00:51:00.004-03:00

Essa é uma dica boba para aqueles que estão começando em ruby on rails como eu. Fazendo aqui um exemplos simples de cadastro de filmes recebi o seguinte erro:

NoMethodError in Filme#incluir

Showing filme/incluir.html.erb where line #5 raised:

undefined method `filmes_path' for #<ActionView::Base:0xb76f144c>

Extracted source (around line #5):

2: 
3: <%= error_messages_for :filme %>
4: 
5: <% form_for @filme do |f| %>
6:   <p>
7:     <b>Título</b><br />
8:     <%= f.text_field :titulo %>

Pelo que eu entendi até agora, isso acontece porque eu não estou utilizando os métodos padrões do ruby on rails. Se eu estiver falando besteira por favor me corrijam. O fato é que resolvi isso definindo a ação que o form deverá executar, o código da view então ficaria da seguinte forma:

<h1>Incluir novo filme</h1>

<%= error_messages_for :filme %>

<% form_for @filme, :url => { :action => 'salvar' } do |f| %>
  <p>
    <b>Título</b><br />
    <%= f.text_field :titulo %>
  </p>

  <p>
    <b>Resumo</b><br />
    <%= f.text_area :resumo %>
  </p>

  <p>
    <%= f.submit "Incluir" %>
  </p>
<% end %>

No caso o controlador possui o método salvar.

Dependência entre tarefas no Scrum

2008-05-01T01:05:00.003-03:00

Um problema recorrente nas reuniões diárias do nosso projeto aqui na globo.com é a dependência entre tarefas. Sempre ocorrem interrupções entre o fluxo de "O que eu fiz" e "O que farei" para questionar a algum colega do time se determinada tarefa já foi concluída. No caso afirmativo ele pode então pegar a tarefa que era dependente. Isso acontece frequentemente, e quando ocorre o fluxo desanda e a atenção se dispersa. Começam então algumas conversas paralelas que acabam atrapalhando o andamento da reunião.

O ideal, é claro, é que não houvessem tarefas dependentes entre si em uma história. Mas isso é muito díficil, e segundo minha breve experiência com Scrum, e nesse ponto ela se resume a apenas alguns poucos projetos web, me parece ser impossivel. Como exemplo posso mostrar três tarefas que foram presentes na maioria das histórias dos projetos que participei e que são dependentes entre si:

1- Criar design
2- Criar html e css estático
3- Implementar camada de visualização

A tarefa 2 depende da tarefa 1, e a tarefa 3 depende da tarefa 2. É claro que seria possível paralelizar a tarefa 3 com a 2, fazendo com que a implementação da camada de visualização fosse apenas de um html tosco. Mas mesmo assim seria necessária uma quarta tarefa para fazer o merge do html bonito com a camada de visualização, e esta nova tarefa seria enfim dependente da tarefa 2.

Ou seja, não vejo como paralelizar todas elas. E cabe aqui uma brecha para colaboração dos leitores no caso de terem encontrado alternativas, ficaria feliz de conhecê-las. De qualquer forma, existem outras situações específicas de cada empresa e de cada time que elevam mais ainda o número de dependência entre as tarefas.

Eis então que presenciei em outro time uma boa adaptação da reunião diária. Ao invés de cada membro do time responder as três perguntas, um em seguida do outro, os membros dizem primeiro o que fizeram, uma após o outro, depois dizem o que pretendem fazer, um atrás do outro, e ao final o que os impede, também da mesma forma.

Com isso o time resolveu de maneira simples um problema que parece não ter solução, sem sacrificar a reunião diária, pois todos saem dela sabendo o que fazer, o que já está pronto e quais são os impedimentos do projeto. Cumprindo exatamente o propósito dela.

Demora do Firefox para começar a receber os eventos de um Comet

2008-04-21T01:38:00.004-03:00

Quando abrimos um HTTP Stream, ou Comet como é chamado hoje em dia, no Firefox, demora um tempo até que os dados comecem a ficar disponíveis. Ao que parece ele espera haja 1kb de dados já recebidos para começar a deixá-los disponíveis para uso. Contudo, há uma forma de habilitar o processamento dos eventos do Comet no Firefox diretamente sem esperar esse 1kb inicial. Basta definir o content type do retorno como multipart/x-mixed-replace. Em Java seria algo como o mostrado abaixo:

response.setContentType("multipart/x-mixed-replace");

Ativando o conector NIO no Tomcat 6

2008-04-19T23:02:00.004-03:00

Para utilizar o CometProcessor do Tomcat 6 é preciso configurar o servidor para utilizar o NIO Connector ao invés do conector http padrão. Caso contrário, ao acessar o seu CometProcessor você receberá o seguinte erro:

message HTTP method GET is not supported by this URL

description The specified HTTP method is not allowed for the requested resource (HTTP method GET is not supported by this URL).

Para habilitar então este conector basta alterar no arquivo server.xml o atributo protocol do conector, deixando-a mais ou menos da seguinte maneira:

    <Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol" 
               connectionTimeout="20000" 
               redirectPort="8443" />

Globo.com no Fisl 9.0

2008-04-15T13:17:00.003-03:00

Do dia 17 a 19 de Abril estarei em Porto Alegre participando do Fisl 9.0 junto com Guilherme Chapiewski, Tiago Peczenyj e mais um monte de gente da Globo.com. Estaremos lá para conversar um pouco sobre os problemas e soluções de um dos maiores portais da internet brasileira e todo nosso esforço para basearmos essas soluções em software livre. Especificamente estarei lá para conversar sobre o portal Globo Vídeos e as nossas ultimas pesquisas com software livre. Quem quiser me encontrar para bater um bom papo nerd é só me procurar no stand da Globo.com. É claro que não estarei o tempo inteiro lá, pois assistirei diversas palestras, no entanto farei o possível para ficar o máximo de tempo lá. Além disso criei um grupo de fotos no 8P para publicarmos as fotos do evento. Assim, se você quiser participar do grupo de fotos do Fisl 9.0 é só se associar e publicar suas fotos. Por hora é só, vejo vocês lá!

Bash para redimensionar imagens

2008-04-14T21:54:00.004-03:00

Toda segunda-feira é a mesma história, depois de um final de semana de festas e diversão, todo mundo fica solicitando, porque não dizer exigindo as fotos tiradas durante os eventos. O problema é que fotos de câmeras digitais costumam ser grandes, tornando dificil a transferencia para os amigos.

O Caio Moritz postou em seu blog uma dica de como redimensionar imagens pela linha de comando usando o comando mogrify. O problema é que o bash que ele criou redimensiona as imagens sem manter as originais. Então, tomei a liberdade de incrementá-lo um pouco, devido às minhas necessitades. Segue abaixo como ficou:

#!/bin/sh
if [ -z $2 ] 
then 
    echo "Uso: resizepics.sh diretorioFonte diretorioDestino";
    exit;
fi

echo "Criando diretorio $2";
mkdir "$2";

echo "Copiando arquivos de $1 para $2";
cp "$1/"*.jpg "$2";

echo "Entrando no diretorio $2";
cd "$2"

echo "Redimensionando imagens";
for img in *.jpg; 
do 
 echo "$img"; 
 mogrify -resize 800x600 "$img"; 
done

Pronto, salve com o nome de resizepics.sh. Para executá-lo é só informar como primeiro parâmetro o diretório onde estão as fotos, e no segundo o diretório onde serão colocadas as fotos redimensionadas. É claro que para isso funcionar você precisa instalar o pacote imagemagick conforme informado no post do Caio.

Brincando de extensões com o chrome do Firefox

2008-04-04T16:04:00.003-03:00

Desenvolver extensões para o Firefox é algo muito divertido. Mas há certas questões que nos deixam de cabelo em pé. Basicamente por falta de exemplos e tutoriais simples. No caso, eu procurava duas coisas: Como acessar o elemento html que foi clicado com o botão direito do mouse, e como copiar um determinado trecho selecionado para a área de transferências (clipboard).

Nessas horas então, nada melhor que analisar os códigos contidos no Chrome do Firefox. Descompactando os arquivos browser.jar e toolkit.jar, localizados no diretório ${FIREFOX_HOME}/chrome, podemos verificar diversos bons exemplos.

No arquivo browser.js do pacote browser.jar por exemplo, pude verificar que para acessar o elemento clicado com o botão direito basta utilizar a notação document.popupNode. O exemplo abaixo mostra de maneira simples um Xul e um Js de um item no menu do botão direito cuja única função é exibir a tag html do elemento clicado com o botão direito.

Xul:

<popup id="contentAreaContextMenu">
 <menuitem id="itemMenuExibirTag" label="Exibir tag" oncommand="exibirTag()"/>
</popup>

Js:

function exibirTag() {
 alert( document.popupNode.tagName );
}

Já para implementar a função de copiar para a área de transferência, verifiquei no arquivo browser.xul do pacote browser.jar que os menus de copiar do próprio navegador chamavam a função goDoCommand com o parâmetro cmd_copy. Encontrei essa função no arquivo globalOverlay.js do pacote toolkit.jar. Havia nele um comentário informando que a função era apenas para manter compatibilidade com versões antigas, e realmente a única coisa que ela fazia era repassar a função para o método doCommand da classe CommandUpdater. Abaixo mostro um exemplo de item que seleciona todos os itens de uma página e copia o conteúdo para o clipboard:

Xul:

<popup id="contentAreaContextMenu">
 <menuitem id="itemMenuCopiarPagina" label="Copiar pagina" oncommand="copiarPagina()"/>
</popup>

Js:

function copiarPagina() {
 CommandUpdater.doCommand('cmd_selectAll');
 CommandUpdater.doCommand('cmd_copy');
}

Definindo atributos somente leitura em uma classe PHP

2008-04-03T19:14:00.003-03:00

O modificador private em PHP, assim como em quase todas as linguagens, impede que membros de uma classe sejam acessados para leitura e escrita. Mas e se você deseja que os atributos de uma classe sejam privados para escrita mas não para leitura? Uma solução simples seria criar métodos get para cada atributo que se deseja liberar a leitura. Mas essa solução é muito verbosa, e como costumo dizer, se você deseja fazer algo desse tipo, melhor então usar Java.

O PHP possui o que no site está descrito como métodos mágicos. No caso para liberarmos a leitura de atributos privados de uma classe, utilizaríamos o método mágico __get. Esse método é chamado sempre que um atributo da classe é acessado. Veja abaixo como ficaria a implementação desse método de forma a liberar todos os atributos da classe:

class Pessoa {
    
    private $nome;
    private $idade;
    
    function Pessoa($nome,$idade) {
        $this->nome = $nome;
        $this->idade = $idade;
    }
    
    function __get($atributo) {
        echo "<br/>Leu atributo $atributo"; 
        return $this->$atributo;
    }
}

Repare que interessante a sintaxe do corpo do método __get. Eu retorno um atributo do objeto atual que contenha o nome enviado por parâmetro. Para verificarmos o funcionamento dele podemos testar com o seguinte código:

$eu = new Pessoa("Tiago",25);
echo "<br/>" . $eu->nome . " tem " . $eu->idade . " anos";
echo "<br/>Atributo nao existente: " . $eu->atributoNaoExistente;

A saída esperada é:

Leu atributo nome
Leu atributo idade
Tiago tem 25 anos
Leu atributo atributoNaoExistente
Atributo nao existente:

Mock de classe no PHPUnit executa o construtor

2008-04-01T13:36:00.008-03:00

O mock de classes no PHPUnit não funciona muito bem, o ideal, claro é mocar interfaces, mas quando isso não é possível é preciso estar ciente de que o construtor da classe mocada será executado e portanto o teste ficará um tanto falho.

É possivel identificar facilmente esse problema com o código abaixo. No caso mocarei a classe ClasseUtilizada para ser utilizada na classe ClasseASerTestada. Ao executar o teste é possível verifique que o echo dentro do construtor será executado erroneamente.

class ClasseUtilizada {   
    function ClasseUtilizada() {
        echo "\n[passou no construtor de ClasseUtilizada]\n";
    }
    public function fazAlgumaCoisa() {
        return "uhuuu";
    }
}
class ClasseASerTestada {
    function ClasseASerTestada($in) {
        echo "\n[" . $in->fazAlgumaCoisa() . "]\n";
    }
}
class MeuTeste extends PHPUnit_Framework_TestCase {
    /**
     * @Test
     */
    public function teste_com_classe() {
        $mock = $this->getMock("ClasseUtilizada");
        $mock->expects($this->once())
                 ->method('fazAlgumaCoisa')
                 ->will($this->returnValue(2));
        new ClasseASerTestada($mock);
    }
}

Uma forma de contornar isso é se aproveitar das características dinâmicas do PHP para simplesmente criar um Mock de uma classe que não existe. Mas pra isso é preciso informar no método getMock não só o nome de uma classe inexistente, como também a lista de métodos que a classe teria. Veja como ficaria abaixo:

    /**
     * @Test
     */
    public function teste_com_classe_inexistente_indicando_metodos() {
        $mock = $this->getMock("ClasseUtilizadaMock", Array('fazAlgumaCoisa'));
        $mock->expects($this->once())
             ->method('fazAlgumaCoisa')
             ->will($this->returnValue(4));
        new ClasseASerTestada($mock);
    }

Se por um acaso você não indicar o segundo parâmetro, que é um array com os métodos que a classe possui, um erro parecido com este será exibido: "Fatal error: Call to undefined method Mock_ClasseUtilizadaMock_4322e2fd :: fazAlgumaCoisa()".

O problema dessa solução é o caso em que a classe a ser utilizada possui verificação de tipo no recebimento dos parâmetros. Como a classe mock criada dinamicamente não é do tipo esperado, ocorrerá um erro. Veja um exemplo de como isso aconteceria abaixo:

class ClasseUtilizada {   
    function ClasseUtilizada() {
        echo "\n---->passou no construtor de ClasseUtilizada<-----\n";
    }
    public function fazAlgumaCoisa() {
        return "uhuuu";
    }
}
class ClasseASerTestadaComVerificacaoDeTipo {
    function ClasseASerTestada(ClasseUtilizada $in) {
        echo "\n[" . $in->fazAlgumaCoisa() . "]\n";
    }
}
class MeuTeste extends PHPUnit_Framework_TestCase {
    /**
     * @Test
     */
    public function teste_com_classe_inexistente_na_classe_com_verificacao_de_tipo() {
        $mock = $this->getMock("ClasseUtilizadaMock", Array('fazAlgumaCoisa'));
        $mock->expects($this->once())
            ->method('fazAlgumaCoisa')
            ->will($this->returnValue(5));
        new ClasseASerTestadaComVerificacaoDeTipo($mock);
    }
}

Nesse caso o erro exibido será "Argument 1 passed to ClasseASerTestadaComVerificacaoDeParametro :: ClasseASerTestadaComVerificacaoDeParametro() must be an instance of ClasseUtilizada"

Para esses casos não tem jeito, é preciso alterar as classes para que exista uma interface a ser mocada. Mas eu sugiro que não utilize a verificação de tipo nos parâmetros, caso contrário, seria melhor deixar de lado uma linguagem dinâmica como PHP e usar uma mais estática como Java.

GreaseMonkey para feed do InfoBlogs no GoogleReader

2008-03-19T23:41:00.007-03:00

Quem assina o feed do InfoBlogs deve ter o mesmo problema que eu. O link deste feed não é para o post em si, ele é para uma cópia do post na página do próprio InfoBlogs. Particularmente acho isso irritante, pois só costumo entrar no blog do autor quando o post é interessante e desejo comentá-lo. Nesse caso, preciso aguardar o carregamento (que é bem lento) da página do InfoBlogs para só depois poder clicar e ver o post original, onde eu posso comentar.

Para resolver esse problema implementei um script no GreaseMonkey para remontar a página do GoogleReader com os links corretos. Para quem não sabe o GreaseMonkey é uma extensão do Firefox, o melhor navegador existente na atualidade, que permite ao usuário configurar scripts para serem rodados ao término do carregamento de uma determinada página. Eu falei brevemente dele no post em que falo sobre as extensões do Firefox essenciais para um desenvolvedor web, e agora com este exemplo ficará mais fácil entender como ele funciona.

O código do script encontra-se abaixo. O que ele faz é verificar a cada 3 segundos se houve alguma alteração de estado no GoogleReader. Para então mudar os links caso haja necessidade. Só há uma ressalva, ele não funciona para o modo de visualização de lista, só a visão expandida. O motivo é que não gosto da visualização em lista e portanto não me interessei em testar nela :P

// ==UserScript==
// @name           GoogleReaderGM
// @namespace      http://www.google.com/reader
// @include        http://www.google.com/reader/*
// ==/UserScript==

function GoogleReaderGM() {}
GoogleReaderGM.prototype = {
      isChanged: function() {
              var e = document.getElementById("entries");
              var ds = e.getElementsByTagName("div");
              if( this._oldUrl != window.location.href ) {
                      this._oldUrl = window.location.href;
                      this._oldQtds = ds.length;
                      return true;
              }
              if( this._oldQtds != ds.length ) {
                      this._oldQtds = ds.length;
                      return true;
              }
              return false;
      },
      mudaLinksInfoBlogs: function() {
              if( this.isChanged() ) {
                      var e = document.getElementById("entries");
                      var as = e.getElementsByTagName("a");
                      for( i=0; i<as.length; i++ ) {
                              var a = as[i];
                              if( a.className=="entry-title-link" && a.href.indexOf("www.infoblogs.com.br/view.action")!=-1 ) {
                                      a.href = a.href.replace("view","redir/go");
                              }
                      }
              }
      }
}

var gr = new GoogleReaderGM();

setInterval(function() { gr.mudaLinksInfoBlogs(); }, 3000);

Como pode ser visto eu defino como um comentário JavaScript em quais páginas esse script será executado. No caso, todas aquelas abaixo de http://www.google.com/reader.

O interessante é que se você quiser pode utilizar esse código como template para executar outras funcionalidades no GoogleReader. Basta adicionar mais alguma função, e utilizando isChanged você fica sabendo se alguma entrada nova apareceu na área que exibe as entradas dos feeds. Isso é claro se você utilizar a visão expandida (Expanded view), pois o método isChanged só foi feito pra ela.

Escapando textos em funções de javascript executadas em links

2008-03-13T11:18:00.008-03:00

Para determinar a execução de uma função javascript no clique de um link temos duas possibilidades. Ou utilizamos o próprio atributo href da tag a com o protocolo javascript: ou adicionamos o atributo onclick fazendo a chamada à função.

Contudo o comportamento de ambos não é totalmente igual. Principalmente quando chamamos funções que passam como argumento algum texto escapado com a função escape. Normalmente usa-se esse escape para evitar error de javascript devido ao uso de aspas simples e duplas nos textos.

Veja abaixo dois exemplos de cógigo com o erro por não usar escape. O primeiro com aspas simples, que faz com que o javascript ache que o texto terminou antes do que deveria e o segundo com aspas duplas fazendo o navegador acreditar que o atributo terminou:

var textoComAspaSimples = "Quero um copo d'água";
var s = '<a href="javascript:alert(\'' + textoComAspaSimples+ '\')">Clique aqui</a>';
document.writeln(s);

var textoComAspaDupla = 'Você está com "sede"?';
var s = '<a href="javascript:void(0)" onclick="alert(\'' + textoComAspaDupla+ '\')">Clique aqui</a>';
document.writeln(s);

Para evitar esses erros uma boa idéia é utilizar a função escape. No entanto isso não funciona direito por href. Neste atributo o navegador interpreta o código escapado causando o mesmo erro. Isso pode ser observado no exemplo a seguir, no primeiro link gerado o erro acontece, no segundo não:

var textoComAspaSimples = "Quero um copo d'água";
var s = '<a href="javascript:alert(\'' + escape(textoComAspaSimples) + '\')">Clique aqui href</a><br/>';
s += '<a href="javascript:void(0)" onclick="alert(\'' + escape(textoComAspaSimples) + '\')">Clique aqui onclick</a>';
document.writeln(s);

O problema é que com essa solução a função que recebe este parâmetro precisa executar uma transformação reversa utilizando a função unescape. Caso contrário veremos algo parecido com o que o segundo link do exemplo acima mostra: Quero%20um%20copo%20d%27%C3%A1gua.

Implementando a transformação reversa na função que recebe teríamos algo como o mostrado abaixo. Uma nova função que recebe o parâmetro escapado e o transforma para utilizá-lo:

function escapedAlert(s) {
 alert( unescape(s) );
}
var textoTodoErrado = "Sentes \"sede\"?\nQuero um copo d'água";
var s = '<a href="javascript:void(0)" onclick="escapedAlert(\'' + escape(textoTodoErrado) + '\')">Clique aqui onclick</a>';
document.writeln(s);

Mas isso ainda não é o ideal pois continuaríamos sem poder utilizar a função dentro do atributo href, e além disso precisaríamos sempre preparar as funções para receber parâmetros escapados. Uma outra alternativa é criar nossa própria função de escape. Como é mostrado no exemplo abaixo:

function escapeForLink(s) {
 if(s) {
  var r = s.split("\n").join("\\n");
  r = r.split("\r").join("\\r");
  r = r.split("'").join("\\u0027");
  r = r.split('"').join("\\u0022");
  return r;
 }
 return s;
}
var textoTodoErrado = "Sentes \"sede\"?\nQuero um copo d'água";
var s = '<a href="javascript:alert(\'' + escapeForLink(textoTodoErrado) + '\')">Clique aqui href</a><br/>';
s += '<a href="javascript:void(0)" onclick="alert(\'' + escapeForLink(textoTodoErrado) + '\')">Clique aqui onclick</a>';
document.writeln(s);

Com essa função os problemas de escape para passagem de parâmetro de texto em funções executadas apartir de links fica resolvido.

Component do VRaptor só pode ter um construtor público

2008-02-27T23:25:00.000-03:00

Nem tudo são flores com o framework MVC VRaptor. Uma classe anotada com Component só pode ter um construtor público. Senão o seguinte erro é exibido na inicialização do container web:

org.vraptor.config.ConfigException: cannot load classes
...
Caused by: org.vraptor.component.InvalidComponentException: 
com.globo.ekzameno.vraptor.QuestionarioLogic component has 2 accessible constructors. 
This is not desirable as it may reflect optional arguments and create complex attributes.

Ok, ok, isso não é o fim do mundo para o VRaptor, mas me atrapalhou um pouco com os testes unitários, pois eu pretendia fazer injeção de dependência por construtor. Como esse framework não me permite isso, terei que fazer por método set. Ou seja, ao invés de fazer assim:

public TiagoLogic() {
 this(new RepositorioImpl());
}
public TiagoLogic(Repositorio repositorio) {
 this.repositorio = repositorio;
}

Terei que fazer assim:

public TiagoLogic() {
 setRepositorio(new RepositorioImpl());
}
public void setRepositorio(Repositorio repositorio) {
 this.repositorio = repositorio;
}

Não é um grande problema, só questão de preferência mesmo. Prefiro por construtor.

NoClassDefFoundError de Expectations no VRaptor 2

2008-02-27T22:22:00.004-03:00

Atenção, não consegui mais replicar o problema descrito neste post. Provavelmente a necessidade da classe não era do VRaptor.

Comecei a utilizar o VRaptor em um projeto pessoal e na primeira tentativa obtive um erro que foi simples corrigir, mas que achei pertinente postar aqui porque não encontrei no google ninguém com o mesmo problema e porque a documentação deste framework não informava nada sobre.

O erro que obtive foi o seguinte:

javax.servlet.ServletException: Servlet.init() for servlet vraptor2 threw exception

Cuja causa foi:

java.lang.NoClassDefFoundError: org/jmock/Expectations

Para resolver isso bastou incluir no classpath da aplicação o jar do JMock. Esse jar não é incluso no blank-project oferecido no site do VRaptor, por isso acho que outras pessoas poderão passar pelo mesmo problema.

Problema do gets com uso de parametros na linha de comando em ruby

2008-02-26T14:47:00.005-03:00

Brincando um pouco com ruby me deparei com um problema que parecia um pouco exotérico. Utilizando a função gets num script que recebe parâmetros por linha de comando, o seguinte erro era exibido:

tiago@tiago-laptop:~/Projetos/testeRuby$ ruby Pessoa.rb Tiago
Pessoa.rb:14:in `gets': No such file or directory - Tiago (Errno::ENOENT)

Esse mesmo erro não ocorria quando não era enviado nenhum argumento na linha de comando. Pesquisando sobre o assunto no Google, encontrei uma discussão que clareou minhas idéias. O Ruby herda o comportamento da função gets do Perl, ou seja, se houver um parâmetro na linha de comando, essa função assume que este parâmetro é o path de um arquivo e portanto tenta abrí-lo.

Para resolver essa questão basta deixar claro que se deseja que a função gets recupere apenas o texto digitado. Na verdade ao invés de usarmos gets puro devemos usar o do STDIN da seguinte maneira STDIN.gets.

Tela cheia em flash no Globo Vídeos Player

2008-01-30T04:55:00.000-03:00

Subiu agora pouco uma nova versão do Globo Vídeos contendo diversas melhorias e algumas correções pontuais. A maioria dessas alterações poucos irão perceber, pois são problemas que somente o controle de qualidade interno tem a paciência de procurar. Mais uma das melhorias sem duvida será muito bem notada, o botão de tela cheia.

Na versão anterior, que usava Windows Media Player, a funcionalidade de tela cheia existia para os usuários de Internet Explorer. Quando entrou o player em flash ela foi removida. Portanto muitos usuários reclamaram de sua remoção.

Acontece que fazer o full screen no flash não é uma tarefa trivial devido as diversas versões de flash que teríamos que suportar. Assim preferimos implementar uma versão mínima do player antes do Big Brother, para posteriormente implementar essas pequenas melhorias. Se tivessemos optado por lançar já com um player completo, talvez só pudéssemos entregá-lo ao final do Big Brother.

Eu particularmente acredito que tomamos a decisão correta. Apesar de termos perdido por um mês a funcionalidade de tela cheia, milhares de usuários que não conseguiam ver vídeos, por causa da M que é o Windows Media Player, agora conseguem. E melhor ainda, agora também têm o botãozinho de tela cheia.

Repassando parâmetros rest para funções que esperam parâmetros rest

2008-01-14T20:45:00.000-03:00

No ActionScript 3 existe um parâmetro especial, comumente chamando de parâmetro rest, que permite que uma função receba "infinitos" parâmetros. O Java, apartir da versão 5, também possui essa facilidade, que é chamada de varargs. Veja abaixo o exemplo de uma função e o logo abaixo o uso dela:

//Funcao que mostra todos os parametros
public function mostra(... numeros) {
    if( numeros && numeros.length > 0 ) {
        for each( var i in numeros ) {
            trace(i);
        }
    }
}
//Uso da funcao:
mostra(1);
mostra(1,2,3);
mostra(1,2,3,5,8);

Apesar de ser um recurso muito bom, a forma como ela foi implementada no ActionScript nos traz um problema no momento em que precisamos repassar esses parâmetros para uma outra função que também receba parâmetros opcionais rest.

Isso acontece porque quando a primeira função é chamada, ela é informada com os parâmetros separados por vírgula, mas ela os recebe como um array. Então se você enviar este array para o segundo método, ele será considerado apenas um parâmetro. No Java há um tratamento mais esperto, de forma que quando enviado um array o compilador não permite que mais nenhum parâmetro seja colocado na chamada à função.

Para ilustrar melhor vamos pensar num cenário que mostrei no post passado sobre como testar funções que executem javascript. No caso era uma função proxy para isolarmos a execução de ExternalInterface.call:

public function executarJavaScript(funcao:String, ... parametros) {
    try {
        return ExternalInterface.call(funcao,parametros);
    } catch(erro:Error) {
        return null;
    }
}

No caso, a função call de ExternalInterface também espera receber parâmetros opcionais, mas como estamos mandando um array, ele achará que estamos mandando apenas dois parâmetros, um com o nome da função javascript e outro com um array. No Google é fácil encontrar uma solução POG e muito feia para isso. Nada mais é que uma cadeia megazord de ifs:

public function executarJavaScript(funcao:String, ... p) {
    try {
        if( p.length == 0 ) return ExternalInterface.call(funcao,null);
        else if( p.length == 1 ) return ExternalInterface.call(funcao,p[0]);
        else if( p.length == 2 ) return ExternalInterface.call(funcao,p[0],p[1]);
        else if( p.length == 3 ) return ExternalInterface.call(funcao,p[0],p[1],p[2]);
        else if( p.length == 4 ) return ExternalInterface.call(funcao,p[0],p[1],p[2],p[3]);
    } catch(erro:Error) {
        return null;
    }
}

Ô coisa feia!

A solução mais elegante para esse problema é utilizar os recurso de reflexão do ActionScript. Ou seja, vamos utilizar o método apply da classe Function, que aguarda os parâmetros como um array, exatamente como recebemos na função ao utilizar um parâmetro rest. Veja como ficaria:

public function executarJavaScript(funcao:String, ... parametros) {
    try {
        var f:Function = ExternalInterface.call;
        var parametrosEnviar:Array = new Array(funcao);
        parametrosEnviar = parametrosEnviar.concat(parametros);
        return f.apply(null,parametrosEnviar);
    } catch(erro:Error) {
        return null;
    }
}

No caso, concatenamos num array de parâmetros a serem enviados a função e os parâmetros rest. Ao enviá-los pela função apply eles são enviados como se fossem diversos parâmetros separados por vírgula e o método call os recebe corretamente como parâmetros rest.

Como testar funções que fazem chamadas javascript no actionscript?

2008-01-13T18:47:00.000-03:00

No ActionScript é possível chamar funções javascript utilizando a função ExternalInterface.call. O problema é que essa função é estática, dificultando muito a criação de testes unitários para as funções que necessitam acessar esses recursos externos.

Para fazer isso é preciso isolar a chamada ao javascript em uma função, e no teste unitário substituir essa função por uma outra que apenas a substitua por uma comportamento esperado de acordo com o teste. Vamos ver como fazer isso:

Primeiro isolamos a chamada a ExternalInterface.call em um função que serviria apenas como proxy. Em linguagens menos dinâmicas precisaríamos isolar essa função em uma outra classe pois não seria possível substitui-la posteriormente:

public function executarJavaScript(funcao:String,parametros:Object = null) {
    try {
        return ExternalInterface.call(funcao,parametros);
    } catch(erro:Error) {
        return null;
    }
}

A classe então que possui essa função precisa ser dinâmica, ou seja deve ter um modificador dynamic, e possuir um atributo da classe Function que recebe no construtor essa função que foi criada:

dynamic public class MinhaClasse {
    public var js:Function;
    function MinhaClasse() {
        js = executarJavaScript;
    }
    public function executarJavaScript(funcao:String,parametros:Object = null) {
        //Conteudo da função já exibido acima :P
    }
    //Outras funções
}

As demais funções da classe deverão usar então o atributo js como uma função para executar o recurso externo desejado. Veja um exemplo que recupera do javascript a URL onde o swf está sendo exibido:

public function obterUrlAtual():String {
    try {
        var objJs = js("document.location.href.toString");
        if( !objJs ) objJs = js("document.location.toString");
        if( !objJs ) return null;
        return new String(objJs);
    } catch(e:Error) {
        return null;
    }
}

Para criar um teste unitário com o ASUnit para esta função de exemplo basta configurar de diversas formas o atributo js da classe MinhaClasse de acordo com o comportamento que você deseja testar. Um exemplo é exibido abaixo:

public function testSegundFuncaoJavaScriptEhChamada():void {
    var m:MinhaClasse = new MinhaClasse();
    m.js = function(funcao:String,parametros:Object = null) {
        if(funcao=="document.location.toString") {
            return "http://programandosemcafeina.blogspot.com";
        } else {
            return null;
        }
    }
    var s:String = m.obterUrlAtual();
    assertEquals("Quando a primeira função retorna null a segunda função deve ser chamada","http://programandosemcafeina.blogspot.com",s);
}

Checar versão do flash de dentro do SWF

2008-01-07T14:29:00.001-03:00

Descobrir a versão do flash por javascript é moleza. Uma rápida busca no google lhe traz dezenas de script prontos pra usar. Mas verificar a versão do flash de dentro do SWF foi díficil de encontrar. Até é bem simples. Basta usar o atributo estático version da classe flash.system.Capabilities. Assim:

trace("versao: " + Capabilities.version);

Simples, porém foi díficil encontrar. Como esse código só funciona no Action Script 3, fica parecendo que ele não tem muita utilidade. Mas acontece que existem pequenas diferenças entre as chamadas minor revisions que precisam ser verificadas no projeto em que estou trabalhando.

Redirecionar requisições do Apache para uma imagem

2008-01-02T18:16:00.001-03:00

Para redirecionar todas as requisições do apache para uma determinada imagem basta utilizar o módulo mod_rewrite.
Se você ainda não utiliza este módulo do apache, é preciso descomentar no arquivo httpd.conf o carregamento dele:

LoadModule rewrite_module modules/mod_rewrite.so

Em seguida deve-se ativar o módulo e criar uma regra, também alterando o mesmo arquivo:

RewriteEngine On
RewriteRule   /*  /empty.gif

Neste caso o comando RewriteRule informa que todas as requisições devem ser atendidas pelo recurso /empty.gif.

Problema com as bordas das janelas usando o Beryl

2007-12-28T01:24:00.000-03:00

Esse sim foi um sufoco. O Beryl não queria funcionar de jeito nenhum no meu Ubuntu. Diversos probleminhas foram faceis após simples pesquisas no google. Mas o problema maior não tinha resposta alguma. Quando o beryl estava rodando as bordas das janelas não apareciam de jeito algum.

A mensagem de erro do Beryl que me fez acordar para a razão do problema foi a seguinte:

beryl: decoration: property ignored because version is 20070319 and decoration plugin version is 20061011

Percebi que devia haver alguma incompatibilidade entre a versão do beryl e a do emerald ou coisa parecida. E realmente havia. O jeito foi achar uma denominador comum entre a versão do emerald, beryl e demais libs. Para fazer isso precisei fazer um downgrade da parada toda:

sudo apt-get install beryl=0.1.9999.2~0beryl1 
beryl-core=0.1.9999.2~0beryl1 
beryl-manager=0.1.9999.2~0beryl1 
beryl-plugins-data=0.1.9999.2~0beryl1 
beryl-settings=0.1.9999.2~0beryl1 
beryl-settings-bindings=0.1.9999.2~0beryl1 
emerald=0.1.9999.2~0beryl1  
libberyldecoration0=0.1.9999.2~0beryl1  
libberylsettings0=0.1.9999.2~0beryl1  
libemeraldengine0=0.1.9999.2~0beryl1 
emerald-themes=0.1.9999.2~0beryl1  -V

O engraçado é que ontem de madrugada, depois que fiz o downgrade, não funcionou. Mas isso porque eu tinha configurado meu Beryl Manager para utilizar o Window Manager do Compiz, pois este funcionava bem. Contudo, com essa versão mais antiga do beryl, o Compiz parou de funcionar. Mas isso não tentarei consertar, ninguém precisa desse Compiz. Bastou então setar no Beryl Manager o Beryl como Windows Manager para tudo funcionar.

Olha a foto de como ficou meu cubo :)

Cada dia que passa me convenço mais da facilidade do Windows. Mas até que é divertido brincar com esse Ubuntu.

Globo Vídeos agora em Flash!

2007-12-19T04:55:00.000-03:00

É com muito orgulho que anuncio que finalmente o Globo Vídeos entrou na era do Flash Vídeo. Os vídeos ao vivo, como da Globo News e as cameras do BBB continuarão em Windows Media Player, mas apartir de hoje a grande maioria dos vídeos on demand e íntegras ficarão disponíveis em flash.

Veja alguns exemplos:
Dominó é mania nacional em Cuba
Romulo e Reno: Lenda ou Realidade?
Festival de gelo na Bélgica

Como obter a largura e a altura de Divs liquidos

2007-12-18T15:58:00.000-03:00

Obter os atributos width e height de Divs absolutos é muito simples. A coisa começa a ficar complicada quando seu Div não possui uma altura e uma largura fixa, se comportando de acordo com o restante da página. Encontrei em alguns blogs diversas dicas de como fazer isso. Alguns só funcionavam no Firefox, outros só no Internet Explorer, nenhum em ambos.

Com essas informações então criei as funções getWidth e getHeight que retornam a largura e altura de um div, mesmo que está seja fluída:

function getHeight(d) {
    if( document.all ) {
        return eval( "document.all." + d.id + ".offsetHeight" );
    } else {
        return parseInt( getStyle(d,"height") );
    }
}

function getWidth(d) {
    if( document.all ) {
        return eval( "document.all." + d.id + ".offsetWidth" );
    } else {
        return parseInt( getStyle(d,"width") );
    }
}

function getStyle(el, style) {
    if(!document.getElementById) return;
    if( window.getComputedStyle ) {
        value = document.defaultView.getComputedStyle(el, "").getPropertyValue(style);
    } else if(document.defaultView) {
        value = document.defaultView.getComputedStyle(el, "").getPropertyValue(style);
    } else if(el.currentStyle) {
        value = el.currentStyle[style];
    }
    return value;
}

Para usá-las é só chamar enviando por parâmetro um objeto div. Veja o exemplo:

var d = document.getElementById("meuDiv");
alert( getWidth( d ) );
alert( getHeight( d ) );

Testei essas funções com o Firefox 2, IE 7 e o Safari 3.

Como utilizar uma versão nova do Rhino no Weblogic 8

2007-09-06T17:36:00.000-03:00

Em recente post mostrei a vocês como descobri que o weblogic.jar contém as classes do Rhino numa versão antiga. Agora vou mostrar porque tentava descobrir isso e como resolvi a situação.

Tudo começou quando ao subir nossa aplicação, que utiliza o js.jar do Rhino, para o weblogic, começamos a obter a seguinte exceção.

java.lang.NoSuchMethodError: org.mozilla.javascript.Context.initStandardObjects()Lorg/mozilla/javascript/ScriptableObject;

Logo descobri a referida bizarrice do weblogic.jar. Começou então o nosso desafio: Como fazer a nossa aplicação utilizar as classes do Rhino contidas no js.jar que levávamos no WEB-INF/lib e não os do weblogic.jar?

O Phillip Calçado, líder de nossa equipe, me deu uma ótima sugestão. Criar um Class Loader para carregar as classes do jar contido em nossa aplicação. Para fazer isso, extendi a classe URLClassLoader e implementei o método loadClass(String). Veja como ficou o código:

public class RhinoClassLoader extends URLClassLoader {
    private static final String PREFIXO_JAVASCRIPT = "org.mozilla.javascript.";
    private static final String PREFIXO_CLASSFILE = "org.mozilla.classfile.";
 
    private Map classesCarregadas;

    public RhinoClassLoader(URL url) {
        super(new URL[]{ url }, RhinoClassLoader.class.getClassLoader() );
        classesCarregadas = new HashMap();
    }

    public Class loadClass(String name) throws ClassNotFoundException {
        if( name!=null && ( name.indexOf(PREFIXO_JAVASCRIPT)!=-1 || name.indexOf(PREFIXO_CLASSFILE)!=-1 ) ) {
            Object classeCarregada = classesCarregadas.get(name);
            if( classeCarregada != null ) {
                return (Class) classeCarregada;
            }

            Class classe = findClass(name);
            classesCarregadas.put(name, classe);

            return classe;
        }
        return super.loadClass(name);
 }
}

Observe que o construtor recebe uma url, que deve ser o caminho pro arquivo jar do Rhino e a repassa para o contrutor da superclasse. Já no método loadClass nós passamos a carregar somente as classes do Rhino através do método findClass da superclasse URLClassLoader. Este procurará essas classes no jar que informamos. Para as demais classes nós repassamos a chamada para o método loadClass default. Ou seja, somente as classes do Rhino estarão com o ClassLoader diferente.

Outra coisa importante do código é o cache de classes anteriormente carregadas. Ele é extremamente necessário, senão pode ocorrer um erro indicando que duas classes com o mesmo nome foram carregadas.

Para obter então a classe correta do Rhino, basta utilizar o método forName da classe Class para recebê-la. Veja abaixo como ficaria:

URL url = new URL( "file:///path/para/o/WEB-INF/lib/js.jar" );
RhinoClassLoader loader = new RhinoClassLoader( url );
Class classeContext = Class.forName("org.mozilla.javascript.Context",true,loader);

Utilizando o objeto classeContext que representa a classe desejada, você pode então criar novas instancias utilizando a api de reflexão do Java. Mas tome cuidado para não causar um ClassCastException. Isso porque a classe representada em classeContext é diferente da classe de mesmo nome que você faria o cast, pois são de ClassLoaders diferentes. Logo, o seguinte cógido causaria a exceção:

Context contexto = (Context)classeContext.newInstance();

Ou seja, você só pode utilizar classes de outro ClassLoader via api de relection. Um exemplo de como seria utilizar um método de Context nesse caso é mostrado a seguir:

Object contexto = (Object)classeContext.newInstance();
Method metodoDebug = classeContext.getMethod("isGeneratingDebug",null);
Boolean gerandoDebug = (Boolean) metodoDebug.invoke( contexto, null );

Repare que no retorno da invocação do método refletido eu faço um cast. Neste caso eu posso, pois somente as classes dos pacotes org.mozilla.javascript e org.mozilla.classfile foram carregadas com outro ClassLoader.

Esse trabalho todo porque o weblogic não sabe brincar. Custava colocar o jar do Rhino separadinho? Tem certas coisas que não dá pra entender. Já falei isso antes, mas repetir nunca é demais. Cada dia que passa mais odeio o weblogic.

Script bash para encontrar classes em um diretório de jars

2007-09-03T20:17:00.001-03:00

Scripts bash é uma das ferramentas mais uteis para desenvolvedores. Hoje por exemplo, para enfrentar um problema de classe duplicada no classpath da aplicação, fiz um rápido script para identificar todas as classes que seguem determinado padrão em um determinado diretório de jars. No caso, no WEB-INF/lib. Segue o script:

for i in $( ls | grep jar )
do
   echo "$i:"
   jar -tvf $i | grep "javascript.Context"
done;

No caso, estava procurando pela classe Context do Rhino, que logo descobri estava mesmo duplicada. Não no WEB-INF/lib da minha aplicação, mas dentro do weblogic.jar. Sim, por incrível que pareça o weblogic empacotou o Rhino inteiro em seu jar, com caminho de pacote e tudo, e ainda por cima numa versão bem antiga. Cada dia que passa mais odeio o weblogic.

JspException: Non-matching extension tags

2007-09-02T21:06:00.000-03:00

Essa semana obtive a referida mensagem de erro ao colocar uma aplicação testada no tomcat para rodar no weblogic. A mensagem era mais ou menos a seguinte:

weblogic.servlet.jsp.JspException: (line 60): Non-matching extension tags //[ null; Line: 60]

Percebi que o erro ocorria na chamada a uma tag customizada de meu sistema que recebia em um atributo um parâmetro da requisição. O código era mais ou menos como o mostrado a seguir:

<minha:tagCustomizada nomeAtributo="<%=request.getParameter("valorFornecido")%>"/>

Ao pesquisar no google sobre o assunto, encontrei outras pessoas com o mesmo problema e uma sugestão para resolução dele. Trocar as aspas duplas por aspas simples no valor do atributo. Isso funcionou:

<minha:tagCustomizada nomeAtributo='<%=request.getParameter("valorFornecido")%>'/>

Parece até aceitável que o erro ocorra, pois pensando no padrão XML, a abertura do valor de atributos terminaria na próxima aspas dupla. Contudo, o JSP em questão não é um documento XML, de forma que teoricamente os scriptlets deveriam ser executados antes das tags customizadas. Tanto que no Tomcat não houve qualquer problema. Ao que tudo indica isso é um bug do Weblogic.

Selenium IDE aplicado a interfaces com Ajax

2007-08-22T19:44:00.001-03:00

Fazer testes automatizados com o Selenium IDE numa interface web que possui chamadas assíncronas pode se tornar um problemão. Um exemplo simples é de um link que buscaria através de HttpRequest um recurso no servidor:


<a href="javascript:void(buscarDados())">Clique aqui</a>

Neste caso para testar o clique no link usando o selenium temos dois problemas. Se usarmos a função click o teste seguinte poderá falhar caso o servidor demore alguns segundos para responder. E se usarmos a função clickAndWait ocorrerá um timeout pois o selenium espera que a página inteira mude.

Para resolver esse tipo de situação é que existem as funções iniciadas por wait. Elas aguardam um bom período até que determinado elemento ou texto sejam impressos na página. Dessa forma podemos utilizar a função click e posteriormente fazer aguardar por determinado recurso, o que indicaria que o servidor respondeu.

No caso do nosso exemplo a função de callback do ajax, ao receber os dados do servidor imprime uma tag H1 do html com o texto "Dados do servidor". Dessa forma o teste ficaria na seguinte ordem:

open	/teste.html
click	link=Clique aqui
waitForElementPresent	//h1
verifyText	//h1	Dados do servidor

Repare que após o clique no link, utilizamos a função waitForElementPresent para aguardar que o html tenha inserido uma tag h1 em qualquer parte dele. Depois que este é impresso eu utilizo a função verifyText para verificar se há alguma tag h1 inserida no html que possua o texto "Dados do servidor".

A versão do Selenium IDE utilizada é 0.8.7 e a versão do Firefox 2.0.0.1

O atributo length de objetos e arrays em javascript

2007-08-17T00:46:00.001-03:00

Eu não resisti e usei Javascript essa ultima semana inteira - É a minha confissão de hoje na reunião de javascriptólatras anônimos - Passei um perrengue danado por causa de suas peculiaridades. Tudo causado por falta de atenção a uma das pequenas regrinhas que essa linguagem viciante tem. Para evitar que outros passem pelo mesmo problema, compartilho aqui minha dor.

Em primeiro lugar é preciso verificar que somente arrays têm o atributo length. Em segundo que arrays podem se comportar como objetos, e objetos podem se comportar como arrays, e que arrays são objetos. Entendeu? Bom, vamos aos exemplos pra ficar mais claro.

 var eu = { nome:"Tiago",idade:25 }; //Criando um objeto dinâmico com {}
 alert( eu["nome"] ) //Acessando como se fosse um mapa
 alert( eu.idade ) //Acessando como um atributo
 eu.sexo = "Sempre"; //Criando um novo atributo
 alert( eu["sexo"] ); 
 eu["altura"] = 1.75; //Criando um novo atributo como mapa
 alert( eu.altura );

No exemplo acima eu crio um objeto dinamicamente utilizando chaves além de acessar e criar novos atributos, de duas formas possíveis: Como se fosse um mapa, utilizando o operado colchetes, e da maneira mais comum, que é utilizando o operador ponto. Vamos seguir então para o próximo exemplo:

 var eu = []; //Criando um array com []
 eu.nome = "Tiago"; //Setando atributo em um array? Que coisa estranha
 eu["idade"] = 25 //Não era um array, por que está aceitando uma chave como se fosse um mapa?
 alert( eu["nome"] ) //Acessando como se fosse um mapa
 alert( eu.idade ) //Acessando como um atributo
 eu.sexo = "Sempre"; //Criando um novo atributo
 alert( eu["sexo"] ); 
 eu["altura"] = 1.75; //Criando um novo atributo como mapa
 alert( eu.altura );

Neste exemplo criamos um array ao invés de um objeto, e qual não é nossa surpresa ao perceber que, exceto pela incialização, o comportamento dele fica exatamente igual ao de um objeto. Isso ocorre porque um array é um objeto. Até aí tudo parece maravilhoso. A coisa desanta quando você resolve usar o comportamento de array, num array tratado como objeto. Vejamos:

 var eu = []; 
 alert(eu.length); //Tamanho 0 oras, não coloquei nada aqui ainda
 eu["nome"] = "Tiago"; //Inserindo um atributo
 alert(eu.length); //Tamanho 0?? E o atributo que botei?
 eu.idade = 25; //Inserindo outro atributo
 alert(eu.length); //Tamanho 0 de novo????
 eu[0] = "primeiro indice"; //Adicionando elementos ao array
 eu[1] = "segundo indice"; 
 alert(eu.length); //Ahhh agora sim
 eu.push("terceiro indice");
 eu.push("quarto indice");
 alert(eu.length); //Ahhh agora sim de novo

No exemplo acima podemos perceber o quão confuso começa a ficar. Basicamente o atributo length passa a só funcionar quando inserimos elementos no array. Ou seja, os atributos inseridos no array ficam fora do array. Isso fica mais evidente fazendo as iterações como as do exemplo abaixo:

 //agora vamos iterar só pelos elementos do array
 for(i=0; i {
     alert("elemento do array: " + eu[i]); 
 }
 //agora vamos iterar sobre tudo que tiver aí
 for(i in eu)
 {
     alert("atributo do objeto: " + eu[i]); 
 }
 //De novo somente elementos do array
 while(eu.length>0)
 {
     alert("Remove elemento: " + eu.pop());
 }

Na primeira eu itero sobre números, logo somente sobre os elementos do array. No segundo eu itero sobre as chaves, sejam elas numéricas, sejam de texto. E finalmente no terceiro eu itero removendo os elementos do array. Mas ainda sim podem ocorrer algumas curiosidades que podem nos confundir, veja abaixo:

 var eu = []; 
 eu[0] = "primeiro indice"; 
 eu[1] = "segundo indice"; 
 eu["1"] = "substitui segundo indice"; //Isso aqui é o mesmo que eu[1]
 alert(eu[1]);  //Vai alertar a mesma coisa que o alerta de baixo
 alert(eu["1"]); 
 eu["length"] = 0; //Vou sacanear o array agora
 alert(eu.length); //Zerei o tamanho
 alert(eu[4]); //Ih!!! Apagou tudo

Perceba que adicionar um elemento ao indice 1 como número é o mesmo que adicionar ao 1 como string. Além disso, veja que podemos alterar o valor do tamanho, atributo length, do array somente atribuindo um valor a ele. Isso pode causar grandes problemas, ainda mais se você estiver guardando dados digitados pelo usuário como se o array fosse um mapa.

Um exemplo simples é um usuário preenchendo um formulário com campo de nome e valor, ao clicar em um botão esses dados são inseridos no array como se fosse um mapa. Digamos que ele preencha da seguinte maneira:

Nome     | Valor: 
---------------------
"país"   | "brasil"
10       | "isso"
7        | "hoje"
"olha"   | "caso"
"length" | 0

Neste caso quando ele digitar o nome 10, o array passará a ter 10 posições, mas no momento que ele digitar "length" com o valor 0, os dados que ele inseriu com nome 10 e 7 desaparecerão. Para debugar isso você terá que arrancar vários tufos de seu cabelo.

E é aí finalmente que chegamos ao ponto crucial. Para evitar esse tipo de problema o ideal é deixar bem separado o que é array, inicializando com [] e o que é objeto inicializando com {}. Isso porque para objetos, um atributo com nome length não tem poder algum, exceto se você implementá-lo para que tenha.

Cuidado com SubReports aninhados

2007-06-19T22:35:00.000-03:00

Com JasperReport é bom prestar atenção no uso de SubReports aninhados. O problema é com os parâmetros, pois o parâmetro de um relatório não persiste em seus SubReports. Parece pouca coisa, mas tive uma péssima experiência com isso.

Um projeto em que estou trabalhando possui um relatório com um SubReport, e este SubReport possui inclui um outro SubReport. Para achar os arquivos jaspers dos SubReports utilizamos o default de concatenação do parâmetro ${SUB_DIRECTORY}. Acontece que ao definirmos na aplicação este parâmetro, o SubReport não recebe esta definição, de forma que ele acaba utilizando o default na inclusão de seu SubReport. Resultado: Funciona no ambiente de desenvolvimento, mas no ambiente de distribuição o bug acontece.

Para resolver isso é preciso repassar o valor do parâmetro ${SUB_DIRECTORY} para os demais SubReports. Para fazer isso no IReport aperte com botão direito no local de inclusão do SubReport e aperte em properties. Na aba em que se configura o path do SubReport, logo abaixo deste campo existe uma caixa onde se pode definir os valores que devem ser repassados por parâmetro.

Classes de auxílio no uso de JasperReport e IReport

2007-06-13T18:22:00.001-03:00

Popular um relatório jasper com uma coleção de beans é simples, o incoveniente é quando se deseja popular com uma coleção de beans que possuem instancias de outros beans como atributo. Para resolver essa sitação, criei dois DataSources do Jasper implementando algo parecido com a EL (Expression language) de forma a navegar seus atributos. São as classes ObjetoDataSource e ColecaoDataSource.

Veja como essas classes funcionam:
- Como funciona a classe ObjetoDataSource para JasperReport
- Como funciona a classe ColecaoDataSource para JasperReport

Se você gostou, pode baixar o projeto timotta-api clicando aqui.

Classe ObjetoDataSource para JasperReport

2007-06-13T18:21:00.001-03:00

Com a classe ObjetoDataSource é possível acessar os atributos de qualquer objeto. Basta colocar os campos separados por ponto. Essa classe faz parte do pacote de auxílio no uso de JasperReport e IReport. Mostro abaixo um exemplo simples. Primeiro vejamos as classes de dominio.

public class Pessoa
{
 String nome;
 Date nascimento;
 Endereco endereco;
 List<String> telefones;
 // ... Gets e Sets omitidos ...
}
public class Endereco
{
 String rua;
 short numero;
 // ... Gets e Sets omitidos ...
}

Agora digamos que a gente possui uma intância da classe Pessoa e desejamos imprimir todos seus campos em um relatório Jasper. Para fazer isso basta instanciar um novo ObjetoDataSource, como mostrado abaixo:

Pessoa eu = loadPessoa();
ObjetoDataSource dataSource = new ObjetoDataSource(eu);
JasperReport compilado = JasperCompileManager.compileReport("/tmp/Relatorio.xml");
JasperPrint preenchido = JasperFillManager.fillReport(compilado, new HashMap(), dataSource);
JasperViewer.viewReport(preenchido);

No seu relatorio, para acessar os campos da Pessoa, basta declarar os campos da seguinte forma:

<field name="nome" class="java.lang.String" />
<field name="nascimento" class="java.util.Date" /> 
<field name="telefones" class="java.lang.Object" />
<field name="endereco.rua" class="java.lang.String" />
<field name="endereco.numero" class="java.lang.Short" />

Repare que o campo telefones é declarado como Object, porque a resposta dele não é um List, e sim um ColecaoDataSource. Isso é feito para que se você possa iterar nele utilizando um SubReport.

Neste exemplo, o relatório possuiria apenas uma pessoa, no caso de termos que exibir várias pessoas utiliza-se o ColecaoDataSource. Ou poderiamos ter uma classe, por exemplo, Equipe que possui um atributo do tipo List. Com essas classes as possibilidades são infinitas.

Classe ColecaoDataSource para JasperReport

2007-06-13T18:19:00.000-03:00

Com a classe ColecaoDataSource é possível iterar e acessar os atributos dos objetos presentes em uma coleção. Funciona da mesma forma que a ObjetoDataSource, com a diferença de que por ser uma coleção, permite iterar entre uma coleção de objetos. Essa classe também faz parte do pacote de auxílio no uso de JasperReport e IReport. Mostro abaixo um exemplo simples. Primeiro vejamos as classes de dominio:

public class Pessoa
{
 String nome;
 Date nascimento;
 Endereco endereco;
 List<String> telefones;
 // ... Gets e Sets omitidos ...
}
public class Endereco
{
 String rua;
 short numero;
 // ... Gets e Sets omitidos ...
}

Agora vou preencher o relatorio com uma lista de pessoas:

List pessoas = loadPessoas();
ColecaoDataSource dataSource = new ColecaoDataSource(eu);
JasperReport compilado = JasperCompileManager.compileReport("/tmp/Relatorio.xml");
JasperPrint preenchido = JasperFillManager.fillReport(compilado, new HashMap(), dataSource);
JasperViewer.viewReport(preenchido);

No seu relatorio, para acessar os campos da Pessoa, basta declarar os campos da mesma forma como foi feita com a classe ObjetoDataSource. Viu como é fácil?

Agora digamos que ao invés de List, queremos utilizar um Map. É a mesma coisa, só a declaração dos campos no relatório fica um pouco diferente. Isso porque passamos a iterar não por objetos Pessoa, mas por objetos Entry. Veja abaixo:

Map<Integer,Pessoa> pessoas = loadPessoas();
ColecaoDataSource dataSource = new ColecaoDataSource(eu);
JasperReport compilado = JasperCompileManager.compileReport("/tmp/Relatorio.xml");
JasperPrint preenchido = JasperFillManager.fillReport(compilado, new HashMap(), dataSource);
JasperViewer.viewReport(preenchido);

No relatório então, os campos ficariam assim:
No seu relatorio, para acessar os campos da Pessoa, basta declarar os campos da seguinte forma:


<field name="key" class="java.lang.Integer" />
<field name="value.nome" class="java.lang.String" />
<field name="value.nascimento" class="java.util.Date" /> 
<field name="value.telefones" class="java.lang.Object" />
<field name="value.endereco.rua" class="java.lang.String" />
<field name="value.endereco.numero" class="java.lang.Short" />

Simples não é?

Download da timotta-api

2007-06-13T18:12:00.002-03:00

Faça o download dos fontes, testes, exemplos e binários:

Versão 0.0.2: http://www.divshare.com/download/5301025-124
Versão 0.0.1: http://www.divshare.com/download/936101-637

Veja as funcionalidades disponíveis na timotta-api 0.0.2:

Gerar imagem PNG com o GnuPlot

2007-05-31T16:35:00.000-03:00

Ao instalar o GnuPlot no servidor, verifiquei que não conseguia gerar graficos no formato png com este programa. O erro que eu obtinha é o seguinte:

gnuplot> set terminal png
                      ^
         unknown or ambiguous terminal type; type just 'set terminal' for a list

Observando o log da configuração, config.log, que é gerado assim que o comando ./configure é executado descobri qual o problema, faltava-me a libgd. Veja a linha do log mostrando o problema:

configure:16121: result:   png terminal: no (requires libgd with png support)

Sabendo disso, desinstalei o gnuplot, instalei a libgd e todas suas dependencias para finalmente reinstalar o gnuplot. Com isso, tudo funcionou perfeitamente.

Load alto causado por um HashMap

2007-05-30T17:19:00.000-03:00

Recentemente tivemos um problema em produção com nosso sistema. O load do servidor aumentava gradativamente chegando a um ponto em que era necessário reinicia-lo. Para quem não sabe, o load é um cálculo que indica quantas threads estão executando ou tentando executar em um determinado período. Ou seja, este problema de load alto poderia então ser causado por uma grande quantidade de acessos, no entanto, o load não baixava em periodos de pouco acesso, e até mesmo quando tirávamos o servidor do balanceamento.

Para analisar as threads que estavam executando, lançamos mão de um Thread Dump em dois momentos, antes de tirarmos a máquina do balanceamento, e outra uma hora depois de tirá-la. No Java, para obter um Thread Dump basta executar o seguinte comando, onde o processo_id é o pid do processo Java que queremos analisar.

kill -QUIT processo_id

Com o resultado em mãos descobrimos que antes e depois de tirarmos o servidor do balanceamento havia uma thread executando (runnable) travada na linha 325 de um HashMap. Veja a descrição dessa thread abaixo:

"ExecuteThread: '94' for queue: 'default'" daemon prio=5 tid=0x00b525a0 nid=0x2c runnable [0x63bfe000..0x63bffc28]
at java.util.HashMap.get(HashMap.java:325)
(...)

Foi então que descobrimos o problemas. Procuramos no Google por esta linha e encontramos diversas pessoas com o mesmo problema e até mesmo notificações deste possível bug para Sun. Contudo, isto não é um bug. O que acontece é que a classe HashMap não é thread safe, nem mesmo para seus métodos put e get. Portanto, se diversas threads gravam e recuperam valores de um HashMap, pode ocorrer problemas como esse. De fato, se olharmos o código de HashMap, podemos perceber que o método get tem grandes possibilidades de entrar em loop infinito.

A solução recomendade pela Sun é utilizar o wrapper sincronizado para mapas Collections.synchronizedMap(new HashMap()), ou utilizar a classe ConcurrentHashMap da api de concorrência incorporada ao Java 5, a java.util.concurrent. Para quem não pode utilizar o Java 5, pode-se utilizar a versão back-port da java.util.concurrent. No nosso caso, utilizamos essa versão backport.

Configurando um tópico JMS no JBoss

2007-05-24T17:51:00.000-03:00

Para configurar um tópico de Java Message Service no JBoss (a versão que estou utilizando é 4.0.5.GA) basta editar o arquivo %JBOSS_HOME%/server/default/deploy/jms/jbossmq-destinations-service.xml iserindo uma tag XML como mostrada abaixo:

<mbean code="org.jboss.mq.server.jmx.Topic" 
        name="jboss.mq.destination:service=Topic,name=nomeDoMeuTopico">
    <depends optional-attribute-name="DestinationManager">jboss.mq:service=DestinationManager</depends>
    <depends optional-attribute-name="SecurityManager">jboss.mq:service=SecurityManager</depends>
    <attribute name="SecurityConf">
        <security>
            <role name="guest" read="true" write="true"/>
            <role name="publisher" read="true" write="true" create="false"/>
            <role name="durpublisher" read="true" write="true" create="true"/>
        </security>
    </attribute>
</mbean>

Não sei bem para que serve cada um dos parâmetros pois estou começando a estudar JMS agora.

Depois de configurar um tópico eu crio um servlet de exemplo que lê um parâmetro e o escreve no tópico como uma mensagem de texto. Observer que o lookup que fazemos no InitialContext para pegar o tópico utiliza o mesmo nome do tópico que configuramos adicionado com o prefixo "topic/":

@Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
    Context jndiContext = null;
    TopicConnectionFactory topicConnectionFactory = null;
    TopicConnection topicConnection = null;
    TopicSession topicSession = null;
    Topic topic = null;
    TopicPublisher topicPublisher = null;

    try
    {
        jndiContext = new InitialContext();

        topicConnectionFactory = (TopicConnectionFactory) jndiContext.lookup("TopicConnectionFactory");
        topic = (Topic) jndiContext.lookup("topic/nomeDoMeuTopico");

        topicConnection = topicConnectionFactory.createTopicConnection();
        topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
        topicPublisher = topicSession.createPublisher(topic);

        TextMessage mensagem = topicSession.createTextMessage();
        mensagem.setText( request.getParameter("m") );
        topicPublisher.publish(mensagem);
    }
    catch (NamingException e)
    {
        log.error("",e);
    }
    catch (JMSException e)
    {
        log.error("",e);
    }
    finally
    {
        if (topicPublisher != null) try { topicPublisher.close(); } catch (JMSException e) {}
        if (topicConnection != null) try { topicConnection.close(); } catch (JMSException e) {}
    }

    response.getWriter().print("Mensagem publicada");
}

Para ler as mensagens enviadas ao tópico é preciso definir um listener, implementando a interface MessageListener, como é mostrado no código abaixo:

public class MensagemDeTextoListener implements MessageListener
{
    public void onMessage(Message mensagem)
    {
        TextMessage msg = null;

        try
        {
            if (mensagem instanceof TextMessage)
            {
                msg = (TextMessage) mensagem;
                System.out.println("Leu mensagem: " +  msg.getText());
            }
            else
            {
                System.out.println("Mensagem de tipo invalido: " + mensagem.getClass().getName());
            }
        }
        catch (JMSException e)
        {
            log.error("",e);
        }
    }
}

Finalmente é preciso inscrever uma instancia deste listener como leitor do tópico. No exemplo abaixo é mostrado como inscrever um listener no tópico anteriormente definido, através do método contextInitializer de um ServletContextListener.

private TopicConnection topicConnection;

private void contextInitialized(ServletContextEvent evento)
{
    Context jndiContext = null;
    TopicConnectionFactory topicConnectionFactory = null;
    TopicSession topicSession = null;
    Topic topic = null;
    TopicSubscriber topicSubscriber = null;
    MensagemDeTextoListener topicListener = null;
    TextMessage message = null;

    try
    {
        jndiContext = new InitialContext();
        topicConnectionFactory = (TopicConnectionFactory)
        jndiContext.lookup("TopicConnectionFactory");
        topic = (Topic) jndiContext.lookup("topic/mensagemTopic");

        topicConnection = topicConnectionFactory.createTopicConnection();
        topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
        topicSubscriber = topicSession.createSubscriber(topic);
        topicListener = new MensagemDeTextoListener();
        topicSubscriber.setMessageListener(topicListener);
        topicConnection.start();
    }
    catch (NamingException e)
    {
        log.error("",e);
    }
    catch (JMSException e)
    {
        log.error("",e);
    }
}
private void finalizarSubscriber()
{
    try
    {
        topicConnection.close();
    }
    catch (JMSException e)
    {
        log.error("",e);
    }
}

Pronto, aparentemente o exemplo funcionaria, mas não, quando inicializar seu JBoss, ocorrerá o seguinte erro: javax.jms.IllegalStateException in JBOSS: This method is not applicable inside the application server. See the J2EE spec, e.g. J2EE1.4 Section 6.6. Esse erro se dará exatamente na linha em que você adiciona o listener das mensagens ao tópico.

Ainda não entendi bem o porque isso acontece, mas achei a solução: Basta alterar o arquivo %JBOSS_HOME%/server/default/deploy/jms/jms-ds.xml adicionando o parâmetro Strict à connection-factory de jndi-name JmsXA. Veja abaixo:

<tx-connection-factory>
    <jndi-name>JmsXA</jndi-name>
    <xa-transaction/>
    <rar-name>jms-ra.rar</rar-name>
    <connection-definition>org.jboss.resource.adapter.jms.JmsConnectionFactory</connection-definition>
    <config-property name="SessionDefaultType" type="java.lang.String">javax.jms.Topic</config-property>
    <config-property name="JmsProviderAdapterJNDI" type="java.lang.String">java:/DefaultJMSProvider</config-property>
    <config-property name="Strict" type="java.lang.Boolean">false</config-property>
    <max-pool-size>20</max-pool-size>
    <security-domain-and-application>JmsXARealm</security-domain-and-application>
</tx-connection-factory>

Cliente de IRC em Java

2007-05-23T11:33:00.000-03:00

Na verdade neste artigo não faremos um cliente de IRC, faremos um simple bot. Mas, a biblioteca que apresento também serve para fazer clientes de IRC, é a PircBot (Java IRC Bot Framework). Para funcionar você pode utilizar um servidor de IRC já existente, ou instalar um na sua máquina. No caso eu preferi intalar um, e utilizei o UnrealIRCd, que possui versões para Windows e Linux.

O UnrealIRCd é um bom servidor de IRC pois é fácil, na medida do possível, de configurar. Isso porque as mensagens de erro dele são bem explicativa, dizendo até mesmo em qual linha do arquivo de configuração há uma entrada incorreta ou faltando.

Depois de escolher servidor criamos uma classe extendendo org.jibble.pircbot.PircBot, essa classe representará o usuário que criamos para se conectar no IRC. A idéia é fazer um usuário que desconecte do IRC quando receber uma mensagem "Sai vagabundo" de qualquer pessoa em qualquer sala.

public class BotVagabundo extends PircBot
{
    public BotVagabundo(String nome)
    {
        this.setName(nome);
    }

    @Override protected void onMessage(String channel, String sender, String login, String hostname, String message)
    {
        System.out.println("Recebi em [" + channel + "] do usuario [" + sender + "] a mensagem [" + message + "]");

        if("Sai vagabundo".equals(message))
        {
            this.disconnect();
            this.dispose();
        }
    }
}

O método PircBot.setName(String) define o nick do usuário. O método onMessage, é acionado quando alguma mensagem é recebida, seja num dos canais em que ele se encontra ou em um chat privado.

Agora vamos ver como se faz para conectar esse usuário no IRC:

BotVagabundo bot = new BotVagabundo("Chapun");

bot.setVerbose(true);
bot.connect("irc.chapun.com");
bot.joinChannel("#brasil");

bot.sendMessage("#brasil", "Eu sou um bot");

No caso eu não só fiz o bot conectar no servidor irc.chapun.com (coloquei o meu servidor local com este host) como fiz ele entrar no canal #brasil e enviar uma mensagem informando que é um bot.

Viu como é fácil?

Além disso, o PircBot tem diversas outras opções, como pegar a lista de canais, lista de usuários em um canal, kikar um usuário... Vale o tempo perdido dar uma olhada no site dele.

Teste unitário em funções javascript utilizando o JUnit

2007-05-16T20:20:00.001-03:00

Um dos grandes problemas do javascript é a falta de testabilidade. Vou mostrar aqui nesse artigo uma forma que encontrei de testar as funções de arquivos javascripts utilizando o JUnit. Ah! Claro, isso só é possível se você estiver utilizando o Java 6, que possui suporte a linguagens de script e já vem nativamente com suporte a javascript.

Primeiro criamos o arquivo funcoes.js contendo uma função para validar um determinado formulário. O objetivo é retornar verdadeiro se todos os campos estiverem preenchidos e falso no caso contrário. O formulário html deve ter dois campos: nome e senha. Inicialmente deixaremos essa função sem nenhum código, pois criaremos os testes primeiro:

function validaFormulario(f)
{
    return false;
}

Em seguida criamos uma classe para realizar os testes unitários contendo o método testValidaFormulario e outras duas classes internas para servir de Mock do formulário html e dos campos do formulário, HtmlFormMock e HtmlFieldMock respectivamente. Segue o código:

package junit.script;
import junit.framework.TestCase;

public class FuncoesTest extends TestCase
{
    public void testValidaFormulario() throws FileNotFoundException, ScriptException, NoSuchMethodException
    {
        //Aqui entrarão os testes
    }
 
    public class HtmlFormMock implements Serializable
    {
        public HtmlFieldMock nome = new HtmlFieldMock();
        public HtmlFieldMock senha = new HtmlFieldMock();
    }
    public class HtmlFieldMock implements Serializable
    {
        public String name;
        public String value;
    }
}

No método testValidaFormulario da classe de testes começamos então importanto o script funcoes.js, e criando um Invocable para poder executar funções no javascript:

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.eval( new FileReader( "C:/Projetos/testes/web/funcoes.js" ) );
Invocable invocable = (Invocable) engine;

Em seguida preenche-se o Mock de formulário da seguinte forma:

HtmlFormMock f1 = new HtmlFormMock();
f1.nome.name = "nome";
f1.nome.value = "Tiago";
f1.senha.name = "senha";
f1.senha.value = "123456";

Tendo o invocador de funções de script (Invocable) e o objeto mock, basta alterar os atributos deste objetos para utilizá-lo como parâmetro do formulário por diversas vezes. Veja abaixo os testes que defini para esta função, repare que fiz dois testes para verificar se o campo "nome" e o campo "senha" existem no formulário, pois é possível que criem um formulário html sem o campos:

//Todo formulario preenchido
Boolean b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertTrue("Formulario todo preenchido deve retornar true", b.booleanValue());

//Senha preenchida com nulo
f1.senha.value = null;
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Senha preenchida com nulo deve retornar falso", b.booleanValue());

//Senha preenchida com vazio
f1.senha.value = "";
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Senha preenchida com vazio deve retornar falso", b.booleanValue());

//Nome preenchido com nulo
f1.senha.value = "outra";
f1.nome.value = null;
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Nome preenchido com nulo deve retornar falso", b.booleanValue());

//Nome preenchido com vazio
f1.nome.value = "";
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Nome preenchido com vazio deve retornar falso", b.booleanValue());

//Campo nome do formulario nao existir deve retornar falso
f1.nome = null;
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Campo nome do formulario nao existe entao deve retornar falso", b.booleanValue());

//Campo senha nao pode ser nulo
f1.nome = new HtmlFieldMock();
f1.nome.name = "nome";
f1.nome.value = "Tiago";
f1.senha = null;
b = (Boolean) invocable.invokeFunction("validaFormulario", new Object[] { f1 } );
assertFalse("Campo senha do formulario nao existe entao deve retornar falso", b.booleanValue());

Executando esse teste com o JUnit teremos uma falha logo no primeiro teste, pois o este espera que haja um retorno de true e nossa função javascript está sempre retornando false. Alteremos então a função javascript dando-lhe um código aceitável:

function validaFormulario(f)
{
 if( f.nome && f.nome.value && f.nome.value.length() > 0 &&
  f.senha && f.senha.value && f.senha.value.length() > 0 )
 {
  return true;
 }
 return false;
}

Pronto, tendo a função javascript codificada, basta rodarmos o teste no JUnit novamente para verificar que finalmente a função está funcionando de acordo com o específicado. E o melhor, sempre que ocorrer uma alteração no código dela, saberemos se houve alguma quebra de contrato.

Também é possível testar métodos de classes javascript. Basta utilizar o método invokeMethod da interface Invocable, ao invés de invokeFunction. Mas isso eu deixo pra outro artigo.

Como utilizar o ForEach Controller do JMeter

2007-05-10T12:12:00.001-03:00

A estrutura de repetição, ForEach Controller do JMeter exige que existam váriaveis definidas com um padrão contendo um prefixo seguido de um número sequencial (Exemplo: x1, x2, x3, ou , n_1, n_2, n_3). Para definir um grande número de váriaveis sem grande esforço, pode-se utilizar um CSV Data Set Config que define váriaveis apartir de um arquivo texto.

No campo "Filename" do CSV Data Set Config indica-se o path de um arquivo de texto contendo os valores separados por vírgula (Exemplo: 10,56,345,12). A seguir no campo "Variable names" define-se um nome de váriavel para cada valor definido no arquivo texto. Assim, se no arquivo texto tiver cinco valores, devem ser definidos cinco nomes de váriaveis (Exemplo: n_1,n_2,n_3,n_4,n_5).

No ForEach Controller deve-se indicar o prefixo da váriavel em "Input variable prefix". Se o padrão de váriaveis suas possuir um _ antes do número, pode-se marcar a opção "Add _ before number". O campo "Output variable name" recebe o valor da variável que receberá o valor de uma das variáveis a cada iteração. Ou seja, a primeira vez que executar o valor será de n_1, na segunda vez será de n_2 e assim por diante.

Assim, os itens que estiverem dentro do ForEach Controller passam a poder utilizar a váriavel definida em "Output variable name" utilizando um padrão parecido com de Expression Language do JSP 2.0: ${nomeVariavel}.

Número de threads no Tomcat

2007-05-09T17:50:00.000-03:00

Para aumentar o número de threads que o seu Tomcat utiliza para atender requisições é só alterar o server.xml, localizado em TOMCAT_HOME/conf/server.xml. É necessário informar alguns novos atributos (ou alterar) na tag Connector que é utilizada para receber as requisições, ou seja aquela que possui o atributo "port" com valor igual a porta http. Veja abaixo:

<Connector 
    className="org.apache.coyote.tomcat4.CoyoteConnector" port="80" 
 ...
    maxThreads="150"
    minSpareThreads="25"
    maxSpareThreads="75">
 ...      
</Connector>

O atributo "maxThreads" indica o máximo de threads que o tomcat irá abrir, o "minSpareThread" e "maxSpareThreads" são respectivamente o mínimo e o máximo de Threads que o Tomcat disponibilizará para servirem de steps.

Essa configuração funcionou para a versão 4.1.31 do Tomcat, mas creio não deve ter mudado para novas versões.

Busca com OpenSearch no Firefox e IE7

2007-05-07T18:05:00.000-03:00

Recentemente fiz texto explicando como disponibilizar a busca de seu site no Firefox. Semana retrasada aqui no trabalho utilizamos uma nova forma de disponibilizar a nossa busca nos navegadores dos usuário. Dessa vez, funciona tanto para Internet Explorer 7, quanto para o Firefox.

Isso foi feito utilizando o padrão OpenSearch. E é bem similar ao padrão do artigo anterior, veja abaixo o código do XML que é preciso disponibilizar:

<?xml version="1.0" encoding="UTF-8"?>
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
    <ShortName>Programando sem cafeina</ShortName>
    <Description>Blog sobre tecnologia principalmente para a area de desenvolvimento de sistemas</Description>
    <Url type="text/html" template="http://programandosemcafeina.blogspot.com/search/label/{searchTerms}"/>
    <LongName>Programando sem cafeina - Blog sobre tecnologia principalmente para a area de desenvolvimento de sistemas</LongName>
    <Image height="64" width="64" type="image/png">http://programandosemcafeina.blogspot.com/imagems/busca-openserach.png</Image>
    <Image height="16" width="16" type="image/png">http://programandosemcafeina.blogspot.com/imagems/busca-openserach.png</Image>
    <Language>pt-br</Language>
    <OutputEncoding>UTF-8</OutputEncoding>
    <InputEncoding>UTF-8</InputEncoding>
</OpenSearchDescription>

Esse XML tem apenas as opções básicas, para saber o restante das opções visite a página: Descrição do documento OpenSearch.

Continuando então, para disponibilizar a busca não basta apenas colocar o XML lá no seu servidor, é preciso oferecer um link com um código javascript que adicione a busca na barra de ferramentas do navegador do usuário. Veja o exemplo abaixo de como fazer isso:

<a href="javascript:void(window.external.AddSearchProvider('http://programandosemcafeina.blogspot.com/minhabusca.xml'));">
Adicionar busca do meu blog
</a>

Viu como é fácil? Quem quizer testar para ver como ficou a busca para o Globo Vídeos basta adicioná-la clicando em Adicionar busca do Globo Vídeos em seu navegador. É bom lembrar que em navegadores muito antigos isso não funciona. No Internet Explorer 6 mesmo não funciona.

Problemas com Post do XMLHttpRequest

2007-05-03T05:10:00.001-03:00

Recentemente tive problemas ao tentar utilizar chamadas assíncronas no javascript utilizando o método post do protocolo http. Na verdade, o que ocorria é que os parâmetros enviados por post não eram recebidos em meu servlet. Descobri então como contornar isso, mas não entendi o porque desse problema ter ocorrido.

No javascript eu fazia a seguinte chamada, onde a variavel r era um objeto XMLHttpRequest:

r.open("POST", "http://localhost/MeuServlet", true);
r.send("nome=tiago");

No servlet MeuServlet eu apenas pegava o parâmetro nome e o imprimia na saída padrão:

String nome = request.getParameter("nome");
System.out.println("nome enviado = " + nome);

A saída era sempre "nome enviado = null". Olhando no debugger de chamadas assíncronas do firebug dava pra ver que os parâmetros estavam sendo enviados com sucesso. O problemas estava mesmo na recepção. Eis então que achei um exemplo na internet com o que faltava para meu código javascript:

r.open("POST", "http://localhost/MeuServlet", true);
r.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;");
r.send("nome=tiago");

Colocando essa linha indicando o Content-Type no header da requisição a chamada por post passou a funcionar. Se alguém tiver uma explicação do porque disso será de grande ajuda.

Rolar um DIV via javascript

2007-05-02T13:48:00.000-03:00

Segue um exemplo de como rolar um div via javascript:

function praBaixo()
{
   var c = document.getElementById("meuId");
   c.scrollTop = c.scrollHeight;
}

No exemplo, a função "praBaixo" colocaria a barra de rolagem de um div para baixo de forma a mostrar o ultimo conteudo do div. É bom lembrar que para um div ter barra de rolagem é preciso indicar seu tamanho, width para rolagem horizontal e height para rolagem vertical, e a propriedade "overflow: auto" no css.

Como criar funções em sua taglib

2007-04-25T16:32:00.000-03:00

Caso você tenha necessidade de uma função que não existe na JSTL, você pode criar facilmente sua própria função. Nesse mini tutorial explicarei como fazer isto. Faremos uma função que retira os simbolos de maior e de menor (<>) dos textos para impedir que tags htmls sejam inseridas numa página. A primeira coisa a se fazer é criar uma classe com um método estático com essa funcionalidade. Veja:

package meupacote;

public class MinhaClasse
{
  public static String escapeHtml(String html)
  {
      String texto = null;
      if( html != null )
      {
          texto = html.replaceAll("<", "& lt;");
          texto = texto.replaceAll(">", "& gt;");
      }
      return texto;
  }
}

Como podemos ver, o método escapeHtml recebe um html e substitui todas as ocorrências de < > pelo seu código equivalente em html. O segundo passo é definir no seu arquivo tld essa function, inserindo a tag function e suas sub-tags de configuração. Veja:

<function>
   <description>
       Substitui tags simbolos de maior e maior pelo seu codigo html
   </description>
   <name>escapeHtml</name>
   <function-class>meupacote.MinhaClasse</function-class>
   <function-signature>boolean escapeHtml(java.lang.String)</function-signature>
</function>

As tags mais importantes da configuração da função são "name", que indica por qual nome ela será referenciada no jsp, "function-class", que indica qual classe possui o método equivalente à função e "funtion-signature", que indica qual o método responderá pelas ações da função.

Tendo isso, basta utilizar essa função no seu jsp, importando sua taglib e chamando a função no formato prefixo:nomefuncao(parametros). Veja o exemplo:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="mt" uri="http://programandosemcafeina.blogspot.com/jsp/taglib/mt" %>

<h1><c:out value="${mt:escapeHtml(materia.titulo)}" /></h1>
<p><c:out value="${mt:escapeHtml(materia.texto)}" /></p>

É claro que por eu usar a tag c:out não seria necessária a função escapeHtml, pois essa tag já faz a conversão que implementamos (e muitas outras). Contudo existem situações em que ela seria necessária. Um exemplo é se utilizarmos a Json Taglib. Essa taglib não tem a opção de escapar o html, para ela então faz-se necessário o uso de uma função como a que fizemos no exemplo.

Resumo do Sun Tech Days de 2007

2007-04-23T02:00:00.000-03:00

Segue o resumão de todos os dias do Sun Tech Days de 2007. As fotos e vídeos irei postar durante a semana.

Resumo do Sun Tech Days do dia 19/04/2007

Resumo do Sun Tech Days do dia 20/04/2007

2007-04-23T01:55:00.001-03:00

Aqui estão as minhas impressões e o que aprendi no segundo dia do Sun Tech Days de São Paulo:

Demorei um pouco pra postar mais foi :)

WEB 2.0 com Ajax no Sun Tech Days

2007-04-23T01:48:00.001-03:00

Essa palestra não trouxe muitas informações novas, era mais para iniciantes na área de ajax, explicando como funcionam as chamadas assincronas utilizando o objeto XMLHttpRequest e dando alguns exemplos bem manjados. Uma coisa apresentada que eu não conhecia é o JMaki Widget. Com essa ferramento no NetBeans, rapidamente a palestrante fez uma página com um menu de imagens de cidades, utilizando aquele efeito que o menu do OS-X tem, que ao clicar em uma delas era exibida a localização da cidade, utilizando Yahoo Maps. Só com Widgets. É uma boa dar uma pesquisada nessa ferramenta.

Aplicações BPEL e SOA com Oracle no Sun Tech Days

2007-04-23T01:34:00.001-03:00

Com essa palestra finalmente aprendi o que é BPEL e para que serve. Relutei muito em ler sobre o assunto, mas não teve jeito :) Segundo a palestra utilizamos o BPEL quando precisamos chamar vários webservices em sequências.

Achei muito interessante, mas a idéia de programar via XML não me agrada. Estruturas condicionais e loops num XML são coisas que nunca me agradarão. Contudo, o fato de ser XML torna a customização de um workflow mais fácil de ser manejado por um programa, como o da Oracle que foi exibido na palestra.

Algumas tags de atividades que foram mostradas são <receive> que recebe a requisição de um cliente, o <reply> que retorna a requisição para o cliente e o <invoke> que chama um webservice. E algumas tags de estrutura que foram mostradas são <sequence> que faz com que as atividades em seu interior sejam executadas em sequencia, <flow> que faz com que as atividades em seu interior sejam executadas em paralelo e <switch> que tem a mesma responsabilidade de um switch programático.

Outra coisa interessante mostrada nessa palestra foi como é formado um arquivo WSDL. Primeiro os tipos de dados, depois as mensagens, os ports referenciando as mensagens, os bindings e finalmente o service.

Linguagens de script no Java no Sun Tech Days

2007-04-23T01:20:00.001-03:00

Palestra muito interessante mostrando a capacidade do Java 6 de executar linguagens de script. Basicamente existem duas formas de se executar uma liguagem de script no Java, por dentro de uma classe ou utilizando o executavel jrunscript.

Dentro de uma classe é preciso pegar o ScriptEngine utilizando o ScriptEngineManager. O ScriptEngine possui um método eval(String ou Reader) que executa um script apartir de uma String ou apartir de um arquivo utilizando um Reader. Para invocar funções utiliza-se o método invokeFunction(String), e nessa chamada pode-se indicar os parâmetros da função pois é um método que utiliza varargs.

Outra coisa legal é o método put que serve para colocar objetos Java dentro do script. As alterações ocorridas neste objeto dentro do script são refletidas fora do script. Também foi mostrado um exemplo de javascript importanto classes Java, com a função importPackage.

Muitos se perguntam se esse suporte a linguagens de script é mesmo necessário e o palestrante deu uma boa idéia do porque é sim importante. Primeiro porque a idéia é que o Java se separe de sua VM, de forma que esta VM possa rodar não só em diversas plataformas como também diversas linguagens. Segundo porque poder executar script apartir de classes Java é muito bom para customização de sistemas, principalmente na área financeira.

Sobre JSF no Sun Tech Days

2007-04-23T01:08:00.001-03:00

Nessa palestra falou-se sobre as qualidades e defeitos do JSF, motivos para utilizá-lo, e sobre o futuro deste framework. Ao final foram feitos alguns rápidos exemplos utilizando o Visual Web Pack em conjunto com o Sun Java Creator.

Interessante foi saber que no futuro o JSTL e o JSF estarão no mesmo pacote. Ou seja, a Sun está fazendo de tudo para que o JSF enfim ganhe mercado. Hoje o JSTL é utilizado em conjunto com outros frameworks, mas se o JSF vier junto com o JSTL, será estranho utilizar outro que não o JSF.

Outra ponto citado que eu já havia lido a respeito é que com o JSF é possivel que uma mesma página gere resultado em vários formatos, não só HTML. Basta utilizar algum RenderKit diferente do HTMLRenderKit. Pena que não foi mostrado nenhum exemplo, esse é mais um assunto que merece que eu faça uma boa pesquisa.

Ao final a palestrante mostrou dois exemplos, um parecido com o da palestra do ADF da Oracle, com a diferença de que o Sun Java Creator com o Visual Web Pack funcionou muito melhor que o JDeveloper em termos de desempenho (é bom lembrar que o JDeveloper exibido era uma versão pré-alfa).

O outro era uma integração com o PayPal que gerou um erro na aplicação. Quando isso ocorreu a palestrante ficou tão constrangida que tivemos dois minutos de silêncio absoluto. Felizmente o erro foi corrigido e ela enfim conseguiu exibir o exemplo pra nós.

Ferramentas Oracle no Sun Tech Days

2007-04-20T14:30:00.001-03:00

Nessa palestra falou-se sobre algumas ferramentas da Oracle para desenvolvimento web como o ADF, framework da Oracle baseado em JSF e EJB3. O exemplo que o palestrante fez com o JDeveloper ficou muito bonito, um grid utilizando um componente JSF deste IDE, que ao ser renderizado é exibido com opções de redimensionar colunas e ordenar por elas. Mão na roda não ter que procurar e adaptar esses scripts. Quem já fez um grid desses, cheios de firulas web 2.0, sabe a chatice que é. Contudo, a apresentação deixou uma má impressão, pois o JDeveloper demorou muito para carregar. Sem graça o palestrante explicou que isso ocorria porque era versão pré-alfa. Amador?

Abertura do segundo dia do Sun Tech Days

2007-04-20T14:20:00.001-03:00

Novamente escrevo sem acentos pois no connection point do Sun Tech Days nao tem como utilizar caracteres especiais.

A abertura desse segundo dia foi muito macante. O palestrante parecia mais um pastor de igreja evangelica do que alguem da area de tecnologia. Objetividade zero. Foi mais de meia hora repetindo o mesmo refrao de comunidade. Esse tipo de discurso serve mais para pessoas da area de humanas.

Depois tivemos uma palestra sobre algumas ferramentas da Oracle, que descreverei mais tarde.

O bom mesmo, foi ao final da abertura, que teve um divertido concurso habilidades no palco. Desenvolvedores e arquitetos subiam para cantar, dancar e especialmente pagar mico. Destaque para os vencedores do concurso, uma menina que veio preparadissima para dancar danca do ventre e um rapaz, mais troncho nunca vi, que tambem dancou danca do ventre, sem camisa, com as banhas balancando. Eu ri muito.

Essas palhacadas eu filmei. Logo logo colocarei os videos no Youtube e entao eu posto aqui no Programando sem cafeina.

Resumo do Sun Tech Days do dia 19/04/2007

2007-04-20T00:08:00.001-03:00

Aqui estão as minhas impressões e o que aprendi no primeiro dia do Sun Tech Days de São Paulo:

Agora vou dormir porque amanhã tem mais, se eu conseguir vaga no connection point eu posto mais durante o dia.

EJB 3 e JPA no Sun Tech Days

2007-04-19T19:07:00.001-03:00

A palestrante explicou como funciona o mapeamento objeto-relacional do JPA por anotações de relacoes ManyToOne e ManyToMany, e como mapear herança utilizando uma só tabela. Para diferenciar se um objeto é de uma subclasse ou de outra utiliza-se a anotação @DiscriminatorColumnName e @DiscriminatorValue. Essa foi a melhor palestra do dia pois explicou do ínicio ao fim o mapeamento, como funciona o EntityUnit, como funciona o EntityManager, mostrou o ciclo de vida de uma entidade e deu ótimas dicas para não termos problemas no desenvolvimento utilizando JPA. Mais tarde quando eu baixar os power points repassarei essas dicas. Agora eu vou aproveitar o cocktail :)

Palestra de JAX-WS e WSIT no Sun Tech Days

2007-04-19T19:01:00.001-03:00

Não consegui entender muito sobre esta palestra porque o palestrante falava rápido demais e a tradução simultânea, como mencionei antes, é um desastre, e além disso, nessa palestra a tradução estava especialmente ruim.

O que achei interessante, mas não entendi como funciona é o método de webservice assíncrono, assim que puder pesquisarei sobre o assunto. O palestrante fez também um WebService simples utilizando o JavaSE 6, com a anotacao @WebService e gerando os stubs com o comando wsimport. É incrivel como WebService fica mais facil com o JavaSE 6.

VMWare no Sun Tech Days

2007-04-19T18:57:00.001-03:00

Nao gostei muito da palestra sobre Virtual Desktop da VMWare, isso porque infra-estrutura nao eh a minha praia, e as coisas que aprendi nao me serao uteis no trabalho, apenas como curiosidade. Gostei da ideia de economia de energia que a utilizacao de maquinas virtuais pode proporcionar. E a ideia de Remotion, no qual um servidor virtual pode ser transferido de um servidor fisico para outro. Isso eh muito util. Uma sugestao que o palestrante deu eh utilizar isso para transferir ambientes totalmente testados para producao, sem nova instalacao.

Palestra sobre JavaSE 6 no Sun Tech Days

2007-04-19T18:45:00.001-03:00

Tivemos uma palestra mostrando as novas funcionalidades do JavaSE 6. O que foi mais interessante foram as alterações no Swing e no AWT. Dentre essas novas funções temos a nova classe TrayIcon que permite colocar um programa na bandeja do Sistema Operacional (Ali, ao lado do relógio), uma forma exibir uma tela de splash antes mesmo de carregar a JVM, e a classe Desktop que permite abrir sistemas nativos.

Outra nova funcionalidade que foi citada e que parece muito boa é a SwingWorker, que serviria para facilitar o trabalho multi-thread em aplicações Swing, pena que não mostraram nem mesmo um exemplo dela. Qualquer dia desses eu dou uma pesquisada sobre ela para colocar aqui.

No JavaSE6 também foram introduzidos novos executáveis para monitoração da aplicação, como é o caso do jconsole. Outro destaque é pela nova forma de criação de WebServices que dispensa a criacao do WSDL, bastando anotar a classe que irá prover o servico com @WebService. O proprio JavaSE levantaria um mini-servidor http para oferecer este servico, bastanto publicar o endpoint com Endpoint.publish.

Segundo o palestrante a migracao de JavaSE 5 para JavaSE 6 nao é custo algum pois nao há alteracao de sintaxe. Portanto é extremamente recomendável a migração devido às melhorias de performance.

Demos do Sun Tech Days

2007-04-19T18:39:00.001-03:00

Foram exibidas duas demonstracões de desenvolvimento rápido com o NetBeans. Nao sou fã dessa IDE, mas tenho que tirar o chapéu, foram ótimas demonstrações. Primeiro fez-se um menu SVG para JavaME e depois uma demonstração de uma aplicacao com o Matise. Ambos mostraram como é rápido o desenvolvimento no NetBeans. Acredito que no dia em que a Sun investir no aperfeiçoamento do editor desta IDE, o NetBeans finalmente poderá barrar o Eclipse. Enquanto isso continuo fiel ao programa que esconde o sol.

Outra coisa legal foi a exibição do SunSpot, uma espécie de luva que faz com que tenhamos um efeito similar ao do filme Minority Report misturado com o LookInGlass, o destop 3D feito em Java. Não funcionou perfeitamente, teve um momento em que a menina que apresentava teve que repetir o movimento umas duas vezes para girar umas janelas, mesmo assim foi lindo de se ver. Sinto que o futuro dos desktops será emocionante.