Comunidade Blastêmica

Mudei de casa

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

Ahá, e vc pensou que esse blog havia morrido, não era? Pois morreu mesmo. Esse é apenas um post para informar o endereço do meu novo blog:

http://marcospereira.wordpress.com/

Para aqueles que usam algum agregador de feeds, o novo endereço é:

http://marcospereira.wordpress.com/feed/

valeuz...

Filosofia futil sobre ciência e sociedade

2007-01-26T10:41:00.000-03:00

Penso que:

No final do século XX e início do século XXI, ocorreram "rupturas paradigmáticas" em diversas areas de conhecimento. Nestas se faz ciência. Como exemplo poso citar:
1 - na física o determinismo newtoniano foi rompido pela mecãnica quântica (aliás, o conceito de informação e fluxo de informação nos micro sistemas [informação quântica] é algo que me facina, pois percebo, mas ainda não sei formular bem esse pensamento, que aí está a possibilidade real de se inquirir sobre o q é informação, e então, poder trazer o entendimento dessa essencia conceitual, para o macro mundo [inclua-se aqui, o campo de nossa atuação acadêmico-profissional].
2 - na lógica matemática, Russel e Godel
3 - na linguística Wittgenstein e Chomsky
4 - na biologia Darwin (teoria da evolução - um livro q todo bibliotecário deve ler), além de Crick e Watson (DNA)
5 - os sistemas dinâmicos foram rompidos pela teoria do caos
6 - teoria da complexidade traz/dá um novo papel ao acaso, na teroia da evolução...
7 - na Ciência da Informação (Capurro, Floridi, Ingwersen, Thelwall etc).

Somado a essa "rupturas", tem-se uma nova visão de mundo, ou melhor, uma CRISE da visão dominante, refletida num espelho cruel onde fica claro o fracasso do capitalismo e do industrialismo (inclua-se o socialismo real), ao prover as soluções finais para os problemas cruciais da humanidade, tais como:
- poluição do meio ambiente; exlusão social; inseguranaça do cidadão; ameaça (instabilidade) constante de desemprego; violência, dentre outros.
Podemos acrescentar nessa linha de raciocínio, e perdoe-me pelos erros/abusos de análise, uma competição bárbara pelo controle da informação e do poder (capital), frustração com os ideais neoliberais e, por último, perda da utopia do socialismo soviético, ainda que resista um pouco em Cuba, por exemplo.

Todas essas transformações são parte de um mesmo mundo, onde a ideologia que reflete os interesses dos grupos dominantes é hegemônica. E então perguntas: o que essa assertiva tem a ver com as "rupturas" descritas acima? Respondo.

A visão de mundo dominante, no decorrer do tempo e espaço (num concepção histórica dos acontecimentos/eventos), acarreta na superestrutura cultural os parâmetros objetivos desse mundo, com sua base material e econômica e ordenção político-social. É nesse contexto que a ciência (processo científico), vai fornecer aos parâmetros objetivos "as ruputras paradigmáticas". Ou seja, o paradigma torna-se um tipo de subsídio, ferramenta. Estas vão se incorporar na visão de mundo (uma visão que penso ser ao mesmo tempo, local/individual e mundial/coletiva), e vão refletir nessa objetivação.

Assim, quando um paradigma torna-se parte dessa visão dos mundos, termos um paradigma hegemônico, ideologicamente inserido na rede de relações humanas, passando a influenciar em diversas e distintas áreas desse relacionamento. E vou além. Penso que em breve, as concepções das teorias econômicas que regulam o mundo atualmente, dando suporte teórico ao capitalismo neoliberal, vão se despedaçar e dar vasão a um novo paradigma, muito complexo e, talvez, oriundo/influenciado pela interação [no sentido de complemento] entre várias áreas disciplinares (ex: biologia + física + ciência cognitiva].
Mas ainda não esta muito claro para mim, quero dizer, como vão se relacionar essas disciplinas...

Então, para concluir, quando comentei sobre as relações de poder, que estão em jogo, entre ciência [enquanto processo constante] e sociedade [todas as esferas], estava defendendo essa minha teoria maluca e, ainda, desprovida de rigor empírico. É isso.

Não sei para onde vou [estudos] e nem por quê.

Bem aventurado aquele(a) que na inutilidade de Ser alcança, pelo menos, uma banal utilidade.
Diego Salcedo
Biblioteconomia - últimas disciplinas UFFFAAAA
UFPE

Foto e Fato

2006-05-19T10:24:00.000-03:00

Um dia comum na Biblioteca Pública de Nova York - Ilha de Manhattan - Estados Unidos.
Haja PC´s.
Não basta a quantidade infinita de livros que temos para "ler" numa vida.
Encontramos uma forma a mais de sofrimento.
Juntamos o PC e um livro, lado a lado.
Haja frustração.
Agora temos texto e hipertexto...
Agora tenho absoluta certeza:
o ser-humano, é completamente sem noção com relação a sua insignificância diante do seu ser.

Vos assina, Diego Salcedo.

XP, Seu nogueira e algumas lendas.

2006-04-06T22:53:00.000-03:00

Como eu disse num post já bem antigo aqui do blastemica, o povo de computação sempre dá um jeito de ligar acontecimentos a algo relacionado a... ora bolas, computação. Foi o sentimento que tive ao ler esse divertido, lendário e, como sempre, interessante post do Thiago Arrais. Não poderia deixar de fazer uma menção aqui.

valeuz...

APIs que não mordem.

2006-03-22T15:52:00.000-03:00

Desde que comecei a programar em Ruby ou outras linguagens de script, como php, por exemplo, penso sobre como essas linguagens possuem APIs bem simples e diretas de usar. Nada de muitos passos para realizar operações relativamente simples, as interfaces são mais diretas e geralmente invocar um método resolve o problema, ou boa parte dele. Mais ou menos como mostrei em um post anterior que apresenta, em 5 linhas, como fazer um leitor de RSS em Ruby. Nos ultimos dias, depois de ter conversas com Thiago Arrais e com Gandhi sobre esse assunto, resolvi ler (aqui, aqui, aqui e aqui) o que povo tem comentado sobre APIs, apenas para tentar formar uma opinião mais fundamentada. Também tentei ler algumas APIs em Java para fazer algumas operações que considero bastante diretas, como ler um RSS ou fazer o parse de um arquivo YAML.

Enquanto lia, constatei que a comunidade Java realmente cria ótimas APIs, boa parte pode servir como exemplo/estudo para programação e design patterns. Pode-se encontrar ótimo design em APIs como a de Collections ou IO, em um número bastante vasto de projetos open source e por aí vai. Mas, geralmente, as APIs em Java pecam por se utilizarem demais de expressões que se tornaram idiomaticas para a linguagem, ou pecam pelo excesso de zelo para escrever APIs que possam ser expandidas de acordo com a necessidade o que, de fato não as impede de ser simples. Um fato engraçado é como nem sempre as pessoas percebem que criam complicações desnecessarias. Exemplo: esses dias procurava por uma API para fazer o parse de arquivos YAML, se fizesse uma correspondencia direta do formato de um arquivo para a estrutura de uma classe, acharia perfeito. Eis que me deparo com a yaml4j - a YAML Loader/Dumper for Java. For those of us who wish Java were agile. O "agile", deixe-me explicar, fica por conta da discussão entre o formato yaml e xml. O primeiro exemplo da API é simples:

File f = new File(args[0]);
Reader reader = new BufferedReader(new FileReader(f));
Loader loader = new Loader();
loader.load( reader );

Object doc = loader.getDocument();

Claro, não vou colocar os imports e tudo mais, apenas o uso mais direto. Nada demais, certo? Errado! O yaml4j peca por me fazer criar objetos dos quais eu não quero saber, apenas para dar suporte a interface provida, ou melhor para superar a barreira criada pela interface não oferecida. O que eu realmente gostaria de fazer é:

Loader loader = new Loader();
loader.load("C:/my_file.yml");
Object doc = loader.getDocument();

Ou mais direto ainda:

Object doc = Loader.load("C:/my_file.yaml");

É provavel que muita gente diga que aí eu não poderia usar outros tipos de Reades, ou seja lá o que for, para fazer o load do arquivo. Não é verdade, simplesmente. Não o é porque quero apenas uma interface mais direta e não uma mais resumida, por mim o exemplo anterior poderia existir à vontade, mas a API deveria me prover métodos mais diretos. Outros com certeza dirão que, por ser código Java, eu poderia criar uma pequena extensão para a API, parar de reclamar e resolver o problema. Também não é verdade, ao menos para mim, pois estou preocupado em resolver os problemas do meu dominio e não em escrever linhas e mais linhas para dar suporte a API.

O ponto realmente é: se algo tem chance de ser usado com uma freqüência muito grande, vale a pena livrar as classes clientes da tralha, esconder a complexidade e prover uma interface para operações mais diretas. Exatamente assim:

require 'yaml'
doc = YAML::load(File.open('C:/my_file.yml'))

Ou, para ninguém ficar na bronca, para não pensarem que quero ver Java morta e enterrada, um exemplo da APIs que usei (alterei apenas para facilitar a leitura, mas perceba: é um correspondente direto para o código em Ruby):

File file = new File("ReceiptEntry.yml");
Entry entry = Yaml.loadType(file, Entry.class);

Um outro exemplo para mim é o Mentawai, apesar de o último release apresentar bons métodos para facilitar o uso do ActionConfig, poderia prover métodos como addForward, addRedirect, addNull. São consequences muito usados, então, por que não facilitar a vida? O addConsequence continua para permitir consequences customizadas.

Enfim, boa parte dos desenvolvedores Java - outras linguagens também, eu sei - deveria aprender a manter as APIs que desenvolvem tão simples quanto possível, mesmo que isso implique a criação de metodos a mais, um pouco de esperteza vai evitar copy and paste. Isso vale para desenvolvimento de classes que não formam uma API propriamente dita, mas que podem muito bem oferecer uma interface mais amigavel. As APIs nem sempre precisam estar prontas para salvar o mundo, às vezes precisam apenas carregar um arquivo YAML.

valeuz...

Adeus avatares a lá Orkut.

2006-03-21T23:38:00.000-03:00

Há algum tempo, um usuario do JavaFree reclamou no forum que o esquema de cores, mais as fotografias, davam a impressão para as pessoas do trabalho de que ele estava perdendo tempo no orkut. Na época eu lembro que pensei imediatamente no Greasemonkey e em como poderia criar um script para remover as tais fotos. Pois é, como eu vivo reclamando da falta de tempo, aproveitei o dia livre - maldita dor de cabeça - para ler sobre o greasemonkey e tentar fazer alguns scripts com utilidade pública.

O primeiro foi para remover as fotografias no forum do JavaFree. O trabalho foi minimo, especialmente depois de colocar um shell e o jsenv entre os meus bookmarks. Incrivel como o povo inventa utilidades para o desenvolvimento web. Mas, fim de papo, quem quiser instalar o script e se livrar dos avatares, vai precisar instalar o Firefox - que? Ainda não usa? Eis mais um bom motivo! - Greasemonkey e depois o script. Absolutamente tranquilo! Para quem já usa o Firefox e o Greasemonkey, clique com o direito aqui e seja mais feliz por não precisar aturar meu avatar.

Update 1: Depois eu tento ver porque ele só remove depois que a pagina carrega.
Update 2: Segundo essa discussão na lista do Greasemonkey, não dá para impedir que as imagens sejam mostradas, porque o script executa apenas depois de toda a arvore DOM ser montada. Enquanto isso, o browser faz as requisições para mostrar as imagens. Verei se há alguma maneira de contornar isso.

valeuz...

Plugins, tags e extensões

2006-01-29T21:14:00.000-03:00

Uma das maneiras recentes mais legais de se catalogar informação é usar tags que podem ser livremente criadas pelos usuários (exemplos: aqui, aqui, aqui e aqui). Tags são um dos destaques, a meu ver, um dos mais interessantes, do que se convencionou chamar de web 2.0. Antes, o que havia era um conjunto de categorias (exemplos aqui e aqui), na maior parte das vezes hierárquicas, criadas por algum administrador da vida e vc precisava, mesmo a contragosto, usar algum ponto da hierarquia. Com tags não. Agora vc categoriza, ou melhor rotula, a informação de acordo com a sua percepção sobre ela. E o melhor, pode compartilhar da percepção que as outras pessoas têm, tanto as que coincidem com as suas quanto as que não. Enfim, tags são um desenvolvimento porque agora as pessoas podem criar as classificações segundo as suas necessidades e vontades.

Vejo isso em arquiteturas que permitem o uso de plugins/extensões também. Agora eu não uso apenas software exatamente como ele vem - out-of-the-box - posso eu mesmo criar extensões de acordo com necessidades bastante particulares. Dos softwares que já usei, um dos primeiros, ao menos que eu me lembre, com esse tipo de funcionalidade era o Winamp. Agora, para mim, um dos melhores exemplos é o Firefox, o tal browser que incomoda a liderança menos folgada do Internet Explorer. E das tantas - e úteis - extensões para o Firefox, uma que me chama a atenção ainda mais é o Greasemonkey porque leva adiante o conceito de extensão. Vejo o Greasemonkey praticamente como uma extensão que permite criar extensões.

É uma daquelas sacadas bem geniais e, como boa parte das idéias geniais, se baseia em um conceito simples: que tal alterar as paginas que vc usa com freqüência? Colocar os links que vc mais usa e não aparecem de imediato, botões para ações comuns, remover partes da pagina que vc não usa, mudar o tamanho das letras, remover propagandas inconvenientes, enfim, o que fazer fica a seu critério. Isso tudo com scripts escritos em JavaScript (se vc for um programador, clique aqui), o bom conceito de se manter compatível com o que já existe. O tal do Greasemonkey é bom ao ponto de mudar minha visão preconceituosa sobre JavaScript - depois de Ruby a linguagem que mais desperta minha curiosidade, para ir alem de apenas validar formularios ou outras funcionalidades mais simples. Mas isso é outra história, preciso criar coragem para começar a escrever um post sobre APIs para daqui a pouco.

valeuz...

Não tem quem aguente!!!

2006-01-09T21:52:00.000-03:00

Hoje fui comprar um livro.
Abaixo do livro que compraria observei um outro livro:
Título: Tesauros (aliás, o único titulo que se encontra a venda em todas as livrarias do Recife sobre esse tema específico).
Até aqui tudo bem. Exceto que, eu estava na área de Física Quântica e Química.
O livro sobre Tesauros estava na área de Química desta livraria, a qual faz parte de uma rede de âmbito nacional.

Pensei!!! Está aqui por engano? Ou será que está classificado para vender assim?
O que fazer? Deixo onde está ou investigo o por que deste equívoco?
Como sou um graduando em biblioteconomia pensei: eu sei que está errado, mas como corregir o erro sem ser chato ou inconveniente? Como abordar um erro e dele chegar ao acerto?

Chamei um vendedor e perguntei: olha, posso lhe fazer uma sugestão?.
Ele respondeu: pois não Sr. E tirou o livro das minhas mãos.
Eu pedi licença, e tomei o livro de volta. Avisei que não queria comprar e nem ver preço, apenas gostaria de constatar um fato.

Então lhe disse: Este livro não é da área de Química.
Ele respondeu: Na etiqueta vem dizendo Química (manuscrito ao lado do preço).
Eu indaguei: Se eu lhe disser que Tesauro não tem nada a ver com Química e que este livro está à venda na prateleira equivocada?
O vendedor respondeu: Olha Sr., aqui na etiqueta diz que trata de Química.
Então eu sugeri que ele abrisse o livro e desse uma olhada mais detalhada.
Fez um gesto com os ombros, como quem não entendeu minha intenção.
Então fui mais além e sugeri que lesse as palavras chaves contidas na ficha catalográfica.

Assim que leu as palavras chaves, pediu para que eu o acompanhasse a um computador.
Digitou o título do livro e então, para minha supresa, no sistema de informação desta livraria de âmbito nacional o livro constava como parte integrante da área de Química.

O vendedor me perguntou: Na etiqueta diz Química e no sistema também. Por que o Sr. diz que está no lugar errado?
Eu respondi: quem sou eu para contrariar o sistema de informação desta mega loja e sua forma de classificar os livros?
e continuei: mas, se lhe interessar aprender um pouquinho mais sobre Tesauros e Química, lhe sugiro que leia a introdução do livro, enquanto não tiver que atender um cliente.
Assim terminamos nosso diálogo e me dirigi ao caixa para comprar meu livro de Física Quântica.

Já saindo da loja, uma pessoa me para. Era o vendedor.
Ele me disse: Obrigado Sr., pela dica. Quando li a introdução, verifiquei que não tem nada a ver com Química e sim com Linguagem e Documentação.
Pensei: Menos mal.
Apertei a mão do vendedor e lhe disse: Lembre-se de mudar no sistema, senão de nada adiantou a nossa intervenção.
Ele respondeu: Vou fazer isso agorinha, Sr. Mas antes tenho que notificar o escritório central. Obrigado.
Eu lhe respondi: não por isso.

Bem aventurado aquele(a) que na inutilidade de Ser alcança, pelo menos, uma banal utilidade.
Diego Salcedo - UFPE.

Adeus ano velho...

2005-12-30T00:18:00.000-03:00

Feliz 2006! Sim eu sei que ainda não chegou, mas ninguém espera que eu vá bloggar durante a virada de ano, então, antes de viajar para Pipa - estou com preguiça de procurar algo no google para linkar, se vira! - ficam os votos para um ano melhor do que 2005, para todos vocês três, meus caros leitores.

Espero uma boa festa em Pipa, até porque, veja bem, apesar de nunca ter ido lá, nem ser lá, nem ir para ficar, sempre me falam bem, então as expectativas são as melhores possiveis. Blog novamente apenas lá para o dia 4 de janeiro de 2006 quando volto a falar sobre qualidade de código, sobre Ruby ou qualquer outra lombra/lenda/mito que atraia meu interesse.

valeuz...

Ruby no tempo livre.

2005-12-28T22:03:00.000-03:00

Eu falei de Ruby apenas uma vez no blog até agora, na verdade, não diretamente de Ruby, e não escrevi nada mais do que algumas linhas embasbacadas por um video do RoR. De lá para cá, no tempo livre, parei para estudar um pouco sobre a linguagem e sempre fica aquela impressão de "não pode ser, só isso?" ou "hum, interessante". Esses dias enquanto fuçava no repositorio remoto do gem em busca de alguma biblioteca para rss - sei lá porque rss, oras - encontrei o Simple-RSS (para instalar gem install simple-rss), e convenhamos, o "simple" no nome é bem justificado. Para testar, resolvi ler o rss dos novos posts no forum do JavaFree. Nada de muito complicado, apenas acessar o rss, iterar sobre as entradas e mostrar os titulos dos posts. O código, gigantesco, 5 linhas, um absurdo, ficou assim:

require 'rubygems'
require 'simple-rss'
require 'open-uri'
rss = SimpleRSS.parse open('http://www.javafree.org/javabb/rss/newPosts.jbb')
rss.channel.entries.each {|e| puts e.title}

Nem quero imaginar como fazer um leitor RSS em Java. De qualquer modo, claro, uma ajudinha das closures, ausentes em Java, não fazem mal a ninguém. Por fim, nada de RoR, por enquanto, já que quero aprender Ruby para valer e depois sim usar o framework com alguns "add-ons". Os planos são fazer uma serie de exemplos simples e praticos até me sentir à vontade com a sintaxe. A proposito, acho que um livro não vai fazer mal.

valeuz...

Boas novas!

2005-12-25T15:08:00.000-03:00

Eis que chega o fim do ano, mais um, e espero que muitos outros fins de ano cheguem. Como de praxe, não fiz tudo que queria, tudo que poderia, mas fiz muita coisa boa esse ano, então, sem lamentações, muito menos promessas para ser mais isso menos aquilo ano que vem.

Se fosse fazer uma promessa seria a de ler mais, nada de livros técnicos, ou eles também. Apenas ler mais. Para não me esticar muito nesse post, afinal, fim de ano sempre se tem algo melhor para fazer do que postar em um blog, fica o Feliz Natal para todas as três pessoas que lêem os desvaneios publicados por aqui e os outros 2 que acessam para se certificarem de que eu continuo falando besteira, não tanta ainda, afinal falta tempo, fazer o que. Feliz Natal a todos, Feliz Ano novo e bla bla bla.

valeuz...

Por um codigo melhor - II

2005-12-19T23:57:00.000-03:00

No post anterior eu postei alguns dos erros que mais me irritam quando leio código alheio. Na verdade, não chega a ser irritação de fato, se fosse não me surpreenderia se fosse diagnosticado com ulcera ou coisa pior. Penso apenas que talvez, com um pouco de pair programming, o autor provavelmente não teria cometido tais erros, ou talvez tivesse cometido menos erros. Essa segunda parte não é muita coisa além de adições de novas dicas esquecidas no post anterior. Na verdade, eu estava com preguiça, mas enfim... vamos a outras dicas para evitar que seu código dê mais trabalho do que deveria e, acredite, se vc comete esse tipo de erros, ele vai dar mais trabalho do que deveria:

1. Exceptions são um fluxo à parte e não o principal. Mas que espécie de dica é essa? Todo mundo já sabe disso, o nome já explica, ora bolas. É, explica, mas não impede ninguém de escrever algo assim:

public int foo(int num) {
 if(num > 50) {

     //faz um monte de coisas complicadas com num
     //até chegar a um "resultado"

     return resultado;

 }

 throw new IllegalArgumentException("num deve ser maior do que 50");
}

Estranho porque o fluxo que realiza a operação é tratado como secundário, à parte, ele é quem faz parte do desvio e não a exception. Esse exemplo - lembre-se, sou péssimo para exemplos - pode não parecer tão ruim, mas experimente lidar com mais de uma exception dessa maneira para vermos no que acontece:

public int foo(int num) {
 if(num > 50) {

     if(num%2 == 0) {

         // faz um monte de coisas complicadas com num
         // até chegar a um "resultado"
         return resultado;
     }

     throw new IllegalArgumentException("num deve ser par");
 }

 throw new IllegalArgumentException("num deve ser maior do que 50");
}

Agora sim é possível perceber o problema com esse tipo de abordagem. Afinal, a grande questão é, porque as pessoas cometem esse tipo de erro? Pergunta retórica apenas. Exceptions, claro, devem ser tratadas em fluxos à parte, ou seja, se uma pré-condição não for satisfeita, uma exception devem ser lançada:

public int foo(int num) {

 // eu sei que não é assim, mas o maldito do blogger não sabe!
 if(num menorOuIgual 50) {
     throw new IllegalArgumentException("num deve ser maior do que 50");
     }

 if(num%2 != 0) {
     throw new IllegalArgumentException("num deve ser par");
 }

 // faz um monte de coisas complicadas com num
 // até chegar a um "resultado"
 return resultado;

}

Se vc ainda não se convenceu a escolher a segunda abordagem, experimente colocar uma nova pré-condição em cada um dos trechos e veja em qual faz isso de modo mais prático. Hoje, mesmo que ainda precise falar outras coisas sobre exception, fica apenas essa dica.

valeuz...

Por um codigo melhor I

2005-12-15T01:29:00.000-03:00

Se vc é programador, mesmo sem nunca ter lido algum livro sobre refactoring[1], é bem provável que já tenha reescrito algum trecho de código para melhorá-lo, torná-lo mais legível, rápido, ou seja lá o que for. Refactoring é uma das práticas mais comuns em metodologias ágeis[2] porque, geralmente, metodologias ágeis estão preocupadas com a qualidade dos artefatos mais importantes e imprescindíveis. E, claro, em desenvolvimento de software, pouca coisa é realmente mais imprescindível do que o próprio código, afinal, código é o artefato sempre presente. Daí haver a necessidade de torná-lo tão legível quanto o possível para que ele represente um "documento" sobre o sistema. Refactoring também entra aí: arrumar a casa e fazer todos entenderem o propósito do código - ou seja, como citei logo acima, fazer um punhado de instruções funcionarem como um "documento" do sistema. Mas, nesse posts, não vou falar especificamente sobre um catalogo de refactoring, se quiser ler algum, nada mais recomendado do que o livro do Fowler[3]. Também vou passar ao largo de definições mais aprumadas sobre o refatoração de código ou explicações de como test unitários[4] permitem reescrever o código de maneira segura.

Minha intenção com esse post é citar algumas dicas para evitar código ruim logo de primeira. Isso não vai lhe eximir completamente de reescrever uma parte ou outra enquanto o sistema evolui, isso é natural. Minha pretensão é evitar que vc pense em trucidar alguém - talvez vc mesmo, talvez eu - quando precisa refatorar partes do software. Vamos as dicas:

1. Dê nomes entendíveis a seus pacotes, classes, métodos e variáveis. Nomes entendíveis também passam pelo conhecimento comum entre os desenvolvedores[5]. Se for costume chamar um método que soma valores de "add", não tente usar algo como "xyz". Em suma essa dica se resume a fazer as pessoas com conhecimento do domínio reconhecerem o propósito da classe/metodo/variavel apenas pelo nome. Exemplos bobos - em Java - de como não fazer:

public void copy(File x, File y);
public long diff(Date d1, Date d2);

Dã, essa ficou fácil copia um arquivo para outro e vê a diferença entre as datas. Não? Não estava tão claro assim. Hum, e se eu tentar assim:

public void copy(File source, File destination);
public long diffInSeconds(Date inicio, Date fim);

Melhor, agora vc sabe qual arquivo é copiado para onde, sabe qual é a data de origem e qual a final e sabe que a diferença é em segundos. Mesmo em um exemplo tão trivial dá para perceber como escolher bem os nomes ajuda a tornar o código mais legível.

2. Transforme operações pouco claras em métodos com nomes - ah, os nomes - que identifiquem melhor a operação. Mesmo em alguns casos aparentemente simples isso pode ajudar um bocado. Por exemplo:

String id = "A@1232143245547657465";
...
if(id.charAt(0) == 'A') {
// algumas linhas antes - bastam 5
Permissoes p = getPermissoesAdmin();
}

Nessa situação vc pode perceber que 1) a operação é simples mas não está clara para quem bate o olho sobre o código e 2) eu sou péssimo para dar exemplos. Deixe-me tentar novamente:

double precoFinal = preco + preco * (17/100) - 10;

Tá, desisto de dar bons exemplos, vamos ao que interessa: tornar os dois trechos mais fáceis de entender. Primeiro, vamos transformar a operação do if em um método e depois usar a dica 1 para facilitar ainda mais a minha vida no futuro. Então, o código será:

String userId = "A@1232143245547657465";
...
if(isAdministrador(userId)) {
// algumas linhas antes - bastam 5
Permissoes permissoes = getPermissoesAdministrativas();
}

private boolean isAdminitrador(String userId) {
return id.charAt(0) == 'A';
}

Talvez vc ache que estou forçando a escrita de mais código, mas, na verdade, melhorei a legibilidade e permiti que a operação para indicar permissões administrativas seja tratada em um único ponto. Já o segundo exemplo, ficaria melhor assim:

double precoFinal = precoComTaxasDescontos(preco);

private double precoComTaxasDescontos(double preco) {
double imposto = preco * (17/100);
double desconto = 10;
return (preco + imposto - desconto);
}

Você até pode ter pensado no aumento de código, mas há, em sistemas reais, vantagens menos perceptíveis, ao menos nesses exemplos, como aplicar o conceito de DRY[6].

3. Remova a complexidade das classes clientes para os métodos que elas usam. Isso faz com que o código nas classes clientes esteja preocupado com suas próprias operações, e não em dar suporte as operações dos métodos que elas usam. Exemplo bobo - mas (quase) real dessa vez:

int idBah = bah.getId();
int numBah = bah.getNum();
String name = foo.getName();
long somethingId = foo.getSomething().getId();

facaAlgo(idBah, numBah, name, somethingId);

Ruim, muito ruim. Imagine 10 classes clientes, pense na repetição de código e... ...isso mesmo, refatore para trazer a complexidade para o método assim:

public void facaAlgo(Bah bah, Foo foo) {

int idBah = bah.getId();
int numBah = bah.getNum();
String name = foo.getName();
long somethingId = foo.getSomething().getId();

// faz o treco

}

E a classe cliente, bem mais aliviada:

facaAlgo(bah, foo);

Bom, sem mais dicas por enquanto. Alias, eu gostaria de ouvir as de vcs. Quais as dicas, bastante práticas, se possível, para tornar meu código um pouco menos fedorento?

Referências:

[1] - Refactorings in Alphabetical Order
[2] - Google - Agile Methodologies
[3] - Refactoring: Improving the Design of Existing Code - Martin Fowler
[4] - JUnit, Testing Resources for Extreme Programming
[5] - Code Conventions for the Java Programming Language
[6] - Don't Repeat Yourseft
[7] - Making Wrong Code Look Wrong
[8] - Padrões de Nomenclatura - Forum GUJ

valeuz...

De volta a ativa.

2005-11-12T01:55:00.000-03:00

Post, só para avisar que esse blogueiro vai voltar a ativa e escrever suas impressões atuais sobre trabalho, tecnologia, programação, mudanças e outras coisas. Fim desse post.

ps.: Sim, vou tentar fazer Diego Salcedo voltar a escrever aqui também. Especialmente, se conseguirmos escrever juntos, vai ser melhor ainda.

valeuz...

A Dimensão Humana junto às Tecnologias de Comunicação (TC's)

2005-08-20T08:29:00.000-03:00

Será que, em verdade, as TC's são instrumentos auxiliares no aumento da produtividade de trabalho? Gostaria de saber como é medida essa tal de produtividade, principalmente pelas entidades governamentais nordestinas. Alguns investigadores argumentam e fundamentam que a inclusão de TC’s no processo produtivo não acarreta, necessariamente, aumento de produtividade*. Por enquanto concordo com eles.

No setor industrial, no comercial, no mercado informal, no terceiro setor o advento das TC's sugere maior produtividade. Este aspecto do trabalho (produtividade), quando aumenta, acarreta o que, a quem? Segundo relatórios do Departamento de Comércio dos Estados Unidos da América, pelo menos um terço do vigoroso crescimento da economia americana nos últimos 5 anos é explicado pelas tecnologias da informação e comunicação (TICs).

No Brasil, e na América Latina, é o mesmo?

Alguns políticos afirmam, principalmente, no Nordeste que na "sociedade da informação", o recurso escasso não é a infra-estrutura. Esta nós temos (me pergunto aonde existe tal infra???). Além disso, os mesmos afirmam em seus discursos que o recurso fundamental é a mão-de-obra qualificada, e essa nós, também, temos e podemos formar.

Do meu ponto de vista, ou seja, de alguém (acadêmico) que recebe para produzir produto (material e/ou serviços) e não para discursar metáforas ideológicas (políticos), estamos formando:
1 - escravos das tecnologias (estes nós temos - já somos)
2 - mão-de-obra qualificada: nós temos mas, com certeza, uma porcentagem mínima da população.
3 – enquanto formar esta mão-de-obra: tarefa lenta - é só dar uma olhada na situação da educação nordestina – e porque não brasileira???

É bom lembrar que Computação e Física, na UFPE, vão muito bem obrigado. Notas “A” no MEC, alunos premiados pelo mundo afora, professores doutores...enquanto isso na porta dos departamentos vemos pessoas pedindo ajuda para comer um lanche...outros para lavar o carro por R$1,00, (mizero Real).

Classe social dominante “possuir” TC's é classe, luxo, status...é manter o social como está.
Pobre “ter” TC's é tomar iniciativa...endividar-se é inclusão social...ter celular e não saber ler é tornar o "ecossistema" nordestino mais competitivo.

Acredito em ações sociais participativas.

Mas a realidade, nua e crua, das ruas do Recife não condiz com a seguinte afirmação:

"...O que é preciso é uma ação articulada entre governos, empresas e universidades, para garantir um ecossistema competitivo de empresas e instituições de tecnologia da informação em cada grande cidade nordestina [o q sugere ser uma cidade grande? No sentido aqui descrito, ficou entendido referir-se apenas às capitais nordestinas. E o restante?]. Em Pernambuco, o Governo do Estado resolveu investir nessa alternativa, aproveitando a excelente qualificação do Centro de Informática da UFPE, e lançou o projeto Porto Digital. O Governador Jarbas Vasconcelos resolveu investir 33 milhões de reais na criação de fundos de capital de risco e de qualificação de recursos humanos [quem vai qualificar os desqualificados?], além de apoiar a instalação no Bairro do Recife de uma plataforma de negócios capaz de gerar e consolidar empreendimentos de classe mundial [ a classe local, fica a ver navios?] na área de tecnologia da informação".**

Ao lado deste empreendimento tecno-científico, existe a favela mais favela do Estado de Pernambuco [favela do Pilar].

Será que é este tipo de ação política “pública”, que leio nos artigos de estudiosos da Ciência da Informação no país afora que devemos apoiar? De certo, não vejo os mesmos ao menos indagando se houve ou não um planejamento junto às comunidades envolvidas. Não sei onde vamos parar. Enquanto estudante de biblioteconomia não sei se o que vejo, e o que leio, é antagônico ou complementar. Talvez tenha que ler e ver mais. Talvez já baste.

Alguns até podem creer que através das TC's o bibliotecário e/ou o arquivísta possam auxiliar no processo social de inclusão dos desinformados e dos injustiçados. Em verdade, me questiono: até que ponto?

Vejo “todos” (assumo aqui a falácia de generalização) preocupados em conseguir e manter emprego. Vejo muito poucos que querem trabalho.

O último trem está para partir...mas na Estação, faltou Luz.

Ser intelectual é, antes de tudo, resultado da intelectualização do ser. (SALCEDO, 2005).

Diego Salcedo.
Graduando de Biblioteconomia – UFPE

* WAINER, Jacques. O Paradoxo da produtividade. In: RUBEN, Guilhermo (Org.). Informática, organizações e sociedade no Brasil. São Paulo: Cortez, 2003, p. 13-55.

** www.estadao.com.br

Nota sobre: "A inclusão digital não se faz a custa de vitimas".

2005-08-12T15:55:00.000-03:00

Me agradou ver que algumas pessoas, em algum fórum longínquo,
pararam para ampliar o pensamento sobre a tecnociência
(inclua-se bibliotecas digitais) e sua relação com a sociedade.

Outrossim, é bom lembrar que a vitimização humana independe
da inclusão digital. Nós somos vítimas desde que nascemos,
de um modo ou de outro.

Gostei de ler que admite-se a existência de diferentes culturas,
acarretando necessariamente a existência de diferentes
conteúdos digitais, respeitando as biodiversidades sociais.

Por outro lado, ainda me questiono sobre:
O que significa dizer socializar a informação???

Estou, por enquanto, pensando que diante da grande metamorfose
que a Terra e os humanos estão passando, não é tão simples
definir essa questão. Perece que um jargão é desementido
com outro, faltando cautela no pensamento para encontrar um equilibrio.

Vou mais além.

A informação enquanto ente, já possui no seu ser a característica do social.
O que chama a atenção, é como o indivíduo media entre o ser da informação,
suas próprioas necessidades e, como a disponibiliza para os outros (sociedade)???

Segue-se com as reflexões sobre a informação enquanto ente existente
e que, no mínimo, merecem todo tipo de sugestões para ampliar
o conhecimento sobre o assunto.

Acredito que os fonêmas social e democracia, possuem valor representativo
relevante para todos. Mas, talvez, deva-se ter mais "carinho" quanto ao uso
exagerado dessas signifações.

Tudo em exagero, tranforma-se em desperdício (SALCEDO, 2005).

Diego Salcedo
Graduando Biblioteconomia - UFPE

Em resposta...

2005-08-10T20:51:00.000-03:00

Eu e Diego Salcedo por vezes temos idéias bastante parecidas sobre uma série de assuntos. Mas, como conhecimento se desenvolve mais fortemente sobre pontos contrários, questionamentos e a necessidade de se provar, demonstrar o isso ao invés do aquilo, também temos opiniões contrárias. Parece que uma deles é sobre como a pesquisa, especialmente no meio acadêmico, deve ser usada, tema citado nesse post escrito por Diego. Qual o proposito das pesquisas feitas em universidade qualquer? Para que diacho tentamos transformar alunos mais preocupados em tomar umas e outras em cientistas que, ora, além de tomar umas e outras, façam pesquisa séria?

A meu ver, o propósito é aproveitar a inteligência de muita gente para beneficiar tantas outras além do próprio inteligente. E hoje, como se faz, da melhor maneira, a pesquisa chegar até os outros? Por qual meio se faz um "estudo sobre o ciclo de vida dos girinos no interior de Floresta" influenciar positivamente a vida de outras pessoas? De maneira nenhuma, nesse caso, porque, acredite, a pesquisa é inutil até mesmo para os girinos. E é inutil como todo conhecimento que existe por si só, que foi criado com o unico entendimento de... existir por si só. Pesquisa unicamente por pesquisa, descabida de qualquer ligação real com a comunidade não faz sentido. Por outro lado, pesquisas de cunho mais pratico, nascidas e voltadas para alguma necessidade da comunidade, seja ela local ou não, têm sim um meio. Muito bem desenvolvido por sinal, talvez ainda não tanto quando possa ser, especialmente no Brasil.

O meio é o comercio! Não há ainda melhor meio para fazer a pesquisa chegar as pessoas do que comercializando os seus resultados. Claro, tudo não pode ser regido unicamente pela necessidade de empresas, mas nem é esse o assunto. Claro, deve haver pesquisa menos pop, que não gere lucro mas traga muito beneficio para a sociedade, como é o caso do soro caseiro. Não percebi exatamente qual a visão que Diego tem sobre o assunto, mas devem existir alguns pontos contrarios sobre minha opinião. Ótimo! Depois eu escrevo mais sobre o assunto, agora tenho que cuidar de outras coisas.

valeuz...

Comunidade Blastêmica

2005-08-10T19:59:00.000-03:00

O futuro da ciência...

A tecnociência, atualmente tão aclamada, por vezes, une a supervalorização do aspecto aplicado do conhecimento com a desvalorização da pesquisa pura e do conhecimento como um
fim em si mesmo.

O princípio da difusão por toda a sociedade dos produtos teóricos e intelectuais pode, em alguns casos, dar lugar a uma intensa privatização do saber em troca de lucros.

Hoje, em vários setores, é quase impossível separar pesquisa científica de interesses e não se cumprem mais os valores de eqüidade e benefício geral, atributos natos da ciência.

Esse estado de mercantilização pode colocar em risco a ciência, se já não estamos vivendo esse processo.

O ser só é ser, enquanto AÇÃO no ser. (SALCEDO, 2005)

Diego Salcedo
Graduando - Biblioteconomia da UFPE

Bibliotecários e/ou intelectuais...ensaio

2005-08-08T00:06:00.000-03:00

De certo, minimizar os esteriótipos e as categorias redutoras que tanto (de)limitam o pensar e o comunicar humano é papel fundamental que reside no âmago de um ativo intelectual.
Pensava-se que o bibliotecário teria essa incumbência. Não é verdade.
O intelectual, que possui o que Foucault chamou uma vez de "erudição implacável", é dramático ao cativar a atenção do público e insurgente quando aproveita-se de raras oportunidades, como estas, que hoje vivemos no Brasil.
Deve, o intelectual, possicionar-se como indivíduo detentor de um papel público na sociedade, que não usa de um reducionismo facial ou que seja membro participativo de classes egoístas e ociosas. O bibliotecário atual, em sua grande maioria, encontra-se nesta situação, ou seja, esconde-se. Ainda, o intelectual é dotado, quando assim o quer, de uma vocação para representar, dar corpo e articular uma mensagem, uma filosofia, uma opinião baseada em fundamentos éticos e morais.
Onde estão os intelectuais brasileiros, que poderíam e deveríam confrontar as ortodoxias e os dogmas sócio-político-culturais, intrínsecos à atualidade deste imenso Estado-Nação?
Onde está o bibliotecário enquanto ativista e militante brasileiro?
Em Pernambuco, o Governador eliminou a função de bibliotecário do quadro funcional.
Não se viu nota pública de repúdio da classe. Há de se ter muita coragem para tornar uma palavra pública (escrever e publicar), oferecendo ambas as faces em defesa de uma posição, de uma causa. Não existe o intelectual politicamente correto. O que deve existir, é um que cause embaraço, que seja do contra e até mesmo, às vezes, desagradável.
O papel social deste, encontra-se no obejtivo maior e universal de promover a liberdade e o conhecimento. Não sería este também, o papel do bibliotecário???
Ainda pode-se acreditar que "as grandes narrativas de emancipação e esclarecimento" façam efeito nesta era, ao contrário do que acredita o filósofo francês Lyotard.
Para não cansar, os já cansados intelectuais e bibliotecários, deixa-se dito que falar a verdade ao poder não é idealismo panglossiano, outrossim, é pensar com cautela as alternativas, escolher a certa e então representá-la de maneira inteligente e una, onde se possa fazer o maior bem e causar a mudança correta.
Todavia, eternamente, novos paradigmas surgirão.
A metamorfose humana nunca e jamais se exauri do seu ser.

Este, crente de sua função social, sugere como leitura:
"Representações do Intelectual", de Edward W. Said, Cia. das Letras, 2005.

O ser só é ser, enquanto AÇÃO no ser. (SALCEDO, 2005)

Diego Salcedo
Graduando - Biblioteconomia da UFPE

Seja compativel

2005-06-27T15:55:00.000-03:00

Uma das características mais marcantes de produtos de TI bem sucedidos, como em muitas areas e diferente de tantas outras, é que eles trazem um grande diferencial de qualidade em relação aos concorrentes. Claro, depois de certo tempo a tendência é que a concorrência aperte o cerco. Mas, por algum período, cada vez menor, diga-se de passagem, o produto inovador tende a dominar sozinho o mercado. Outro fator bastante importante para o sucesso de um produto de tecnologia da informação é a compatibilidade com produtos de terceiros, geralmente tão competitivos quanto. Alias, compatibilidade é algo que movimenta qualquer setor. Carros agora não são compatíveis apenas com a gasolina, o que aquece o mercado de Álcool e, se eu parar para pensar melhor, creio que chegarei à conclusão de que convergência digital tem futuro justamente por criar compatibilidades: entre a TV e o computador, entre o telefone e o computador, entre o telefone e o cartão de crédito, entre o controle remoto e o abridor de latas, entre a bohemia e corações de galinha bem temperados.

Mas antes que eu elocumbre demais em torno de convergência, deixe-me voltar para o propósito real desse post: a compatibilidade com terceiros garante maior competitividade. Apesar de não ser um conceito novo, parece-me que apenas agora a comunidade open source se deu conta realmente disso e a ideia tem se tornado algo bem mais comum. Assim que cada vez mais frameworks de A trabalham fácil com os de B, C, D e E. E não é apenas uma característica de reuso, é algo além disso. É a compatibilidade pensada antes para aproveitar a popularidade alheia a fim de ganhar competitividade. No mundo Java, não posso deixar de citar o Spring, que surgiu com suporte ao Hibernate, iBatis, Velocity, e por aí vai. Não dá para deixar de citar também o WebWork, prontinho para se aconchegar ao Hibernate, também, Jasper, FreeMarker, Pico e, ora vejam só, Spring. Cada vez mais frameworks seguem esse caminho. Até Java por si só nasceu assim: run anywhere. Quer compatibilidade maior?

Fora isso, vale citar a movimentação do mercado em torno de se permitir funcionar no Linux, MacOS, FreeBSD e não apenas no Windows. Só para lembrar, compatibilidade foi o que fez o Windows ir além dos Mac OS da vida, ao menos quando o assunto é mercado. Abrir as APIs e deixar que os fabricantes de softwares fizessem, mais fácil e rapidamente, programas Windows, foi crucial. Agora, um pouco do esforço, proporcional a sua popularidade, se volta para o Linux. O problema é que, aparentemente, a historia do Linux caminha no sentido oposto, o de criar tantas distribuições a ponto de criar incompatibilidades. Tomara que o "pai" do software livre aprenda algo que "filhos" que estão nascendo sabem de cor. E agora o outro lado da moeda. Criar incompatibilidades para promover inovação. Não exatamente isso, mas, pense bem, para que diacho adotar um padrão se ele simplesmente não é bom? Não faz sentido e as grandes empresas perceberam isso e tomaram atitudes de criar comitês, laboratórios ou projetos comuns para desenvolver padrões de acordo com o mercado que nem sempre segue as regras definidas pelo W3C, só para exemplificar.

Um fato talvez não tão claro a primeira vista é que, geralmente, vc precisa ser uma empresa com uma boa, mas muito boa mesmo, fatia do mercado para criar uma incompatibilidade. Por exemplo, a Microsoft lançou o Windows XP e ele simplesmente era incompativel com muitos produtos, em especial hardware ainda presentes no mercado. Muitos usuarios reclamaram, entretanto, ninguem duvida que o Windows XP é hoje o sistema operacional desktop mais usado e se duvida, deve ser por picuinha. Fora a movimentação de mercado dos fabricantes de hardware e software para se adequarem ao novo modelo e se manterem compativeis com um produto de sucesso. Enfim, a Microsoft podia se dar ao luxo de fazer algo assim porque está acima no mercado, pode ditar regras, mesmo que pareçam arbitrarias. Agora, tome o caso da AMD, porque o chip de 64bits não emplacou tão rapidamente quanto o XP? Se eu desconsiderar as diferenças entre um processador e um sistema operacional, simples, a lider de mercado, com boa folga, é outra empresa, a Intel e AMD se vê em uma curva S de adoção que sequer pode chegar ao fim. A Intel como boa conhecedora já aposta em outros aspectos ligados a convergencia digital e compatibilidade com terceiros, vide novo acordo com a Apple.

valeuz...

Irretocável

2005-06-22T14:12:00.000-03:00

Ouça!

valeuz...

Ruby on Rails: embasbacante!

2005-06-17T18:28:00.000-03:00

Se vc trabalha com desenvolvimento web, e mesmo depois de ver esse video sobre o Ruby on Rails não quiser experimentar um pouco do treco é bom procurar algum tratamento psiquiatrico! O video tem duração de ~10 minutos e vale cada um deles pela praticidade demonstrada. O cara cria um mini weblog em duas(!) classes e um pequeno HTML. Muito legal mesmo.

valeuz...

Suggest com o Lucene II

2005-06-14T15:46:00.000-03:00

Como vcs viram em um post passado, desenvolvi um pequeno esquema para realizar suggests com o Lucene. Agora eu finalmente terminei e coloquei para funcionar em um dos sistemas em que trabalhei recentemente. É incrivel como o Lucene permite desenvolver coisas interessantes sem muita complexidade, realmente simplicidade é uma vantagem forte dessa api. Vamos lá, primeiro eu refatorei a classe Suggest para guardar tanto a palavra original quanto a sugestão e o numero de ocorrências da tal sugestão. O resultado final é:

public class Suggest implements Comparable<Suggest> {

    private String suggest;
    private String original;
    private int occurrences;

    /**
     * @param suggest
     * @param original
     * @param occurrences
     */
    public Suggest ( String suggest, String original, int occurrences ) {

        this.suggest = suggest;
        this.original = original;
        this.occurrences = occurrences;
    }

    /**
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals( Object obj ) {

        boolean result = false;

        if (obj instanceof Suggest) {

            Suggest s = (Suggest) obj;

            String sWord = s.suggest.toLowerCase();
            String thisWord = suggest.toLowerCase();

            result = sWord.equals(thisWord) && occurrences == s.occurrences;

        }

        return result;
    }

    /**
     * @see java.lang.Object#hashCode()
     */
    public int hashCode() {

        return suggest.toLowerCase().hashCode() * occurrences;

    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {

        return suggest + " - " + occurrences;

    }

    /**
     * @param other
     * @return
     * @see java.lang.Comparable#compareTo(T)
     */
    public int compareTo( Suggest other ) {

        return other.occurrences - occurrences;

    }

    // somente gets, o objeto é immutable

}

Ter a palavra original é interessante porque a partir dela posso saber se houve mesmo uma sugestão ou não. Quando trato de uma palavra simples isso não chega a ser necessário, mas no caso de frases, é importante para que eu destaque apenas as sugestões e não todas as palavras presentes em uma consulta. Tambem refatorei algumas partes da classe Suggestor para evitar que ele sugerisse a propria palavra, fiz algumas pequenas melhorias na performance, sugestões para frases e as adaptações simples decorrentes do refactoring de Suggest. O bom da historia foi ver as classes clientes de Suggestor funcionarem perfeitamente depois disso tudo. Enfim, o novo codigo de Suggestor é:

public class Suggestor {

    /**
     *
     */
    public static final String PUNCTUATION_SPLITER = "[\\p{Punct}\\s]+";

    private static final Log logger = LogFactory.getLog(Suggestor.class);

    private Directory lucenePath;
    private Analyzer analyzer;
    private float minSimilarity = FuzzyQuery.defaultMinSimilarity;

    /**
     * @param path
     * @param analyzer
     * @param similarity
     */
    public Suggestor ( Directory path, Analyzer analyzer, float similarity ) {

        lucenePath = path;
        minSimilarity = similarity;
        this.analyzer = analyzer;
    }

    /**
     * @param path
     * @param analyzer
     * @param similarity
     * @throws IOException
     */
    public Suggestor ( Resource path, Analyzer analyzer, float similarity )
            throws IOException {

        this(FSDirectory.getDirectory(path.getFile(), false), analyzer, similarity);

    }

    /**
     * @param word
     * @param field
     * @return
     */
    public List<Suggest> suggestsByFrequency( String word, String field ) {

        List<Suggest> suggests = suggestsBySimilarity(word, field);

        Collections.sort(suggests);

        return suggests;

    }

    /**
     * @param word
     * @param field
     * @param maxSuggestions
     * @return
     */
    public List<Suggest> suggestsByFrequency( String word, String field,
            int maxSuggestions ) {

        List<Suggest> suggests = suggestsByFrequency(word, field);

        suggests = chopList(maxSuggestions, suggests);

        return suggests;

    }

    /**
     * @param word
     * @param field
     * @param maxSuggestions
     * @return
     */
    public List<Suggest> suggestsBySimilarity( String word, String field,
            int maxSuggestions ) {

        List<Suggest> suggests = suggestsBySimilarity(word, field);

        suggests = chopList(maxSuggestions, suggests);

        return suggests;

    }

    /**
     * @param word
     * @param field
     * @return
     * @throws IOException
     */
    public List<Suggest> suggestsBySimilarity( String word, String field ) {

        IndexReader reader = null;
        List<Suggest> suggests = new ArrayList<Suggest>();

        try {

            synchronized (LuceneMonitor.LUCENE_MONITOR) {

                reader = IndexReader.open(lucenePath);
                Term term = new Term(field, word);

                FuzzyTermEnum termEnum;
                termEnum = new FuzzyTermEnum(reader, term, minSimilarity);

                suggests = termEnumToList(word, termEnum);

            }

        } catch (IOException ex) {

            throw new LuceneIndexException(ex);

        } finally {

            try {

                if (reader != null) reader.close();

            } catch (Exception ex) {

                if (logger.isDebugEnabled()) {

                    logger.debug("Could not close reader", ex);

                }
            }

        }

        filterSuggests(suggests, word);

        return suggests;

    }

    private void filterSuggests( List<Suggest> suggests, String word ) {

        Predicate predicate = new AvoidWordItseltPredicate(word);
        CollectionUtils.filter(suggests, predicate);

    }

    /**
     * @param phrase
     * @param field
     * @return
     */
    public List<Suggest> phrasalSuggest( String phrase, String field ) {

        List<Suggest> suggests = new ArrayList<Suggest>();

        IndexReader indexReader = null;
        TokenStream tokenStream = null;

        try {

            Reader reader = new StringReader(phrase);
            tokenStream = analyzer.tokenStream(field, reader);

            synchronized (LuceneMonitor.LUCENE_MONITOR) {

                indexReader = IndexReader.open(lucenePath);

                Token token;
                while ((token = tokenStream.next()) != null) {

                    Term term = new Term(field, token.termText());

                    FuzzyTermEnum termEnum;
                    termEnum = new FuzzyTermEnum(indexReader, term, minSimilarity);

                    List<Suggest> temp = termEnumToList(token.termText(), termEnum);

                    if (!temp.isEmpty()) {

                        suggests.add(Collections.min(temp));

                    }
                }
            }

        } catch (IOException ex) {

            throw new LuceneIndexException(ex);

        } finally {

            try {

                if (indexReader != null) indexReader.close();

            } catch (IOException ex) {

                if (logger.isDebugEnabled()) {

                    logger.debug("Could not close reader", ex);

                }

            }

        }

        filterSuggests(suggests, phrase);

        return suggests;

    }

    private List<Suggest> termEnumToList( String word, TermEnum termEnum )
            throws IOException {

        List<Suggest> suggests = new ArrayList<Suggest>();

        while (termEnum.next()) {

            Term term = termEnum.term();

            String termValue = term.text();
            int frequency = termEnum.docFreq();

            suggests.add(new Suggest(termValue, word, frequency));

        }

        return suggests;
    }

    private List<Suggest> chopList( int maxSuggestions, List<Suggest> suggests ) {

        if (suggests.size() > maxSuggestions) {

            suggests = suggests.subList(0, maxSuggestions);

        }

        return suggests;
    }

    /**
     * @author Marcos Silva Pereira - marcos.pereira@vicinity.com.br
     *
     *
     * @since 24/05/2005
     * @version $Id$
     */
    static class AvoidWordItseltPredicate implements Predicate {

        private Set words;

        /**
         * @param words
         */
        public AvoidWordItseltPredicate( String words ) {

            this(makeSet(words));

        }

        /**
         * @param words
         */
        public AvoidWordItseltPredicate( Set words ) {

            this.words = words;

        }

        /**
         * @see org.apache.commons.collections.Predicate#evaluate(java.lang.Object)
         */
        public boolean evaluate( Object obj ) {

            boolean result = false;

            if (obj instanceof Suggest) {

                Suggest suggest = (Suggest) obj;
                String word = suggest.getSuggest().toLowerCase();

                result = !words.contains(word);
            }

            return result;

        }

        private static Set makeSet( String words ) {

            Set<String> set = new HashSet<String>();

            String[] strings = words.split(PUNCTUATION_SPLITER);

            for (String string : strings) {

                set.add(string.toLowerCase());

            }

            return set;
        }

    }
}

O metodo phrasalSuggests usa o Analyzer para parsear as palavras e evitar que eu tente fazer sugestões para stop words, por exemplo. AvoidWordItseltPredicate é uma implementação simples de Predicate, interface do Jakarta Commons Collections, e é ele quem filtra o conjunto de sugestões para evitar que a propria palavra seja sugerida. Alteradas essas classes, criei uma helper para gerar codigo HTML a partir de uma frase e seu conjunto de sugestões, nada demais como vc pode ver abaixo:

public class HTMLPhrasalSuggest {

    /**
     *
     */
    private HTMLPhrasalSuggest () {

        // private constructor to avoid instantiation...
    }

    /**
     * @param phrase
     * @param suggests
     * @param tag
     *
     * @return
     */
    public static String htmlPhrasalSuggest( String phrase,
            List<Suggest> suggests, String tag ) {

        StringBuilder result = new StringBuilder();

        String[] wordsInPhrase = phrase.split(Suggestor.PUNCTUATION_SPLITER);

        int i = 0;
        for (String string : wordsInPhrase) {

            if (hasSuggest(string, suggests)) {

                result.append(openTag(tag));
                result.append(suggests.get(i++).getSuggest());
                result.append(closeTag(tag));

            } else {

                result.append(string);

            }
           
            result.append(" ");

        }

        return result.toString().trim();

    }

    /**
     * @param phrase
     * @param suggests
     * @return
     */
    public static String phrasalSuggest( String phrase, List<Suggest> suggests ) {

        StringBuilder result = new StringBuilder();

        String[] wordsInPhrase = phrase.split(Suggestor.PUNCTUATION_SPLITER);

        int i = 0;
        for (String string : wordsInPhrase) {

            if (hasSuggest(string, suggests)) {

                result.append(suggests.get(i++).getSuggest());

            } else {

                result.append(string);

            }
           
            result.append(" ");

        }

        return result.toString().trim();

    }

    private static boolean hasSuggest( String word, List<Suggest> suggests ) {

        boolean result = false;

        for (Suggest suggest : suggests) {

            if (suggest.getOriginal().equalsIgnoreCase(word)) {

                result = true;
                break;

            }

        }

        return result;

    }

    private static String openTag( String tag ) {

        return "<" + tag + ">";

    }

    private static String closeTag( String tag ) {

        return "</" + tag + ">";

    }

}

No metodo privado hasSuggest dá para ver a utilidade de guardar a palavra original. Se ela está presente no conjunto de sugestões, é porque houve uma sugestão para ela. Por exemplo, "jakarta luceni" vai gerar um conjunto de sugestões apenas com "lucene" já que "jakarta" está grafada corretamente. E por fim, o uso dessa tralha toda é feito via uma tag que criei baseado no suporte do WebWork com OGNL e tudo mais:

public class LuceneSuggestTag extends WebWorkTagSupport {

    private String query;
    private String field;
    private String url;
    private String tag;

    private Suggestor suggestor;

    /**
     * @see javax.servlet.jsp.tagext.BodyTagSupport#doEndTag()
     */
    public int doEndTag() throws JspException {

        try {

            List<Suggest> suggests = suggestor.phrasalSuggest(query, field);
           
            String htmlSuggest;
            htmlSuggest = HTMLPhrasalSuggest.htmlPhrasalSuggest(query, suggests, tag);
           
            String textSuggest;
            textSuggest = HTMLPhrasalSuggest.phrasalSuggest(query, suggests);

            StringBuilder toShow = new StringBuilder();
            toShow.append("<a href=\"").append(url).append(textSuggest);
            toShow.append("\">").append(htmlSuggest).append("</a>");
           
            Writer writer = pageContext.getOut();           
            writer.write(toShow.toString());

        } catch (Exception ex) {
           
            throw new JspException(ex.getMessage(), ex);
           
        }

        return EVAL_PAGE;
    }

    /**
     * @see javax.servlet.jsp.tagext.BodyTagSupport#doStartTag()
     */
    public int doStartTag() throws JspException {

        try {
           
            ServletContext servletContext = pageContext.getServletContext();

            suggestor = (Suggestor) servletContext.getAttribute("luceneSuggestor");
           
            query = String.valueOf(getStack().findValue(query, String.class));
            field = String.valueOf(getStack().findValue(field, String.class));

            return SKIP_BODY;

        } catch (Exception ex) {

            throw new JspException(ex.getMessage(), ex);

        }
    }

    // sets e gets para os atributos.

}

E o uso, no meu caso numa jsp:

<%@ taglib prefix="ww" uri="webwork" %>
<%@ taglib prefix="lucene" uri="lucene" %>

...

<lucene:suggest field="'PageText'" query="query" tag="em" url="Search.pc?query=">

...

Agora, coisas que preciso melhorar:
1. Evitar que a view precise indicar o campo a ser buscado para as suggests (PageText);
2. Suggests para palavras coladas (comunidadeblastemica -> comunidade blastemica);
3. Tornar a tag library compativel com o metodo POST do HTTP;
4. Escapes para HTML e evitar que algum mal intencionado envie queries como <javascript bla bla bla>

É isso, sugestões e comentarios são muito bem vindos.

valeuz...

Qualidade importa

2005-06-09T19:18:00.000-03:00

Um argumento recorrente de quem não tem tanta preocupação com qualidade de software em geral é: "O cliente não quer saber dos padrões e métricas usados, quer que funcione e pronto". Isso é mais do que verdade, até porque, para boa parte dos clientes, não faz sentido explicar como os padrões do GoF, por exemplo, ajudam, quando usados de acordo, a gerar software de maior qualidade. Os clientes geralmente querem que os requisitos sejam cumpridos dentro de prazos e custos e não que se use o mais novo e balado framework. Mais ainda, apenas em casos que implicam manter compatibilidade, os clientes se preocupam com as tecnologias usadas no desenvolvimento.

Apesar de o argumento parecer extremamente lógico para boa parte dos casos, ele não é verdadeiro quando você olha para outro aspecto envolvido: a "empresa" que desenvolve. Em tempos de prazos cada vez mais apertados, desenvolver software sem se preocupar com seu futuro pode manter a empresa amarrada a um problema muito além do tempo necessário. É o típico caso de haver tempo para fazer duas (ou mais) vezes, mas não haver para fazer uma vez bem feita. Há, a meu ver, dois grandes problemas com software mal desenvolvido que, de uma maneira ou outra, irão criar outro conjunto de problemas. São eles:

1. Você passará muito tempo literalmente remendando erros e, provavelmente, criando outros. Isso toma parte da força de trabalho para algo que simplesmente não gera o lucro esperado se a gama de usuários for pequena. Para grandes empresas os custos para consertar o problema podem ser altos não apenas pelo conserto em si mas também para a marca, a percepção que as pessoas têm do produto ou empresa. Que o diga a Microsoft com o grande numero de service packs e com a falta de credibilidade que permeou o Windows por um bom tempo. E, pode acreditar, se você não tem qualidade ou credibilidade, alguém terá. No fim das contas, qualquer pessoa envolvida seriamente com qualidade, sabe que manutenção toma mais tempo do que desenvolvimento. Isso é fato e nos leva ao seguinte: bom desenvolvimento leva a um período de manutenções mais leves;

2. Outros projetos são afetados pela falta de qualidade do primeiro. Em especial, se algo não foi bem feito, provavelmente não será reusado, se for, o problema apenas aumenta já que temos uma propagação do erro. Se não é possível reusar, o tempo para desenvolvimento de novos projetos certamente crescerá e o retrabalho causado pela falta de reuso causará uma série de horas extras e daí para frente vc pode imaginar sozinho. Falta de reuso gera outro problema menos explicito que é o aumento na quantidade de erros e código a corrigir/refatorar;

Projetos com qualidade, por outro lado, têm, claro, uma série de aspectos positivos para a empresa e no fim das contas para os clientes. Para emparelhar com os problemas acima e ser um pouco chato, vou citar os mais óbvios e importantes:

1. Não passar meses corrigindo erros tem uma vantagem além da economia de tempo e dinheiro. Com bons produtos as chances de feedback e adesão de novos clientes crescem. Bom feedback é crucial para o amadurecimento não apenas do produto mas da empresa em si. Bom feedback lhe direciona para as necessidades mais importantes do cliente, lhe permite desenvolver funcionalidades não pensadas ou conhecidas antes e, então, estar hábil a conquistar novos clientes. Novos clientes, mais do que apenas mais grana, implicam mais popularidade, fortalecimento da marca e amadurecimento, agora especialmente da empresa que já pode pensar em lançar novos produtos com uma legenda do tipo "dos mesmos produtores de bla bla bla...";

2. Os tipos de vantagem trazidos pelo reuso são geralmente claras, imagine iniciar um projeto com 20% de código pronto, bonitinho. Mas, mais ainda, quando vc reusa código, percebe pontos nos quais ele pode melhorar, o contato mais freqüente lhe faz pensar sobre melhorias possíveis. É menos codigo para testar/corrigir/refatorar tambem. Sem reuso seu codigo/produto simplesmente não evolui e, novamente, daqui para frente vc pode imaginar sozinho.

Para finalizar, ficam algumas dicas simples:

1. Planeje! Mesmo planejamento mínimo é melhor do que nenhum e até metodologias ágeis como XP têm etapas para planejar o jogo. Planejamento geralmente passa por decidir escopo, atividades, como usar tempo e recursos disponíveis entre outras coisas, qualquer bom livro de gerenciamento de projetos explica como planejar. Depois, decidir e justificar, não se esqueça, quais tecnologias usar. Justificar lhe ajuda a fundamentar a escolha e evitar mudanças desnecessárias no decorrer do desenvolvimento;

2. Defina metas de qualidade reais baseadas nos recursos e tempo disponíveis. Metas irreais criarão atrasos e frustrações desnecessárias. Lembre-se da filosofia de não tentar "tirar leite de pedra". Tente criar metas gerais e, dentro destas, metas menores que devem ser alcançadas em etapas. Assim fica mais fácil...

3. ... controlar a qualidade, o que significa criar padrões e convenções a serem seguidas e verificar de maneira efetiva se são seguidas. Uma "convenção" interessante são testes. Obrigue-se a escrever testes. Só essa dica já daria para escrever outro post, testes praticamente gritam: "ei, isso aqui funciona".

4. Revise e tente fazer o codigo evoluir entre um projeto e outro. Só siga essa dica se vc seguir a 3 também. Procure identificar pontos fracos no código, pontos onde há tendencias de se usar um padrão e refatorar o que conseguir identificar. Uma boa maneira de se fazer isso é usar algumas ferramentas de inspeção de codigo como o PMD, Findbugs, Metrics e Checkstyle.

5. Faça todos os envolvidos pensarem em qualidades para não ocorrerem dissiparidades em partes do projeto. Mesmo que todos não estejam no mesmo nivel de conhecimento, boa comunicação entre os desenvolvedores pode garantir ou ao menos diminuir as chances de os menos experientes cometerem erros.

valeuz...

Suggest com o Lucene

2005-05-23T14:21:00.000-03:00

Um recurso bastante interessante nos mecanismos de busca mais sofisticados é o de sugestões. Funciona assim: você, usuário, digita algo errado e o mecanismo lhe sugere a palavra correta. Ou, em alguns outros casos, sugere outra palavra parecida com a que digitada mas com um numero maior de resultados. Algo como sugerir "lucene" se você digitar "luceni". Criar um mecanismo de sugestão com o Lucene é algo bastante simples. A maior parte da complicação está em definir se a estratégia trará as palavras mais parecidas ou as palavras parecidas com maior numero de resultados. Outro aspecto considerado é o quanto as palavras devem ser parecidas, ou seja, o grau de similaridade entre elas. No Lucene esse grau varia entre no intervalo [0,1] e o valor default é 0.5. Geralmente ambas as decisões são tomadas depois de alguns testes para verificar qual abordagem melhor se adequa ao seu caso, mas, para o grau de similaridade, quanto menor a base de índices, menor deve ser o grau mínimo requerido, já que não há muitas palavras a disposição. Feitas as escolhas, vamos a um exemplo simples. Criamos uma classe Suggest que encapsulará os dados, palavra e quantidade de resultados, de uma sugestão:


public class Suggest implements Comparable<Suggest> {

   private String word;
   private int occurrences;

   /**
    * @param word
    * @param occurrences
    */
   public Suggest ( String word, int occurrences ) {

      this.word = word;
      this.occurrences = occurrences;
   }

   /**
    * @see java.lang.Object#equals(java.lang.Object)
    */
   public boolean equals( Object obj ) {

      boolean result = false;

      if (obj instanceof Suggest) {

         Suggest suggest = (Suggest) obj;

         String sWord = suggest.word.toLowerCase();
         String thisWord = word.toLowerCase();

         result = sWord.equals(thisWord)
               ∧∧ occurrences == suggest.occurrences;

      }

      return result;
   }

   /**
    * @see java.lang.Object#hashCode()
    */
   public int hashCode() {

      return word.toLowerCase().hashCode() * occurrences;
     
   }

   /**
    * @see java.lang.Object#toString()
    */
   public String toString() {

      return word + " - " + occurrences;
     
   }

   /**
    * @param other
    * @return
    * @see java.lang.Comparable#compareTo(T)
    */
   public int compareTo( Suggest other ) {

      return other.occurrences - occurrences;

   }

   /**
    * @return Returns the occurrences.
    */
   public int getOccurrences() {

      return occurrences;
   }

   /**
    * @return Returns the word.
    */
   public String getWord() {

      return word;
   }
}

A classe é Comparable para permitir a ordenação de acordo com o numero de documentos nos quais o termo procurado aparece. E agora a classe que cria as sugestões a partir do seu índice:


import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermEnum;
import org.apache.lucene.search.FuzzyQuery;
import org.apache.lucene.search.FuzzyTermEnum;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;


/**
 * @author Marcos Silva Pereira - marcos.pereira@vicinity.com.br
 *
 *
 * @since 21/05/2005
 * @version $Id$
 */
public class Suggestor {

   private Directory lucenePath;
   private Analyzer analyzer;
   private float minSimilarity = FuzzyQuery.defaultMinSimilarity;

   /**
    * @param path
    * @param analyzer
    * @param similarity
    */
   public Suggestor ( Directory path, Analyzer analyzer, float similarity ) {

      lucenePath = path;
      minSimilarity = similarity;
      this.analyzer = analyzer;
   }

   /**
    * @param word
    * @param field
    * @return
    */
   public List<Suggest> suggestsByFrequency( String word, String field ) {

      List<Suggest> suggests = suggestsBySimilarity(word, field);

      Collections.sort(suggests);

      return suggests;

   }

   /**
    * @param word
    * @param field
    * @param maxSuggestions
    * @return
    */
   public List<Suggest> suggestsByFrequency( String word, String field,
         int maxSuggestions ) {

      List<Suggest> suggests = suggestsByFrequency(word, field);

      suggests = chopList(maxSuggestions, suggests);

      return suggests;

   }

   /**
    * @param word
    * @param field
    * @param maxSuggestions
    * @return
    */
   public List<Suggest> suggestsBySimilarity( String word, String field,
         int maxSuggestions ) {

      List<Suggest> suggests = suggestsBySimilarity(word, field);

      suggests = chopList(maxSuggestions, suggests);

      return suggests;

   }

   /**
    * @param word
    * @param field
    * @return
    * @throws IOException
    */
   public List<Suggest> suggestsBySimilarity( String word, String field ) {

      IndexReader reader = null;

      try {

         List<Suggest> suggests;

         reader = IndexReader.open(lucenePath);
         Term term = new Term(field, word);

         FuzzyTermEnum termEnum;
         termEnum = new FuzzyTermEnum(reader, term, minSimilarity);

         suggests = termEnumToList(termEnum);

         return suggests;

      } catch (IOException ex) {

         throw new SuggestException(ex);

      } finally {

         try {

            if (reader != null)
               reader.close();

         } catch (Exception ex) {

            // TODO log this exception...
         }

      }

   }

   /**
    * @param phrase
    * @param field
    * @return
    */
   public List<Suggest> phrasalSuggest( String phrase, String field ) {

      List<Suggest> suggests = new ArrayList<Suggest>();

      TokenStream tokenStream = null;
     
      try {
        
         Reader reader = new StringReader(phrase);
         tokenStream = analyzer.tokenStream(field,  reader);
        
         Token token;
         while((token = tokenStream.next()) != null) {
           
            String tokenText = token.termText();
            List<Suggest> temp = suggestsByFrequency(tokenText, field, 1);
           
            if(!temp.isEmpty()) {
              
               suggests.addAll(temp);
              
            }
           
         }
        
      } catch (IOException ex) {
        
         throw new SuggestException(ex);
        
      } finally {
        
         try {
           
            if(tokenStream != null) tokenStream.close();
           
         } catch (IOException ex) {
           
            // TODO Logger this exception
           
         }
        
      }

      return suggests;

   }

   private List<Suggest> termEnumToList( TermEnum termEnum )
         throws IOException {

      List<Suggest> suggests = new ArrayList<Suggest>();

      while (termEnum.next()) {

         Term term = termEnum.term();

         String termValue = term.text();
         int frequency = termEnum.docFreq();

         suggests.add(new Suggest(termValue, frequency));

      }

      return suggests;
   }

   private List<Suggest> chopList( int maxSuggestions, List<Suggest> suggests ) {

      if (suggests.size() > maxSuggestions) {

         suggests = suggests.subList(0, maxSuggestions);

      }

      return suggests;
   }
}

Os métodos suggestBySimilarity trazem as palavras mais parecidas com a buscada e não se preocupam com o numero de documentos com os quais o termo buscado está relacionado. Já os métodos suggestsByFrequency trazem primeiro as palavras parecidas e com maior numero de documentos. Nesse caso, o numero de documentos é determinante e a similaridade é usada apenas para retornar o conjunto de palavras. Infelizmente o Lucene não provê o grau de similaridade para que se pudesse criar uma media entre esse grau e o numero de documentos. O método phrasalSuggest gera um conjunto de sugestões baseado na frase indicada. Um analyzer é usado para que as palavras da consulta sejam tratadas do mesmo modo que são para a busca. Assim, stop words, palavras descartadas por serem muito comuns, não receberão uma sugestão e daí por diante. Usar a classes Suggestor nas classes clientes é bastante simples. Em uma action do WebWork, por exemplo, bastaria fazer algo como a seguir:


public class ActionSearch extends ActionSupport {

   private Suggestor suggestor;
   private List<Suggest> suggests;

   private List searchResult;
   private String query;

   /**
    * @return Action execute status
    */
   public String findByText() {

      String result = Action.ERROR;

      try {

         // abstraia a busca, afinal o foco está em como fazer as sugestões
         this.searchResult = Mystical.doSearch(query);

         // recuperando conjunto de sugestões.
         this.suggests = suggests();

         result = Action.SUCCESS;

      } catch (Exception e) {

         addActionError("Erro ao realizar a busca: " + e.getMessage());

      }

      return result;

   }
  
   private List<Suggest> suggests() {
     
      List<Suggest> suggestions = new ArrayList<Suggest>();
     
      try {
        
         // pode acreditar, a classe Mystical faz um café de primeira
         suggestions = suggestor.suggestsByFrequency(query, Mystical.FIELD_TO_SEARCH, 2);
        
      } catch (Exception e) {
        
         // TODO logger this exception
        
      }
     
      return suggestions;
     
   }
  
   // gets and sets

}

O método suggests foi criado para realizar o tratamento de exceções, ou seja, se a recuperação das sugestões lançar alguma exception, a busca é feita, como é de se esperar. As sugestões ficam então disponíveis para serem usadas na pagina que mostra o resultado da busca. Por fim, os códigos acima estão sendo desenvolvidos para o projeto JavaBB e não demora a estarem disponíveis (sem mágicas, ou quase) no CVS do projeto. Até lá!

valeuz...

Lucene e Compass

2005-05-10T18:00:00.000-03:00

O meu esquema de criar anotações para o Lucene ficou quase sem sentido quando descobri o Compass, uma biblioteca que usa uma especie de mapeamento de campos de um objeto para campos do Lucene. Quase porque ele usa XML, num esquema parecido com o Hibernate, para realizar o mapeamento e isso é algo que eu gostaria muito de evitar. Fora isso, o Compass possui um esquema de Template e Callback bastante familiar para quem já tentou usar o Spring. Penso seriamente em ajudar no desenvolvimento do projeto, em especial, criar interceptors para tornar o compass menos intrusivo quando usado com o Spring, anotações baseadas na DTD deles e quem sabe um modulo XDoclet, só para manter o projeto compativel com versões antigas do Java.

O dificil até agora tem sido entrar em contato com os desenvolvedores. Simplesmente não consegui assinar a lista de desenvolvedores. Vou tentar contato direto com o lider do projeto e ver como posso ajudar.

valeuz...

Anotações no Tiger

2005-04-20T15:18:00.000-03:00

Comecei a usar com mais força alguns recursos do Tiger, a nova versão de Java, e apesar de à primeira vista algumas coisas terem jeitão de sugar syntax, a maioria das inovações deixou a linguagem bem mais prática. O loop for a lá foreach é um exemplo disso porque não chega a inovar, mas apenas melhorar, iterações sobre arrays ou coleções de objetos. Lembro que quando comecei a programar em Java eu detestava ter que fazer algo assim:

List objects = ...
...
Iterator iterator = objects.iterator();
while(iterator.hasNext()) {
Something some = (Something)iterator.next();
...
}

Claro, depois que descobri a maneira "correta" de se fazer isso era:

List objects = ...
...
for(Interator it = objects.iterator();it.hasNext();) {
Something some = (Something)iterator.next();
...
}

Não chega a ser tão diferente do while, e também, não tem a legibilidade de um foreach:

List objects = ...
for(Something some: objects) {
...
}

Bem melhor, não?! Mas, até agora a feature que tem sido mais útil para mim são annotations. Poder dar a uma classe, metodo, atributo, parametro, whatever mais informações do que apenas um nome e tipo é algo extremamente poderoso. Agora, por exemplo, estou trabalhando em um pequeno conjunto de anotações que me permita traduzir atributos de uma classe para campos de um documento do Lucene. Já havia feito algo semelhante com reflexão apenas, mas o treco fica tão genérico que chega a não valer a pena já que trato todos os atributos de maneira completamente uniforme. Decidi então criar a seguinte anotação:

@Documented
@Target( ElementType.FIELD )
@Retention( RetentionPolicy.RUNTIME )
public @interface LuceneField {

String name();
boolean index() default true;
boolean store() default false;
boolean tokenize() default true;
float boost() default 1.0f;

}

Com ela posso descrever os atributos de uma classe num nível de granularidade impossível de ser alcançado apenas com reflection. Para exemplificar, vejamos a seguinte classe:

public class People implements Serializable {

@LuceneField(index=true,
  tokenize=false,
  store=true,
  name="peopleid")
private Long id;

@LuceneField(index=true,
  tokenize=true,
  store=true,
  name="peopleName")
private String name;

@LuceneField(index=true,
  tokenize=false,
  store=true,
  name="peopleEmail")
private String email;

// some stuff

}

Depois, uma helper class traduz objetos dessa classe e de qualquer outra que use as anotações para um Document. Bem legal e relativamente fácil de implementar. Há ainda outras anotações, mas eu mostro depois quando a idéia estiver mais amadurecida. Para escrever essa tralha toda baixei o Eclipse3.1M6 que também tem boas novidades e as incompatibilidades de sempre com plugins feitos para a versão anterior. Por falar em forward/backward compatibility, esse é um dos problemas com o código atual que estou produzindo, nem adianta MESMO tentar usar em uma versão anterior do Java. De qualquer modo, como estou em um ambiente muito controlado, não vale a pena esperar (mais ainda) para usar as novas features em aplicações reais.

valeuz...

dois mil anos de invenções.

2005-04-14T10:19:00.000-03:00

"Qual é a mais importante invenção dos últimos dois mil anos?" Essa é a pergunta que uma série de "cientistas da terceira cultura" ligados ao EDGE tentaram responder e deu origem ao livro "As Maiores Invenções dos Últimos 2000 Anos". Há algumas sugestões bastante peculiares como "a borracha de apagar", "a musica clássica ocidental" e outras. Ainda, detalhes interessantes como alguns darem sugestões completamente desligadas a area em que atual. Mas há também, respostas que indicam invenções mais ao alcance de todos, como a televisão, a imprensa e a Internet. E minha resposta para a pergunta passa por essas três ultimas. Para mim, a mais importante invenção dos últimos dois mil anos tem raízes em um espaço de tempo maior do que o proposto pela pergunta e não se trata de um objeto ou máquina, mas sim de um conceito. E a resposta é a "divulgação da informação" que, notadamente, surgiu, talvez por instinto ou não, nas pinturas rupestres. Alguns antropólogos e arqueólogos vêem as pinturas rupestres não como uma maneira de divertimento ou arte e sim como um registro das atividades e métodos para, por exemplo, realizar caçadas e rituais. É bem natural que o homem tenha percebido que era bem mais interessante registrar como se caça, como o fogo surge, ou como os rituais eram feitos do que ensinar tudo de maneira tácita.

E depois, a necessidade de transmitir informação se desenvolveu das paredes para os papiros, destes até chegar ao papel, e da escrita à mão até à imprensa de Gutenberg. E aí, a imprensa deu velocidade antes não imaginada a capacidade de divulgar informação. Ora, prensar livros em série ao invés de escrevê-los é algo infinitamente mais prático por uma série de motivos óbvios. Depois de todas as evoluções feitas à técnica, impressão em jornais, melhores papéis, impressão à cores, surge outro meio de informação: a tv! Claro, antes outros, o rádio e o telegrafo, mas nenhum com poderes próximos ao da televisão. E não conseguiriam, não com a televisão dando capacidade de ver e ouvir ao mesmo tempo, atingindo mais sentidos, o impacto do assistir, de ver, afinal, "o que eu escuto, eu esqueço; o que eu vejo, eu lembro". E eis que a velocidade para fazer a informação circular cresce em curva vertiginosa novamente. Com ela, a TV, foi possível saber, ver, alias, o que se passava em outros cantos do planeta. E criou-se, a meu ver, efetivamente, o que Pierre Levi chama de desterritorialização, você não pensa mais tão fortemente onde os fatos, a informação, ocorreu. Pensa, isso sim, "eu vi na televisão." Não pensa, a priori, de onde a informação está vindo, pensa para onde está indo, para a televisão. Pensa nos canais antes de pensar nos locais.

E, por fim, depois das transmissões a satélite, das manchetes depois do jantar, surge a Internet, filha da ARPANET (neta, ou a versão amadurecida da coisa, sei lá, ora bolas), com informações mais desterritorializadas ainda, eu não penso onde o Google está, fisicamente falando, claro, e sim no endereço que devo acessar, se está nos EUA, no Canadá ou na Conchinchina, não me importa, importa o endereço. Mas, mais do que isso, a Internet mudou também, ou melhor, deu maior velocidade, a geração da informação. Não são mais apenas escritores, repórteres, mulheres do tempo a me dizer o que se passa. Sou eu escrevendo em um blog, tenho minha página na Internet onde gero tanta informação (e lixo) quanto sou capaz. São, pelo menos 50 bilhões de páginas, e o numero aumento, lá vamos nós, vertiginosamente. Talvez como não se tenha visto na imprensa e na televisão. Nem poderia ser!

Afinal, os tempos são outros, mas as razões, a meu ver ainda são as mesmas. Os meios evoluíram com a própria humanidade. Antes, apenas se preocupar com a caça e com o grupo, então para que diacho publicar livros? Depois, tribos, cidades, castas, hierarquias, não dava para dizer "ei, cruza o mar e vem aqui sacar o que escrevi na minha caverna", então, a escrita em papiro, papel, mais simples de transportar do que uma caverna (leitor, essa é a única certeza nesse texto, o resto são especulações de uma mente pouco saudável). Os livros supriram a necessidade dos países, nos continentes, a necessidade de bem mais gente no mundo. Escrever a mão era praticamente impossível já que não é um tipo de produção em série. A TV para um mundo já parcialmente globalizado, mais cidades, mais gente ainda. Era natural que surgisse um meio mais barato e rápido do que livros ou jornais impressos. E, por fim, a Internet, a World Wide Web, com implicações, ainda não decidi, além da transmissão de informação. Escolho a "divulgação da informação" porque acredito ser o alicerce para muitas outras das invenções descritas no livro. Até mesmo para a borracha de apagar!

ps.: Eu já até imagino Diego Salcedo vir aqui e dizer algo do tipo "Mas blá, a informação sempre esteve sobre o controle de alguem, do faraó, sei lá, e nem todos têm acesso." E eu digo, "porra bla, eu sei, quer dizer, lembrava mais não, mas sei. Escreve sobre então, carai!".

valeuz...

Filosofia da informação

2005-04-12T08:27:00.000-03:00

É parceiro blá...informar pra q e pra q informar...dizem q é uma necessidade humana...num sei não...informação na virada do século XX surge-nos mais como um produto imperativo à nossa sobrevivência...num sei não...surge com temática de estudo científico...num sei não...é...de tudo q sei...num sei não...na verdade quero ir surfar um pouco e depois deitar numa rede para sentir-me parte de uma metainformação potencial universal ou (MIPU)...assina DS.

Meu nome é bla

2005-04-11T16:35:00.000-03:00

Aê, finalmente viagens viajadas da vida viajada. Vou abrir, aqui, nesse momento, a faculdade dos doidões.

valeuz...

Lucene.

2005-04-11T09:42:00.000-03:00

Para aproveitar um pouco melhor o pouco tempo livre das férias, resolvi escrever um artigo sobre o Lucene. Eu gosto bastante dessa API então, nada melhor do que aproveitar e escrever sobre. A idéia, na verdade, começou com um post na wiki de onde trabalho, mas eu confesso que não havia gostado do resultado. Aliás, escrevi na filosofia de wiki mesmo, "depois alguém melhora isso." Então, quando sugeri ao JavaFree que poderia criar um tutorial a partir da entrada na Wiki alguém teve a ótima idéia de tentar publicar na revista MundoJava, ao invés de apenas publicar no portal. Vamos ver, ainda não entrei em contato oficial com a revista, mas, espero conseguir a publicação e, se não conseguir, ao menos é um bom tutorial para o JavaFree.

valeuz...

Meu código, meu precioso código... ou nem tanto.

2005-04-11T09:41:00.000-03:00

É quase regra um programador não gostar do código de outros a menos que esse se pareça com o seu e, também, achar seus códigos antigos ruins, o que é completamente natural se vc considerar que evoluiu um bocado desde os tempos em que escreveu aquelas linhas de qualidade duvidosa. Foi justamente essa a sensação que tive quando, muito por acaso, encontrei alguns códigos de um projeto do qual participei em 2000. Os códigos não eram todos meus, mas vou assumir a culpa já que eu poderia ter ajudado a tornar as coisas melhores. Havia tantas más praticas que ativar o PMD, Metrics e FindBugs fez o Eclipse travar.

Os problemas mais comuns eram programação baseada em classes e não em interfaces, blocos condicionais complicados, métodos gritando por refactoring, quebra total do MVC, hierarquias de herança completamente desnecessárias, muito código sem qualquer conhecimento de YAGNI, singletons adoidados, checked exceptions aos montes e outras esquisitices que não vou citar sob o risco de ser apedrejado nas ruas. Mas não dá para negar, minha atenção se voltou principalmente para a total falta de uso de componentes, frameworks ou bibliotecas de classes prontas. Pool de conexões manual, MVC manual, persistência via plain JDBC (não me lembro de ter visto outras aplicações que permitiam tanto SQL Injection), sequer uma ferramenta de automação, como o Ant, por exemplo, era usada.

Então, lá fui eu fazer algumas estatísticas superficiais: entre as minhas 401 classes (401 classe?! Meu Deus!), dividas em 60 pacotes, 131 eram... Exceptions, o que indica graves problemas. Não vou explicar o projeto, mas acreditem, 401 classes são demais e, quando mais de 30% das suas classes são Exceptions, pode acreditar, existe algo de muito errado. Pior ainda, NENHUMA era unchecked e, daí, o errado passa a podre. Outro erro crasso era a total falta de abstração. Mesmo onde existiam interfaces, e elas eram apenas 42, era fácil encontrar algo do tipo:

MinhaInterface bla = new MinhaClasse();

Ou seja, sem uma abstração para criar os objetos, não adianta muito ter interfaces. Mas isso é fichinha perto do método abaixo:


public void setValue() {
if (value == null) {
    throw new IllegalArgumentException();
} else {
    this.value = value;
}
}

Muito útil, não?! Bom, baseado no lixo que eram meus códigos, ficam algumas dicas: 1) Tente pensar de maneira simples; 2) Tenha em mente YAGNI (401 classes?! Humpf!); 3) Usar frameworks e libraries de terceiros não vai fazer mal algum, então pesquise antes de tentar implementar uma solução caseira; 4) pense um pouco antes de criar uma Exception filha que não acrescenta informação a Exception pai; 5) unchecked exceptions são geralmente uma alternativa interessante; 6) Cuidado com aquelas classes MinhasOperacoesMalucas ou similares, em especial quando elas contem comentários do tipo "LIXÃO DO CODIGO ANTERIOR". E ficam também algumas constatações: 1) Eu aprendi muito em fóruns, mas pesquisar me ensinou mais ainda; 2) mudar do JBuilder para o Eclipse e usar ferramentas para inspeção de codigo me fez bem; 3) ainda bem que inventaram container de IoC e AOP; 4) testes podem até parecer chatos, mas são legais; 5) não tive preguiça de ler documentações e livros como o Effective Java, então, considere se tornar um bom leitor de bons livros.

valeuz...

KISS

2005-03-28T18:30:00.000-03:00

Simplicidade é um conceito que ganha pontos comigo a cada dia e em quase tudo que faço ultimamente me pergunto duas coisas: Isso é simples? Se não é o suficiente, eu preciso da complicação que criei? Alias, esse é o tipo de pergunta que surge na minha cabeça a cada cinco minutos enquanto estudo Ruby. Sempre tento pensar sobre os paradigmas de Java e muitos deles não fazem sentido algum em Ruby. Mas, voltemos à simplicidades: é um tanto complicado dizer que algo é simples ou não porque isso depende, e muito, do ponto de vista e conhecimentos de quem julga. A combinação Hibernate + Spring + WebWork, por exemplo, pode parecer um monstro se quem olha não tem conhecimento de nenhum dos três e, talvez, principalmente, se não conhece os padrões e idéias sobre as quais cada um destes foi construído. Abstração e independência de banco de dados, loose coupling com IoC e AOP, MVC e Command simplesmente não têm utilidade se você nunca usou e, mais do que isso, se você nunca precisou usar.

Enquanto lia o ótimo Better, Faster, Lighter Java, vi, ou melhor, revi simplicidade como um conceito fundamental no desenvolvimento de software, mas, revi também que ser simples está tão distante de ser simplista quanto possível. E é aí que mora o perigo. É muito comum confundir os dois conceitos e tentar criar coisas simplistas que ferem outros conceitos fundamentais de desenvolvimento como pouco acoplamento e extensibilidade apenas para ficar nos mais conhecidos. É comum não usar um determinado e emergente, e entenda por emergente adequado ao problema, padrão de projeto quando você decide que não vai pagar os custos em troca dos benefícios apenas porque usar o padrão lhe parece ferir demais a simplicidade. Ou seja, você tende ao simplista.

Aqui onde trabalho a arquitetura passa pelos dois frameworks abordados no Better, Faster, Lighter Java: Hibernate e Spring e ainda pelo WW. Alguns projetos são feitos em PHP e o debate surgiu daí. PHP é sem sombra de duvidas mais simples (ou seria simplista?), configurá-lo para funcionar com o Apache, diferente do Tomcat, é moleza e a curva de aprendizado, maior trunfo da linguagem, é ridícula de tão pequena. Em um fim de semana aprendi o suficiente para desenvolver um dos pequenos projetos. Acontece que para os projetos maiores PHP não é satisfatório, ou ao menos não parece ser, pois precisamos da tal abstração ao banco de dados (Hibernate), melhor separation of concerns como a provida pelo MVC (WW) e um container de IoC (Spring) que nos ajude a pensar em componentes e maior capacidade de reuso.

A meu ver, nenhum desses frameworks é extremamente complicado. Alias, por focarem bem nos problemas que se prestam a resolver, eles são até bem simples. Claro, Ã primeira vista, juntar todos e jogar na cabeça de alguém pode não ser a melhor das idéias, mas não se pode negar que os benefícios oferecidos por cada um deles pagam com folga as complicações iniciais que trazem.

valeuz...

Jablo: Talvez mais tarde

2005-03-28T18:04:00.000-03:00

Pois é, depois de insistir um bocado quanto a usar o Jablo, descobri não era mais possível manter u m blog por lá. Isso porque em boa parte do tempo o sistema está fora do ar e ler "Server Error" ou "HTTP 404" não é algo lá muito instrutivo. Eu espero muito sinceramente que o Jablo consiga resolver as broncas com hosting e, se conseguir, volto a escrever com prazer. Por enquanto, vou tentar repaginar alguns dos textos que escrevi por lá e publicar aqui.

valeuz...

Desenvolvimento do Conhecimento

2005-02-01T14:02:00.000-03:00

Uma das muitas vantagens de tirar férias é que você lê apenas textos realmente interessantes. Eu, em hipótese alguma, pararia para ler uma bula de remédio, os livros do Sidney Sheldon ou aqueles artigos sobre o novo release do JSeiLáOQue. Mas uma edição da Continente Multicultural, gibis da Mônica e um caderno especial da Revista Escola chamaram minha atenção. Este último continha uma série de escritos rápidos sobre como o pensamento e práticas a respeito de ensinar se desenvolveram. Os textos iam de Skinner a Paulo Freire passando por Russeau e outros dos quais já ouvi falar na universidade, como Vygostky e Piaget.

Mas, como nerd em época de férias sempre arruma um jeito para ligar toda e qualquer coisa a computador, enquanto lia o texto sobre Comenius, lembrei de alguns trechos do livro sobre padrões de projetos do GoF. Comenius foi um dos primeiros a pensar na criação de “padrões” para a educação e em como se deve considerar o aspecto psicológico das crianças ao invés de apenas tratá-las como um repositorio de conhecimentos. Como era um pensador da época das colonizações, seus tratados tentavam ser tão universais quanto possível e, para universalizar, Comenius achou que deveria criar algumas restrições. Em particular, desenvolveu a tese de que todo o conhecimento da humanidade é estático. Era uma maneira inteligente de tratar com o desconhecido que tanto afligia aquela época e, mais do que isso, criar um sistema de educação que pudesse ser empregado em qualquer lugar, visto que o conhecimento estava completamente estabelecido.

Diferente disso, o livro do GoF traz alguns pontos contrários bem interessantes. Claro, boa parte deles se desenvolveu ao longo do tempo e não foram, acreditem, os caras do GoF que os criaram. Já na introdução o livro afirma que não catalogou todos os padrões e mostra como registrar novos, uma clara notação tanto de que outros padrões conhecidos podem ser catalogados quanto criados. Além disso, existe outro conceito bastante interessante, e agora não lembro exatamente se é algo dito nesse livro, de que modelagem de software sempre pode evoluir. Ou seja, em tese, é sempre possível melhorar o design de uma aplicação qualquer. Se é viável ou não é outra história.

Em sistemas pequenos pode ser difícil enxergar isso ou a regra pode simplesmente falhar. Mas, em sistemas mais complexos, e se levarmos em conta todo o ciclo de vida, fica fácil perceber que muito provavelmente melhorias podem ser feitas em algum ponto. O melhor deste tipo de pensamento - o conhecimento se desenvolve - como vieram a concluir outros pensadores posteriores a Comenius também retratados na revista, é a ampliação do próprio conhecimento e, no fim das contas, do estudo e aprendizado. Basta perceber que preciso parar de escrever besteira e ir ler a documentação do novo release do JSeiLáOQue.

valeuz...

O Inicio.

2005-01-27T21:32:00.000-03:00

Como todo blog que se preze, este tem que começar com um daqueles posts do tipo "apenas para inaugurar" ou "teste". Mas, para não fazer feio, aliás, para não fazer muito feio, vou falar sobre meu interesse por blogs. Ele surgiu quando o GUJ e o PortalJava lançaram o JavaBlogs e boa parte da comunidade Java do Brasil decidiu apoiar e participar. Apesar da iniciativa extremamente interessante, o sistema de blogs passava mais tempo fora do ar do que qualquer um de nós parcipantes gostaria. Eu até poderia deixar blogs de lado, mas acho que é um bom mecanismo para me manter escrevendo além dos foruns e, como herança do Jablo, apelido do JavaBlogs, ficou meu interesse por blogs.

É fácil ver alguns bons blogs por aí e também é fácil perder a paciência quando vc procurar por a letra de uma música e acaba dando de cara com aqueles blogs cheio de "xeiosssss", "bjoxxxx" e outras coisas que vcs já devem estar cansados de ver. Então, para evitar parecer com um adolescente dislexo de 15 anos que escreve num dialeto pouco compreensivel, tentarei escrever posts com um bom português, mas, para não parecer com o professor Pasquale, não serie chato o suficiente para evitar alguns verbetes típicos da internet. Enfim, esse blog será sobre tecnologia, especialmente linguagens de programação, banco de dados, metadados e fones de ouvido. Mas também postarei sobre assuntos menos... ehrm, deixa pra lá, e falarei sobre fotografia, cinema e impressões que tiver sobre alguma leitura. É isso.

ps.: O nome comunidade blastêmica veio de um grupo de amigos que se reunia para falar bla bla blas. Não sei se a palavra blastêmica faz parte do dicionário, mas, fazer o que, neologismo existe para isso mesmo.

valeuz...