42 - Opiniões

Invasão na USP

2011-11-08T17:55:00.000-08:00

Tudo começou com os policiais abordando três estudantes que portavam alguns baseados. Não seria provocação fumar na cara dos policiais? O que parece que a Universidade é um feudo, e dentro da Universidade as leis são diferentes. Bom, não é. Mas nem todas as leis são corretas.

Não é porque a lei existe que ela é justa. Cabe sim aos universitários questionar as leis. E veja, eu não defendo o uso das drogas nem a discriminalização do seu comércio. Mas defendo o direito de se debater isso de forma civilizada. O que nos leva de volta ao ocorrido na USP. Sim, a polícia é um forte instrumento de coerção. Seria legal ser levado a delegacia porque você "estacionou" em lugar proibido? Não parece exagero, excesso de força!? Então, o que essa ala revolucionária ultrajovem por meio da assembleia (antidemocrática) dos estudantes propõe é que a vigilância seja exercida pela guarda universitária e não pela PM (bom… é uma solicitação razoável).

O diabo é que a USP convive com com uma violência assustadora. É fácil cometer todo tipo de crime e fugir por uma das diversas portas não mais vigiadas da USP. Não mais vigiadas porque a bandidagem é tão grande que não é "seguro" para a guarda universitária vigiar essas portas (não para o contigente nem para as armas que ela dispõe). A USP está a mercê de bandidos que residem nas comunidades carentes que orbitam sua existência. Bandidos existem em todos lugares, mas a desigualdade social, a pobreza, a exclusão social e uma série de outros fatores acabam por fazer que as comunidades mais carentes mais expostos ao crime, principalmente a criminalidade violenta.

Não que a USP deva ser uma exceção e ter o privilégio de não compartilhar das mesmas mazelas da sociedade, principalmente a vizinha. São então os estudantes da USP melhores que os moradores da São Remo? Ocorre que nossa sociedade não "democratiza" todas as suas coisas. A USP em si é um ótimo exemplo de exclusão social. A maior parte da verba destinada a educação é dirigida a instituições como ela da qual apenas uma ínfima fração da sociedade pode aproveitar. Uma vez que temos essa incongruência estabelecida seria ainda errado não zelar pelos recursos estão em parte concentrados nela, incluindo o humano.

De volta ao feudo que criamos, a USP como uma extensão dos condomínios da classe média. Sem a segurança devida, a USP é de fato uma gorda oferta aos petralhas. Fácil de entrar, fácil de sair, fácil acesso para "favelas", e várias alvos potenciais. Inclusive alguns estudantes de forma mais direta alimentam o crime assim como esses alimentam seus vícios. Então, ok, todos querem segurança (na USP) mas será que não é ingénuo achar que a guarda universitária é capaz de lidar com os problemas da complexidade descrita acima? Que a PM não está perfeitamente capacitada para abordar os estudantes concordamos mas parece pior a situação sem ela.

De onde nos leva ao linchamento público. Reitero minha opinião: não concordo com certas opiniões mas concordo muito que opiniões sejam respeitadas. Isso não é democracia. É um conceito muito maior. Justiça!? Respeito!? Bom, não sei o nome mas diverge daquilo que ocorreu. Já é difícil uma assembleia estudantil em que propostas mais ponderadas vençam e quando isso acontece o pessoal ignora? Para que? Repetir a agressão as autoridades. Forçar uma decisão que não tem o apoio da maioria. Para forçar goela abaixo uma opinião. Essas ações divergem de tudo… dos ideais, da civilidade, de tudo. Como defender essas atitudes?

The Climb

2011-10-10T13:02:00.000-07:00

Oi, pessoal!

Acabamos de inaugurar o site (obrigada Carolina Daffara, Bruno Gouveia, Marcos Sobrinho e Igor Escobar _ espero que não tenha esquecido de ninguém) e estamos dando início ao processo de divulgação da theClimb. Inicialmente vamos nos concentrar na região próxima à USP, mas em breve estaremos espalhados por sampa! Convido a todos que sejam ou conheçam alunos de inglês em potencial e professores procurando aulas na região do Butantã/Osasco que divulguem e acessem o site: www.theclimb.com.br . Many, many thanks to you all (críticas e sugestões ao site são benvindas!!!)

2011-05-05T10:05:00.000-07:00

Alemanha sempre me surpreende...

Recentemente eu tenho conhecido um pessoal aqui em São Paulo que tem jogado jogos de Tabuleiro ao estilo Alemão.

http://en.wikipedia.org/wiki/German-style_board_game (a versão da wikipedia em português é péssima... melhor pedir para o google traduzir a página em inglês).

A sacada é a seguinte... os jogos de tabuleiro tradicionais (do mercado) brasileiro são ruins... e os alemães são ótimos... Por que? Eis os pontos mágicos:

1) Os jogadores não devem ser eliminados: em jogos de guerra como WAR, um jogador por ser retirado do jogo prematuramente. Isso é bem chato... enquanto o resto do grupo joga, os jogadores eliminados olham para o teto.

2) O jogo termina: Jogos ruins como WAR, Banco imobiliária, etc... o jogo pode durar uma quantidade indefinida de turnos. Isso torna o jogo chato. A forma do jogo não durar infinitamente são duas: ou o jogo dura um número finito e pré-definido de turnos ou existe algum recurso (também finito e conhecido) do jogo que se exauri (continuamente) com o passar dos turnos.

3) Estratégia deve estar acima da Sorte: acho que isso fala por si só, mas 2 pontos são bons ressaltar. 1) Jogos determinísticos podem ser difíceis demais para reles mortalis; 2) basta que o jogo priorize um pouquinho a sorte para ele incomodar.

Bom, apenas para exemplificar um jogo maravilhoso nessa linha... Pillars of the Earth (Pilares da Terra ou ainda Die Säulen der Erde), jogo homônimo ao Best Seller que fala sobre a construção de uma catedral Gótica. Imperdível.

Jogo na Amazon.

#fica_a_dica!

Código Inspirado

2011-01-13T06:02:00.000-08:00

Acabo de reler um código que escrevi e achei a solução tão maluca e útil rs que vale a pena ser comentada. O objetivo é implementar uma versão simples do HttpResponse cujo comportamento seja minimamente próximo a versão original, sem no entanto precisar extender um NullObject do HttpResponse. A solução de sempre... proxy dinâmico.

public class DynamicProxy implements InvocationHandler{
 private Set set = new HashSet();
 private Object target;
 private String getTarget;
 
 public DynamicProxy(Object target, String getTarget){
 Method[] methods = target.getClass().getMethods();
 set.addAll(Arrays.asList(methods));
 this.getTarget = getTarget;
 this.target = target; 
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
 if (set.contains(method)){
  return method.invoke(target, args);
 }else {
  if (method.toString().equals(getTarget)){
    return target;
  }
 }
 return null;
 }
}

Agora o método que fabrica o HttpResponse. O resultado do response será colocado no printWriter. É bom notar que o Response praticamente implementa a interface do PrintWriter então o código poderia ser melhorado para usar isso.

private HttpServletResponse createHttpResponse(StringWriter stringWriter) {
// Ninjutsu!
 PrintWriter printWriter = new PrintWriter(stringWriter);
 DynamicProxy dynamicProxy = new DynamicProxy(printWriter,
    "public abstract java.io.PrintWriter javax.servlet.ServletResponse.getWriter() throws java.io.IOException");
 HttpServletResponse response = (HttpServletResponse) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
     new Class[] { HttpServletResponse.class }, dynamicProxy);
 return response;

Apple não é o dono da Bola

2011-01-06T06:44:00.000-08:00

Tem uma anedota que ilustra bem como o que a Apple e o Android OS significam no mercado de smartphones e tablets.

Todas as tardes, o pessoal saía para jogar bola num campinho próximo ao centro. O encontro não era formal, não havia hora combinada, não sabíamos quem compareceria nem quem iria trazer a bola. Na verdade a questão da bola costumava ser a mais problemática. As mães não gostavam que levássemos a bola novinha para se perder no meio do mato ou coisas assim. Mas tentávamos o possível para sempre ter uma bola ali.

Em alguns casos, aparecia um moleque mimado que, por estar ele com uma bola, deixávamos que ele participasse do racha. Geralmente esses moleques não suportavam a primeira dividida e ameaçavam levar a preciosa redonda caso fossem contrariados. Evitávamos esse mal estar: quando encontrávamos essa situação, tolerávamos o cidadão o máximo possível.

Foi então um dia que cheguei um pouco mais tarde que o habitual e o jogo já havia começado. E era um daqueles dias que tinha um moleque mimado jogando. Um que eu nunca tinha visto antes e que era especialmente insuportável. Reclamava de tudo e de todos. O pessoal não acreditava na folga dele. E como de costume, procurávamos não pegar pesado. Até que alguém da turma grita: "pessoal, eu tenho que ir embora mas depois vocês podem levar a bola lá para casa".

'Hein!? Pára tudo! Então a bola não é daquele moleque???' _ dava para ouvir o pensamento das pessoas ali. Olhávamos uns para a cara do outros incrédulos que havíamos suportando aquele estorvo por tanto tempo.

Mas foi o que bastou...A partir daquele momento o pobre não conseguiu mais tocar na bola. Sempre havia alguém para dar um esbarrãozinho nele e fazê-lo voar uns 3 metros para frente. "Foi na bola!", "Foi mal!", etc.
-----

O Android OS é justamente alguém gritando: "a bola pode ficar aqui. Joguem a vontade". Será que os mimadinhos da Apple vão continuar jogando do mesmo jeito???

Easy Tricks

2010-12-21T10:29:00.000-08:00

I've already done a thumbnail page, using DropBox, ImageMagick, bash > ls > html > css.

First tip: You can sync your files online and across computers with @Dropbox. 2GB account is free! https://www.dropbox.com/home.

Second, select a collection of files (in my case, PDF files about boardgames) and put them in a public folder within Dropbox (I've created games subfolder in public folder to do that).

Use ImageMagick to create thumbnail from files:
(to install imagemagick in Linux use: sudo apt-get install imagemagick)

So, to create a thumb for all files I've used following command:

for a in $(ls *.pdf); do convert -thumbnail x96 $a[0] $a.png; done

Now, it is possible create HTML from these files:

for a in $(ls *.pdf); do echo "< a href=\"$a\" class=\"image\" >< img src=\"$a.png\" /> < span class=\"text\">$a< / a >" >> file.html; done

(yes, I know... I would use sed command to change pdf extension rather than just to suffix ".png"... it's just to keep things simple :D)

Next, I've created an index file to exhibit that files. Basicly, the file use the following css (thanx to Gabriel Ricci):

a.image
{
float: left;
display: block;
text-align: center;
margin: 5px;
}

a.image img{
display: block;
border: none;
}
a.image .text{
display: block;
width: 100px;
word-wrap: break-word;
font-size: small;
}

Done! A very fast and simple thumbnail from PDF files.

O resultado segue aqui: galeria de jogos de tabuleiro.

Chuva de Granizo...

2010-11-25T12:48:00.000-08:00

O som das pedras de granizo estourando no telhado era o mais impressionante

Esquizofrenia paulistana

2010-11-03T18:16:00.000-07:00

São Paulo não tem identidade.
É uma terra perdida, perplexa.
Sua origem é universal,
Reinventada a cada dia.
Caminha a noite, de dia,
Nas avenidas que voltam para si mesmas:
Avenidas sem fim...
Avenidas mineiras, paulistas,
estrangeiras.
São Paulo não tem fronteiras.
Embora teimem os mapas
Sua cara não mente
São todas as caras
De dor, alegria,
Ódio e amor.
São Paulo é isto...
Me desculpe, não tem como descrevê-lo
Vão achar mil faces para detestar
Mas Sampa tem milhões,
muitos milhões de faces
Que um dia irão olhar para si
E se reconhecer Paulista
Mas hoje Paulo olha as estrelas
em busca de um destino
E elas quietas respondem todos os destinos possíveis

Sobre o xiismo

2010-10-26T11:24:00.000-07:00

Não é bom, correto ou adequado utilizar o termo xiita como sinônimo para fundamentalista ou radical. Xiita é só um dos ramos da religião Muçulmana com mais de 100 milhões de seguidores em todo mundo. No Iraque, os xiitas foram massacrados pelos sunitas liderados por Saddam Hussain o que foi considerado um crime contra a humanidade e levou a condenação de Hussain. No Irã, os sunitas foram oprimidos por xiitas. Mas o fundamentalismo ou radicalismo não é inerente a essas crenças e não faz o menor sentido pensar que um grupo é moderado e outro é radical.
Aliás, de quem é a frase: "ou você está do nosso lado ou contra nós": dos xiitas? dos sunitas?

Poetic License

2010-10-20T18:56:00.001-07:00

(c) 2005 Alexander E Genaud

This work ‘as-is’ we provide.
No warranty express or implied.
We’ve done our best,
to debug and test.
Liability for damages denied.

Permission is granted hereby,
to copy, share, and modify.
Use as is fit,
free or for profit.
These rights, on this notice, rely.

O Tempo, o pôquer e o planejamento

2010-09-20T08:44:00.000-07:00

As frases de efeitos que carregam a pregação do Scrum muitas vezes atrapalham mais do que ajudam a explicar certas cerimônias do Scrum. Isso acontece por exemplo com a reunião de planejamento, onde os membros do time precisam estimar o tamanho das histórias e o julgamento dos membros é enublado por referências como "não é possível dizer quanto uma tarefa é maior que outra devido a imprecisão inerente a estimativa".

Pretendo aqui fazer uma reflexão sobre a estimativa do Scrum que, em minha opinião, não rompe com as convenções usuais de estimativa e onde os valores atribuidos as tarefas expressam de fato o "tamanho" médio estimado para cada tarefa com relação ao tempo.

Para quem não sabe, durante a reunião de planejamento o Product Owner explica as histórias do "Backlog", o time precisa estimar o "esforço" necessário para concluir cada delas. A
ferramenta para auxiliar a estimativa é o pôquer do planejamento. No pôquer do planejamento, cada membro da equipe utiliza um baralho de cartas de uma pseudo-sequência de fibonacci (os baralhos mais comuns seguem a sequência 1,2,3,5,8,13,20,40, 100). Escolhe-se uma tarefa como referência a pontuação. Ex: uma aplicação simples de cadastro é a tarefa de valor 2.

A cada história, após o PO apresentar o problema e de uma discussão inicial dos membros da equipe, os membros da equipe iniciam o jogo. Simultaneamente apresentam a carta que melhor aproxima o valor que cada um considera representar o esforço (em relação a tarefa de referência) necessário para a realização da tarefa. Se ocorrerem divergências, jogadores que escolheram os valores mínimos ou máximos expõem o motivo porque acreditam que a pontuação deva ser maior ou menor apresentando facilidades e dificuldades que talvez outros membros não tenham percebido. Outras rodadas do pôquer se sucedem até
que os jogadores entrem em consenso.

Sterilis theoria, auream praxis. Na prática, muitas pessoas ficam confusas sobre o valores e a escala do pôquer do planejamento. Um colega meu defendia a ideia que os números não representam valores escalares, ou por exemplo uma atividade 2 não foi estimada 2,5 vezes mais fácil do que uma atividade 5 e que para justamente não levar ao erro dessa relação matemática entre as grandezas fora escolhida uma sequência estranha de progressão. Por esse raciocínio, 5 expressa apenas um esforço maior que 2 e 3 porém menor que 8.

Para a discussão ficar mais rica irei ilustrar o problema com 4 atividades para serem avaliadas: ler um exemplar da Revista Caras, ler um livro da série Harry Potter, ler Os Lusíadas e ler a teoria de Galois. Ao final, a equipe deve ser capaz de fazer um resumo ou apontar os pontos mais importantes da leitura. Esse exemplo foi inspirado num exemplo utilizado num “curso de Scrum”. Em nosso cenário imaginário, esse é o primeiro Sprint
e a equipe deve eleger uma história como referência. Vamos supor que a história de ler um exemplar da Revista Caras seja escolhido como referência (o esforço estimado é 2). Ainda por hipótese, ninguém da equipe leu a série Harry Potter nem o exemplar específico da Revista Caras em questão. Qual deveria ser o esforço estimado para a leitura de um Harry Potter???

Para ser mais específico, considerando que um livro da série Harry Potter tenha 700 páginas e que uma revista Caras tenha 50 páginas, imaginando que a linguagem utilizada no livro seja no máximo tão difícil quanto a linguagem utilizada na revista, seria errado assumir que o livro é no mínimo dez vezes mais difícil que a revista? Tudo leva a crer que sim....

Para compreender melhor isso é importante saber para que essas avaliações serão utilizadas. A avaliação não apenas torna possível ordenar as tarefas. Ela permite estimar o conjunto de tarefas que o grupo é capaz de realizar num Sprint. Primeiro porque a cada Sprint, um total de histórias é realizado. Cada história leva consigo sua pontuação. Logo, a cada Sprint tem-se a média de total de pontos que o time é capaz de entregar (entre outros estimadores como o mínimo de pontos entregues, mediana, etc). Esses valores balizam a quantidade de pontos que o time pode se comprometer a entregar. Na verdade, mesmo num primeiro Sprint, o time deveria ser capaz de imaginar qual valor seria razoável como esse limite.

Se a sequencia fosse apenas uma ordem (digamos A para a tarefa mais fácil e G para a tarefa mais difícil) não seria possível estimar a capacidade de produção do time. Além disso, após as estimativas, o PO tem a liberdade de escolher qualquer combinação de histórias cujo total seja menor ou igual a capacidade da equipe. Para isso, seria muito saudável que uma história 8 fosse 4 vezes “maior” que uma história 2.

Num segundo momento, essa capacidade média de produção será utilizada para que o PO possa estimar o tempo para a realização de histórias maiores, mesmo com incertezas grandes. Toda ideia de estimativa é essa, senão estaríamos falando de definição do tempo.

Voltamos ao exemplo dos livros... Ao invés da revista Caras vamos considerar que história básica seja ler “A Volta ao Mundo em Oitenta Dias” (com 256 páginas). Com todas as variáveis constante a menos do tamanho dos livros, Harry Potter teria nota 5,4.

Ocorre que qualquer estimativa leva consigo uma certa incerteza. O pôquer do planejamento resolve isso com uma relação implícita entre intervalos e valores ao limitar a escolha de valores intermediários. Dessa forma, ao estimar uma história com 2 seria uma forma de dizer que a história tem valor maior que 1 e menor que 3, logo de um intervalo de 2 pontos. Aliás, a série de Fibonacci serve justamente para isso, qualquer número da série (maior que 1) é igual a diferença entre o número que sucede e antecede.

Avaliar a leitura de um livro da série de Harry Potter, deveria considerar esse intervalo. E dessa forma 5 seria um valor que faria bastante sentindo. Agora, qual a dificuldade de ler (e entender ) a teoria de Galois que poderia ser escrita em 10 páginas. Os cursos de graduação em bacharelado de matemática dedicam um semestre ao estudo dessa teoria. Logo, questões como a complexidade ou incertezas podem ser fatores decisivos na estimativa. Assim como a experiência anterior dos membros da equipe (por exemplo, poderíamos ter matemáticos no time o que diminuiria bastante a dificuldade dessa história).

Para finalizar, qualquer metologia de estimativa descrita nos livros de engenharia de software das abordagens tradicionais apontam questões como extensão, complexidade, experiência da equipe e a incerteza. O Scrum não pormenoriza o processo de como estimar deixando isso a cargo do time, mas de qualquer forma trata de avaliar a seguinte grandeza: velocidade (ou trabalho sobre tempo) (lembrando que essa velocidade inclui incertezas inerentes ao processo de estimativa e a diferença entre o cenário especulado e o cenário real).

Em frente a estação Cidade Universitária

2010-09-10T08:24:00.000-07:00

Boa surpresa em frente a estação Cidade Universitária.

StarCraft II - Wings of Liberty

2010-09-09T06:00:00.000-07:00

After 12 years, this software looks like just a expansion pack of Starcraft.

Starcraft II é o super lançamento da Blizzard para 2010. Um jogo aguardado por 10 anos, mais que chega com cara de pacote de expansão.

Sim, Starcraft II (ou SC2) apresenta algumas melhorias em relação ao jogo "original". O microgerenciamento melhorou bastante com duas novidades:

Fila de tarefas: é possível determinar que uma unidade cumpra uma fila tarefas, isso serve, por exemplo, para determinar que os "peões" (SCV) construam uma sequência de Suply Depots, ou que o imbecil do Siege Tank faça transformação Siege apenas após atingir o local adequado, ou para determinar a ordem de ataque de unidades, tornando o focus fire mais eficiente.
Smart Cast: ao selecionar um grupo de casters, apenas uma unidade (provavelmente a mais apta) irá executar o comando designado. Por exemplo, se um grupo de High Templar forem selecionados, ao utilizar o comando Void, apenas uma unidade laçará o spell no alvo o que acaba evitando desperdício de "energy".

Além dessas novidades, SC2 conta com todas as melhorias de Warcraft III como Set Rally Point em recursos que atribui a tarefa de extração ao peões assim que esses são produzidos pelo Centro de Controle.

Do ponto de vista do visual, as melhorias são mais óbvias mas nada de revolucionário. Wings of Liberty praticamente contém um "filme" inserido em sua narrativa digital que ocorre entre as diversas missões do jogo. A história é centrada em Jim Rainor,um misto de cowboy com motoqueiro desse universo cyberpunk. Várias são as referências aos filmes de Western. Para citar alguns: Mar Sara é um planeta árido, sem construções verticais, praticamente abandonado da civilização; Antes da Zero Hour
Jim encontra-se num bar com um crânio de Zerg pendurado na parede, bebendo alguma coisa que se assemelha a Whisky, planejando sua próxima ação para confrontar as forças da Tirana Domination entre elas, o ataque aos comboios de suprimentos da Domination. Raynor é agora um hard-drinking amargurado anti-herói perseguido pelas trágicas lembranças dos conflitos intergalácticos que antecederam SC2 e busca a redenção de seus atos e ao mesmo tempo executar seus planos revolucionários. Sua maior culpa foi inculbir Sarah Kerrigan a uma missão em que ela fora abandonada a sorte, capturada e transformada pelos Zergs na Rainha das Lâminas (Queen of Blades). A história culmina com o confronto de Jim com Sarah.

Junto com essa narrativa Wings of Liberty traz uma nova engine gráfica 12 anos mais moderna que a versão anterior mas cuja as diferenças são apenas
sutilezas: as unidades são bem semelhante as unidades do jogo anterior mais rica em detalhes e com uma textura mais sofisticada. Todos os reviews consideram
o visual e a música ponto fortes do jogo, mas está longe de ser uma revolução como prometido.

A um certo nível de competitividade variações nos atributos das unidades provocam mudanças nas estratégias adotadas pelos jogadores. E essas mudanças ocorrem em Wings of Liberty:

Algumas unidades ignoram diferença de níveis em Terrenos;
Nidus Network e Warp Gate permitem que unidades sejam lançadas em diferentes pontos de cenário, inclusive pŕoximo a bases inimigas;
Para o Late game, as unidades terráqueas ficaram mais fortes. Smart cast tornam Battlecruisers mais eficientes, especialmente contra os Carriers.

A BattleNet está também bem mudada e bem mais potente. O sistema de ranking, alianças, jogo com amigos está online do que nunca. Por outro lado, a Blizzard acabou com a farra das LANs e o jogo não oferece suporte a jogo em rede, apenas pela Internet. Welcome to www (wait wait wait) games.

Do ponto de vista da jogabilidade o jogo é ainda menos inovador. Embora SC e SC2 sejam muito melhores que Warcraft III com seu doente sistema de microgerenciamento, Starcraft sofre da pouca inteligência de unidades, e um ridículo conjunto de comandos que não permitem às tropas se organizarem e combarem de forma eficiente, a menos que você tenha a pachorra de controlar cada uma de suas idiotas unidades individualmente.

Estou falando de alguma coisa de outro mundo? Acho que não:

Age of Empires (1998) inclui várias opções de formação para tropas. Além disso, a quantidade de tropas permitidas nesse jogo faz o microgerenciamento pouco eficiente.
BattleTanks e guntaxx são jogos mesozóicos que permitem aos jogadores programarem o funcionamento de suas unidades. Cada jogador pode utilizar um script personalizado do
funcionamento do seu tanque, por exemplo em battletanks.
Battle Realms possui a opção de Guard. Essa ação faz com que uma unidade tente guardar uma outra posição, estrutura ou outra unidade. Em Starcraft, isso permitiria por exemplo que unidades anti-aereas protegessem um battlecruiser ou que marauders protegessem um siege tank em siege mode. A função guard não faz apenas com que uma unidade ataque qualquer uma unidade hostil que se aproxime do alvo. Faz com que a unidade se coloque entre a unidade guardada e a unidade hostil e engage that unit into a battle.

Essa falta de inteligência das unidades não tira do jogo a diversão de criar e se defender de estratégias como Banneling Bust, Rush, etc, mas torna o jogo sofrível para quem quiser competir com pessoas afeiçoadas ao miserável microgerenciamento.

Magia Assíncrona

2010-07-12T10:06:00.000-07:00

Versão PDF

Como transformar objetos comuns em "objetos assíncronos"

Programação Concorrente em Erlang - A inspiração

Joe Armstrong, um dos criadores da linguagem Erlang nos mostrou uma maneira muito elegante de tratar concorrência na programação. Iremos introduzir alguns conceitos de Erlang que tangem a programação concorrente deixando de lado uma séria de sofisticações como o tratamento e propagação de erros, programação remota para focar nos conceitos mais básicos e gerais.
O primeiro comando básico de concorrência é o BIF (built in function) ``spawn''. Essa função é usada para criar um novo ``processo" (na nomenclatura de Erlang, processo seria uma linha de execução (portanto uma thread) que não compartilha dados). A assinatura da função é a seguinte: spawn(Module, Exported Function, List of Arguments). Considere o seguinte módulo (extraído do tutorial do Erlang):

--module(example1).

-export([start/0, say_something/2]).

say_something(_, 0) -> done;

say_something(What, Times)-> 
 io:format("~p~n", [What]),
 say_something(What, Times - 1).

start() ->
 spawn(example1, say_something, [hello, 3]),
 spawn(example1, say_something, [goodbye, 3]).

A função start() deste módulo bem simples cria dois processos que executa a função \verb+say_something+ com os parâmetros $[hello, 3]$ e $[goodbye,3]$. Além disso, a função devolve o id do processo criado (como veremos a frente).

1> c(example1).
{ok,example1}
2> example1:start().
hello
goodbye
<0.43.0>
hello
goodbye
hello
goodbye

Por enquanto, criamos processos que executam ações mas não escutam mensagens. Mas enviar mensagens para um objeto que não responde é como estender a mão a um cego esperando que aperte sua mão. Façamos então o processo enxegar ou ouvir mensagens. Para isso, utilizamos a estrutura receive.

A construção receive é usada para permitir que processos esperem mensagens de outros. Seu formato é:

receive
 pattern1 ->
  actions1;
 pattern2 ->
  actions2;
 ....
 patternN
  actionsN
end.

O que é um tanto quanto intuitivo. Ao receber alguma mensagem que coincida com o pattern1 o processo executará actions1 e assim sucessivamente. Outra construção igualmente importante é a forma como enviamos mensagens para um processo. Para isso usamos o operador ``!''.

Pid ! Message

A construção acima envia a mensagem Message (que pode ser qualquer ``termo'' Erlang) para processo cujo id seja igual a Pid. A seguir, um exemplo de programa com interações (processos enviando mensagens para outros processos), ilustrando o uso das construções citadas:

-module(example2).

-export([start/0, ping/2, pong/0]).

ping(0, Pong_PID) ->
 Pong_PID ! finished,
 io:format("ping finished~n", []);

ping(N, Pong_PID) ->
 Pong_PID ! {ping, self()},
 receive
  pong -> io:format("Ping received pong~n", [])
 end,
 ping(N - 1, Pong_PID).

pong() ->
 receive
  finished -> io:format("Pong finished~n", []);
  {ping, Ping_PID} ->
   io:format("Pong received ping~n", []),
   Ping_PID ! pong, pong()
 end.
start() ->
 Pong_PID = spawn(example2, pong, []),
 spawn(example2, ping, [3, Pong_PID]).

Ao executar o código acima teremos o seguinte resultado:

1> c(example2.erl).
{ok,example2}
2> example2:start().
Pong received ping
<0.43.0>
Ping received pong
Pong received ping
Ping received pong
Pong received ping
Ping received pong
ping finished
Pong finished

Surpreendentemente simples e útil. Por trás dessas simples construções, Erlang
cria um novo processo (spawn) e uma ``caixa de mensagens'' para este processo.
Sempre que uma mensagem é enviado ao processo (Pid ! Message), a mensagem fica
guardada na caixa de mensagens até que o processo esteja disponível para recebê-lo. O processo então retira a mensagem da caixa (receive) e seleciona qual ação tomará baseado no
padrão que a mesma se encaixa.

Asynchronous Proxy Factory - Java Strike Back

Um dos grandes apelos das linguagens tipadas é a facilidade de saber quais
mensagens são entendidas por objetos dessa linguagem, e sempre que a assinatura
das mensagens enviadas não coincidirem com a interface do objeto tem-se um erro
em tempo de compilação. Isso permite a uma IDE como Eclipse fornecer dicas de
codificação no momento que o programador digita o código.
Em oposição, durante a codificação de mensagens em Erlang com a construção "Pid ! Message"
não é possível saber quais mensagens, afinal, o processo Pid escuta.
Java, não fornece estruturas simples como Erlang para mensageria mas um
complicado e também sofisticado arcabouço de concorrência java.util.concurrent.
Nossa proposta é criar uma biblioteca auxiliar que forneça os mecanismos de
concorrência para objetos que funcionem de forma ``síncrona'' usando apenas as
ferramentas já disponíveis na linguagem.

Versão OO do Ping-Pong

Para uma melhor comparação entre os conceitos de atores de Erlang e os conceitos
de Orientação a Objetos de Java, iremos fazer uma adaptação do programa
ping-pong (example2). Tomaremos o cuidado de fazer uma versão testável, quer
dizer, ao invés dos métodos escreverem String na saída padrão, eles irão
preencher um ``log de conversação'' que será analisado num teste unitário. Comecemos
pelo teste.

@Test
 public void ping(){
  StringBuffer string = new StringBuffer();
  Ping ping = new Ping(string);
  PingInterface pong = new Ping(string);
  ping.sendPing(3, pong);
  verifyPingConversation(string, 3);
 }

StringBuffer é uma versão sincronizada do StringBuilder. Isto vem a calhar
porque devemos evitar condições de corrida na escrita do log. A grosso modo,
este método é uma versão junit da função start() do programa example2.
A verificação que implementaremos apenas verifica se todas as falas foram
realizadas durante o diálogo dos atores. Inicializaremos uma mapa com as frases
e a quantidade de vezes que aquelas frases devem aparecer. Sempre que uma frase
for dita, iremos decrementar o contador no mapa até zerá-lo quando riscaremos
a frase do mapa.

private void verifyPingConversation(StringBuffer string, int i) {
  String[] messages = string.toString().split("\n");
  Map expectedResult = 
   new HashMap();
  expectedResult.put("Pong received ping", i);
  expectedResult.put("Ping received pong", i);
  expectedResult.put("Pong finished", 1);
  expectedResult.put("ping finished", 1);
  for (String string2 : messages) {
   Integer count = expectedResult.get(string2);
   count--;
   if (count ==0){
    expectedResult.remove(string2);
   } else {
    expectedResult.put(string2, count);
   }
  }
  Assert.assertTrue(expectedResult.isEmpty());
 }

Agora a versão Java do Ping. Bonus: definimos uma interface de comunicação,
eliminamos os seletores e a classe é testável.

public class Ping implements PingInterface {
 private StringBuffer conversation;


 public Ping(StringBuffer string){
  conversation = string;
 }

 public void sendPing(int n, PingInterface pid) {
  if (n ==0 ){
   pid.finished();
   say("ping finished\n");   
  } else {
   pid.ping(this);
   sendPing(n-1, pid);
  }
 }

 private void say(String string) {
  conversation.append(string);
 }

 public void finished() {
  say("Pong finished\n"); 
 }

 public void pong(PingInterface pong) {
  say("Ping received pong\n");
 }
 

 public void ping(PingInterface ping) {
  say("Pong received ping\n");
  ping.pong(this);
 }
}

Padrão Produtor-Consumidor em Java

Inicialmente, precisaremos de um sistema de mensageria como Erlang. Para
isso, teremos uma ``caixa de mensagens'' que faremos com o uso de uma
BlockingQueue (fila bloqueante do pacote java.util.concurrent). Por questões de
simplicidade utilizaremos a implementação ArrayBlockingQueue.
Deixaremos um consumidor a espera de serviços que chegarão na
``caixa de mensagens''. Este trabalhador terá uma linha de execução
independente do programa principal e um reservatório de trabalhadores para
executar cada uma das mensagens.
Para controlar o ciclo de vida do consumidor, o consumidor irá dispor de:

Uma tarefa kill; Ao receber a tarefa kill, o processo deve parar. A ideia é que essa seja a última tarefa a ser executada pelo processo.
Uma variável sentinel; caso o valor falso seja atribuido o processo pára independente se outras tarefas existam na fila;
um método para interrupção;

Internamente, o consumidor terá controle sobre o reservatório de trabalhadores
através da interface ExecutorService.
Abaixo, propriedades do executor conforme mencionado:

/**
  * caixa de mensagens (tarefas) do executor
  */
 protected BlockingQueue blockingQueue;

 /**
  * reservatorio de trabalhadores
  */
 protected ExecutorService executorService;

 
 // variaveis de controle do ciclo de vida
 private boolean sentinel = true;
 /**
  *  Tarefa que finaliza
  */
 private final T kill;

 /**
  * variavel de sincronizacao: quando chegar a zero, o
  *  processo terminou sua execucao
  */
 private CountDownLatch countDownLatch = new CountDownLatch(1);

O método principal do Executor, é o método público run() da interface Runnable.

@Override
 public void run() {
  try {
   // importante para interromper o loop infinito
   while (isSentinelEnable()) {
    T t = getBlockingQueue().take();
    if (t == kill) {
     kill();
     sentinel = false;
    } else {
     execute(t);
    }
   }
   // anuncia que o programa terminou
   getCountDownLatch().countDown();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }

Se uma mensagem kill é recebida, o método kill() será invocado para que o objeto
possa realizar algum procedimento de sanidade. Para as demais mensagens, o
método execute() é invocado.
Enquanto execute() é abstrato o método kill() possui um implementação básica
vazia.

protected abstract void execute(T t);

 protected void kill() {
 }

A classe possui ainda três métodos de razoável importância. O construtor, um
inicializador e um método de sincronização. Os demais métodos são accessors e
mutators, além de possíveis métodos para finalização.

/**
  * Instancia o executor, mas nao inicia seu processamento 
  * @param n tamanho do pool de trabalhadores
  * @param m capacidade maxima da caixa de mensagens
  * @param kill tarefa utilizada para finalizar o processamento
  */
 public Executor(int n, int m, T kill) {
  executorService = Executors.newFixedThreadPool(n);
  blockingQueue = new ArrayBlockingQueue(m);
  this.kill = kill;
 }

 /**
  * Inicia o processamento com uma nova linha de execucao
  */
 public void execute() {
  final Thread thread = new Thread(this);
  thread.start();
 }

 /**
  * aguarda o fim do processamento e finaliza o reservatorio 
  * de trabalhadores
  */
 public void awaitTermination() {
  try {
   getCountDownLatch().await();
   this.executorService.shutdown();
   this.executorService.awaitTermination(1000,
                       TimeUnit.MILLISECONDS);
  } catch (final InterruptedException e) {
   e.printStackTrace();
  }
 }

Quicksort Paralelo em Java

Façamos agora uma pausa, no desenvolvimento da solução para testar a classe
acima. Como prova de conceito iremos implementar uma versão paralela do
Quicksort que utliza o código.
A ideia básica, em implementar um quicksort paralelo usando o padrão
produtor-consumidor é receber uma tarefa com um vetor a ser ordenado
e particioná-los através de um elemento pivo (desse vetor) e
adicionar cada uma das partições como novas tarefas da fila de execução do
executor.

@Override
 public void execute(QuickSortJob t) {
  int size = t.array.length;
  if (size < thresold){
   Arrays.sort(t.array);
   t.result = t.array;
   t.array = null;
   if (t.joinToFather()){
    doneSignal.countDown();
   }
   return ;
  } 
  int rand = random.nextInt(size);
  final T comparable = t.array[rand];
  T[] rights = newInstanceArray(t);
  T[] lefts = newInstanceArray(t);
  T[] mids  = newInstanceArray(t);
  int l = 0, r = 0, m = 0;
  for (int i = 0; i < t.array.length; i++) {
    T array_element = t.array[i];
   if (array_element.compareTo(comparable) < 0){
    lefts[l++] = array_element;
    continue;
   }
   if (array_element.compareTo(comparable) > 0){
    rights[r++] = array_element;
    continue;
   }
   mids[m++] = array_element;
  }  
  BlockingQueue> blockingQueue = getBlockingQueue();
  blockingQueue.add(new QuickSortJob
   (t, QuickSortJob.LEFT, Arrays.copyOf(lefts, l)));
  t.mid = Arrays.copyOf(mids, m);
  blockingQueue.add
   (new QuickSortJob(t, 
    QuickSortJob.RIGHT, Arrays.copyOf(rights, r)));
  t.array = null;
 }

Podemos programar um certificado \footnote{algoritmos de verficação ou
certificados estão relacionados com complexidade computacional. Uma breve
explicação sobre o assunto pode nas do
Paulo Feofiloff para ordenação. Para isto criamos um vetor desordenado, executamos o ordenador e verificamos se os elementos do vetor estão ordenados.

public void testQuickSort() throws Exception { 
  Random random = new Random(); int n = 200000;  
  Integer[] problem = new Integer[n];
  for (int i =0; i < n ; i++){
      problem[i] = random.nextInt();
  }
  final long timeMilis = System.currentTimeMillis();  
  QuickSortWorker.doneSignal = new CountDownLatch(1);
  originalJob =  new QuickSortJob(null, 0, problem);  
  QuickSortWorker executor = 
    new QuickSortWorker(10, n); // executor  
  executor.getBlockingQueue().add(originalJob);
  executor.setCountDownLatch(QuickSortWorker.doneSignal);
  executor.execute();
  executor.awaitTermination();
  
  final long lastMilis = System.currentTimeMillis();
  System.out.println("Tempo Total:" + (lastMilis - timeMilis));
  
  int temp = Integer.MIN_VALUE;
  QuickSortJob job = originalJob;
  for (int i = 0; i < job.result.length; i++) {
   assertTrue(temp <= job.result[i]);
   temp = job.result[i];
  }

 }

Junit verde! Podemos prosseguir com o desenvolvimento do utilitário.

Uma versão estática

O que a construção receive faz em Erlang, um ``switch case'' poderia fazer no
template method execute. Podemos fazer melhor que isto. Em Java, é possível
fazer com que o compilador verifique se as mensagens enviadas são entendidas por
meio de sua assinatura. Para isto, iremos criar um wrapper que implementa
a (mesma) interface de um objeto alvo e transformar a mensagem bloqueante numa
assíncrona. Criaremos uma classe message com todas as informações necessárias
a execução da mensagem o próprio método (java.lang.reflec.Method), o objeto
alvo e os parâmetros da chamada.

public class Message implements Callable{
 
 Object[] parameters;
 Object target;
 Method method;
 
 public Message(Object target2, Method method2, Object[] args) {
  parameters = args;
  this.method = method2;
  this.target = target2;
 }

 public Message() {
 }

 @Override
 public Object call() throws Exception {
  return method.invoke(target, parameters);
 }

}

Agora, iremos criamos uma especialização do Executor que processa uma FutureTask.

public class SpawnExecutor extends Executor{
 public SpawnExecutor(int n, int m) {
  super(n, m, new FutureTask(new Message()));
 }
 
 @Override
 protected void execute(FutureTask task) {
  executorService.execute(task);
 }

 public void shutdown(){
  try {
   getBlockingQueue().put(getKill());
  } catch (InterruptedException e) {
  }
 }
}

Devemos encapsular o objeto Message numa FutureTask. Dessa forma, podemos
notificar os interessados sobre a conclusão de uma mensagem específica. Façamos então uma outra especialização (do Executor) que exporte estas funcionalidades além de
oferecer uma interface mais simples para o envio de mensagens.

public void send(Message message) {
  FutureTask futureTask = new FutureTask(message);
  spawnExecutor.getBlockingQueue().add(futureTask);
  notify(futureTask);
 }

 private void notify(FutureTask futureTask) {
  if (observer != null){
   observer.notify(futureTask);
  }
 }

 private Observer observer;
 
 public void setObserver(Observer observer) {
  this.observer = observer;
 }
 
 public Observer getObserver() {
  return observer;
 }

Na listagem, o efeito é conseguido com o padrão Decorator.
Temos um último problema: popular o objeto Message. Enquanto que objeto alvo e
os parâmetros são conhecidos, ainda precisamos encontrar o objeto Method apartir
do pacote de reflexão (queremos encontrar o método apartir do nome). Para isso,
faremos um objeto mais especializado que recebe uma mensagem e cria e popula um
objeto Message e o coloca na fila de trabalhos.

public abstract class AsynchronousStaticExecutor extends AsynchronousExecutor{
  protected void sendMessage(Method method, Object[] params) {
  if (parameters.length - parameterTypes.length != 0)
   return false;
  for (int i = 0; i < parameters.length; i++) {
   Object object = parameters[i];
   if (!parameterTypes[i].isAssignableFrom(
           object.getClass()))
    return false;
  }
  return true;
 }
}

Agora podemos criar a versão estática assíncrona do programa ping pong.
Mas, como de costume iremos apresentar o teste unitário para tal.

@Test
 public void testAsyncStaticPing(){
  StringBuffer string = new StringBuffer();
  Ping ping = new Ping(string);  
  AsyncPing pong = new AsyncPing(ping);
  // iniciar processo
  pong.start();
  
  ping.sendPing(3, pong);
  
  // finaliza processo
  pong.shutdown();
  pong.awaitForTermination();
  
  verifyPingConversation(string, 3);
 }

E, a classe estática.

public class AsyncPing extends AsynchronousStaticExecutor 
     implements PingInterface {

 private Ping target;

 public AsyncPing(Ping ping) {
  this.target = ping;
 }

 @Override
 protected Object getTarget() {
  return target;
 }

 @Override
 public void finished() {
  sendMessage("finished", new Object[] {});
 }

 @Override
 public void ping(PingInterface ping) {
  sendMessage("ping", new Object[] { ping });
 }

 @Override
 public void pong(PingInterface pong) {
  sendMessage("pong", new Object[] { pong });
 }
}

Java Lang Reflection

Um mago sabe a importância de um espelho. Entre as várias mágicas que o pacote
de reflexão da linguagem está o truque de criar um proxy às chamadas
de um conjunto de interfaces. Essa simples mágica talvez seja a forma mais
fácil de adicionar algum comportamento em tempo de execução para algum objeto
genérico (outras formas seriam a manipulação de byte code ou do próprio
código-fonte). Por tamanha facilidade, a API de reflexão é utilizada nas
chamadas RMI para forjar um representante local de uma classe remota. Este
representante recebe as chamadas locais e delega sua execução a entidade remota
correspondente dando a ilusão ao programador que as chamadas são realizadas localmente.
E, tudo isso graças a uma fábrica de proxies e uma interface de manipulação:

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

public class GenericProxyFactory {

Limitação importante: Não é possível
criar proxy para objetos sem interfaces. Para contornar o problema é
possível utlizar a refatoração: extract interface.

Aplicação: AsynchronousProxy

Vamos agora ao objetivo final desse artigo, apresentar um proxy para transformar
chamadas bloqueantes em chamadas não bloqueantes. O uso básico desse proxy e
permitir que o programador faça uma versão simples do código, sem se preocupar
com concorrência e depois, sem mudança de paradigma ou expressivade, utilizar a
concorrência.

@Test
 public void testAsyncPing() throws Exception {
  StringBuffer string = new StringBuffer();
  Ping ping = new Ping(string);
  Ping pong = new Ping(string);
  // iniciar processo
  AsynchronousProxyFactory asynchronousProxyFactory = new AsynchronousProxyFactory (1, 10, pong);
  PingInterface asyncPong = asynchronousProxyFactory.getAsynchronousProxy(PingInterface.class);
  asynchronousProxyFactory.start();
  
  ping.sendPing(3, asyncPong);
  
  // finalizar processo
  asynchronousProxyFactory.shutdown();
  asynchronousProxyFactory.awaitForTermination();
  
  verifyPingConversation(string, 3);
 }

public class AsynchronousInvocationHandler implements InvocationHandler{
 private final AsynchronousExecutor asynchronousExecutor;
 private final T target; 
 public AsynchronousInvocationHandler
   (AsynchronousExecutor asynchronousObject, T target) {
  this.asynchronousExecutor = asynchronousObject;
  this.target = target;
 }
 @Override
 public Object invoke
   (Object proxy, Method method, Object[] args) throws Throwable {
  asynchronousExecutor.send(new Message(target, method, args));
  return null; 
 }
}

public class AsynchronousProxyFactory extends AsynchronousExecutor {

 private T target;

 public AsynchronousProxyFactory(int n, int m, T obj) {
  super(n, m);
  this.target = obj;
 }

 @SuppressWarnings("unchecked")
 public T getAsynchronousProxy(Class intf) {
  return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
    new Class[] { intf },
    new AsynchronousInvocationHandler(this, target));
 }
 
 
}

Feito!

Luz 360 graus

2010-06-18T14:26:00.000-07:00

Com ajuda do Hugin, e das dicas do Marcos Sobrinho, criei uma imagem da histórica estação da Luz da capital paulista com as fotos tiradas do meu celular LG.

:D

http://hugin.sourceforge.net/

Uma crítica da crítica do BBB

2010-04-07T22:00:00.001-07:00

Eu não acredito no que estou fazendo. Estou maculando meu blog com um post sobre BBB. Então, primeiro, a minha defesa, por que escrevo sobre isso. Basicamente porque todas as análises sobre o programa que li foram toscas e por muitas vezes de pessoas que se sentiram ofendidas, magoadas, pelo resultado. E? E o fato delas se sentirem magoadas é sinal que elas precisam aprender a respeitar a opinião alheia. O presente texto tem objetivo apaziguador, diplomático e didático.
Toda essa discussão que o último BBB trouxe já torna evidente a relevância do programa. Ele traz em voga a discussão sobre comportamento e a percepção do comportamento.
Não importa quanto a produção tenha manipulado os jogadores, ou quanto a edição participou do programa. Fato é que um enredo fora apresentado e ao final de cada semana um outro jogo era travado. Sim, a votação é um jogo que como foi provado por Kenneth Arrow, matematicamente impossível de se ter um sistema que seja perfeitamente justa (ou que otimize a função de bem-estar social).
Não vou entrar aqui nos detalhes da teoria dos jogos e sobre a impossibilidade de Arrow. Estou apenas deixando evidente que o público jogou BBB, no intuito de fazer valer o seu gosto individual, sua opinião sobre o que achou mais interessante. E cabe aqui ressaltar um outro detalhe que muitos não compreenderam: O público do BBB não tem interesse em escolher o participante de maior QI, conhecimento, etc. Não tem motivo algum para escolher o “participante” que seria o melhor presidente da república porque esse poderia ser um chato que não teria feito ressaltar suas qualidades ou, mais do que isso, não teria transmitido alguma ideia relevante.
É claro que quando digo “participante” falo da imagem do participante real, do recorte apresentado ao público da história que ele viveu ali, da série de decisões e atitudes naquele intervalo de espaço-tempo (obviamente editadas, manipuladas, etc _ ressalto que isso não interessa. A história é mais importante que a veracidade dos fatos; porque é essa que é analisada). Se essas decisões e atitudes refletem um ponto de vista é o que basta.
Pois, voltando ao público como jogadores. O jogo torna-se mais interessante quando pontos de vista que partes do público se identificam colidem. Aí a inteligência dos produtores em selecionar tipos, caricaturas que provoquem discussões (e outras interações) entre o público.
Mas então, qual seria o ponto de vista que o vencedor desse BBB apresentou? Pedro Bial, o jornalista apresentador do reallity show, deu excelentes pistas disso, no discurso que declarou o vencedor da competição, quando muitos já haviam fracassado miseravelmente. Sim, porque alguns preferiram simplificar a história como: a vitória do preconceito sobre a diversidade. Torpe! Débora Secco, fortemente malhada por Tutty Vasquez se aproximou muito mais da realidade com suas declarações despretensiosas do que esses jornalistas.
Segundo, segundo Bial, Dourado representou a ideia do cara sofrido, derrotado mil vezes pela vida mas que ainda assim insistia em lutar. O grande perdedor, transformado em vencedor na epopeia. Já Débora Secco avaliou que o personagem representou o imperfeito, a pessoas cheia de defeitos, como as pessoas reais, e que mesmo assim jogava para ser vitorioso; foi o errado que deu certo.Vasquez foi taxativo: a lógica da militância dourada: “por maiores que sejam os defeitos, dá para vencer no Brasil”.
Vasquez, porque você fugiu da biblioteca nas aulas de literatura? Poderia teria aproveitado “Memórias de um sargento de milícias” e ter aprendido que existem personagens pícaros (os bons professores de literatura costumam ensinar sobre isso). Se você mora na Terra e tem um pouco de senso crítico já deve ter percebido que existe um desgaste do maniqueismo.
Falo de Tutty Vasquez porque ele foi o epitoma da obtusidade. Mas outros jornalistas falaram sobre o reinado do lado negro a partir do BBB7, sobre os jedis do lado claro da força. Aff!
Dizer que algum gay deveria ganhar é igualmente patusco. Pela própria ideia de igualdade, a opção sexual do vencedor não deveria importar em absoluto. Um gay não é um gay antes de tudo. É uma pessoa, e como pessoa deveria ser julgado. Essa é a ideia de igualdade que parece ter permeado o julgamento do público, ou pelo menos da maioria “vencedora”.
A maioria que tomou repulsa desse tipo de imposição de valores (“esse Big Brother deveria ser para celebrar a diversidade”. A resposta do público foi como: “O BB celebra o que eu quero, cara pálida”.
As impressões passadas pelo personagem dourado refletem, além do que já foi falado (seu jeito pícaro, do coração Rocky Balboa ), a repulsa a imposição. Algumas de suas frases ilustram bem isso: Numa brincadeira ao vivo de como o publico gay aumentava no Brasil, o Dourado se pôs como hétero, dizendo ser da "resistência hétero". Outra, quando Dicesar, após indicá-lo para o Paredão, na mesma semana que havia falado que ele merecia uma folga do paredão responde: “Apesar de ser viado, seje homem”.
Mas, muitas outras divertidas e absurdas frases serão encontradas na internet. Aqui uma pequena seleção:

Fernanda : Dourado, você vai chupar o picolé de banana ?
Dourado: Eu não chupo, eu como.
---------
Dourado: Homem que é homem não repara em celulite.
Serginho: Eu reparo!
Dourado: E você é homem?
---------
Dourado na piscina e Fernanda pergunta: Vai mergulhar?
Dourado: Não. Só entrei pra ver se não era Sprite.
---------
Dicesar : Você não deveria rir assim porque escapou de um paredão.
Dourado: Você votou em mim ?
Dicesar: Sim.
Dourado: Então estou rindo é de você

Outras estapafúrdias (e equivocadas) como a frase sobre a relação dos homossexuais e a AIDS.

Cabe, enfim lembrar uma frase célebre de Oscar Wilde, um dos maiores escritores do mundo, diga-se de passagem, gay: “É absurdo dividir as pessoas em boas e más. As pessoas ou são charmosas ou tediosas”.

Eu sou pessoa?

2010-02-10T08:04:00.000-08:00

Pessoa: um indivíduo, com referência a seu relacionamento social.

A mãe tentava explicar a filha de três anos porque era preciso fazer silêncio no ônibus.
_ As pessoas podem não gostar do barulho. As pessoas têm o direito de não ser perturbada.
_ Karina, uma coisa... _ levantou o dedinho para interromper a mãe _ eu sou pessoa ?
Dava para ver em seus olhos sua preocupação sincera em saber se gozava do título mencionado, e desses direitos. Talvez por "ser pinininha", como ela racionalizara certa vez, não teria tal sorte.
A mãe respondeu com um abraço:
_ Claro que é uma "pessoa". E uma pessoa maravilhosa!
A pequena se encheu de alegria pelo respeito concedido a ela.

Irmão melhor

2010-02-01T14:14:00.001-08:00

Essa história eu ouvi de uma entrevista do Pedro Bloch a muitos anos atrás (1998). Ainda melhor que a história dos pregos... Não encontrei o texto em nenhum lugar. Então estou recontando a história da forma como lembro.

Na sala do médico, duas crianças de oito anos estão numa consulta de rotina.
Eram gêmeos. Desses que é difícil dizer quem é quem. Mas que a aparência não o engane. Eram irmãos
de personalidades diferentes. Na entrevista, o médico perguntou aos garotos:
_ Quem é o mais estudioso !?
_ É ele! _ respondeu alegre o mais cerelepe.
_ Ah. Quem é o mais inteligente !?
_ É ele! _ denovo o garoto cerelepe.
_ Ah. Então quem é o mais bonito !?
_ É ele! _ não titumbeou o garoto.
_ Mmm. E de quem a mãe mais gosta!?
_ É dele! _ respondeu mais um vez sem nem dar chance do seu irmão falar alguma coisa.
Bom, mas essa última pergunta também não ajudava muito: se ele é o mais estudioso, inteligente e bonito,
claro que a mãe iria gostar mais dele.
_ Escuta garoto _ exclamou o médico em tom sério _ não tem nada que você não seja "mais" não !?
_ Sim. _ respondeu o outro gêmeo _ ele é mais irmão.

[]'s
Rodrigo

Um texto pós-moderno - better man

2009-12-30T07:49:00.000-08:00

Espere olhando para as horas... são 4 horas. Tem que parar. Nesse tom melancólico, começa a modesta música "better man", uma balada pop composta por Eddie Vedder ainda na adolescência. A música é a ilustração perfeita da ironia. O próprio título é irônico, uma vez que em momento algum na música aparece um better man.

She lies and says she's in love with him, can't find a better man...

Irônico, não!? Para começar, com a personagem central da história, a mulher que aguarda tarde da noite seu esposo... Ela chega a treinar com o espelho o fim do relacionamento. E o que faz? Diz a negação do que queria dizer.

Vedder escreve músicas sobre sentimentos fortes. Sua relação com a mãe foi bastante complicada pelo o que descreve em suas canções. Na trilogia Mommy, Vedder descreve um homem perturbado com o relacionamento materno; a mãe mente para o filho sobre a identidade do pai, revela a verdade para o garoto na puberdade dizendo a ele como se parece com o verdadeiro pai e o leva a uma relação incestuosa. Sua reflexão: "Ainda estou vivo...". No final da trilogia, a mãe morre e o personagem central é condenado à pena capital.

Em better man, Vedder ataca a posição passiva e conformada da mãe, mas de uma forma mais singela. Basta ouvir a música uma única vez para perceber que o tom melancólico do refrão é (outra) ironia. Can't find a better man? A música cresce, continuamente, torna-se viva e cheia de esperança. É claro que ela pode. Desde o princípio sempre pode. E carregado de certeza do contrário, o refrão canta: can't find a better man x2. Can't find a better maaaaaaaaaaan... Ao final da música, o ouvinte se sente energizado e esperançoso, o que é irônico a essas palavras.

Assim, dentro da simplicidade do gênero grunge, o vocalista consegue pintar com a antítese: verdadeiro com falso, esperança com melancolia de forma clara como cristal. O recurso consagrado por imortais da literatura como Oscar Wilde e Machado de Assis fica estampado nos acordes metálicos dessa simples mas vibrante música. Da abertura sombria para o esperançoso final, os vários tons de uma figura de linguagem.

Palavras de Verdade

2009-12-30T07:45:00.000-08:00

A primeira palavra que minha filha aprendeu a falar foi "pai". O que pode parecer estranho porque ele morava com a mãe e eu não tinha tanto contato assim com ela. Talvez tenha sido coincidência que o som que ela emitia ao me ver fosse parecido com pai. Fato é que ela aprendeu rápido a chamar o pai, a mãe e depois vários objetos. Mas nenhuma dessas palavras foi tão palavra quanto aquela que ela aprendeu a falar pouco tempo depois: "não".

O que acontece com o "não" é que esse advérbio tem um valor semântico variável. Ao contrário de mãe, pai, bola, água cujo valor semântico é constante para a criança (pai é sempre o mesmo pai, assim como bola sempre significa uma bola, oras), o não é usado para expressar a negação de qualquer coisa. Portanto, "não" pode ser qualquer coisa.

A aquisição de tal vocábulo é o início de uma nova relação com o mundo. O mundo deixa de ter apenas objetos e passa a ter história, inter relações que começam a ser compreendidas. A mudança é tão fantástica que nossas lembranças mais remotas remetem a um certo momento em que conseguimos expressar o mundo por tais vocábulos.

Hoje minha afilhada chamou a mãe várias vezes por mamãezinha. A mudança sutil entre chamar a mãe por mãe e por mamãezinha é outra enorme mudança. Quando a criança chama a mãe por mamãezinha ela já está "mal" intencionada. Ela não quer simplesmente invocar a mãe, mas chamá-la de forma que ela se sinta prestigiada, agradada por ela. E isso aconteceu porque essa criança notou que as palavras estão dentro de um jogo de comunicação onde o mais importante não é expressar o que queremos, o que já é tarefa bastante complicada, mas convencer as pessoas a nos ajudar a conseguir tal coisa.

Cá estou com meus botões a pensar que com um pouco de sensibilidade encontramos nos pequeninos gestos das crianças as sutilezas que nos tornam tão complexos.

Minisaia na Uniban

2009-10-28T20:05:00.000-07:00

http://www.youtube.com/watch?v=gWUyKgs0u-4

http://virgula.uol.com.br/ver/noticia/news/2009/10/28/226552-aluna-da-uniban-ameacada-de-estupro-no-campus-por-usar-minissaia

Para mim, a menina da minissaia é uma heroína, ao exercer a liberdade de escolher suas vestes, e destoar de uma regra implícita, velada por sociedade cínica e
hipócrita em que “estava” inserida.

As razões que explicam a reação dos estudantes vão muito além das simplificações sobre a qualidade da escola. A natureza humana é perversa, e mesmo submersos a um mundo de controle e disciplinas, carregamentos essa perversidade intrínseca em alguma parte de nossa mente.

Abaixo, trecho extraído da natureza do terrorismo:

“O terrorismo é uma manifestação da psique. A raiz psicológica do terrorismo é um ódio quase-psicótico do ressentimento fanático que origina nas profundidades da psique arquétipa.

Um exemplo literário clássico é de Melville, Moby Dick. O Capitão Ahab, com seu ódio fanático da baleia branca, é um paradigma do terrorista moderno. Os terroristas articulados expressam-se geralmente na terminologia (arquétipa) religiosa. O inimigo é considerado como o princípio de mal objetivo [“puta” em nossa versão da Uniban] e o terrorista percebe-se como herói, agente de justiça divina ou objetiva.

Para tratar o terrorismo eficazmente nós devemos compreendê-lo. Estes indivíduos não são criminosos e não são loucos embora tenham algumas qualidades de ambos. Vamos chamá-los de fanáticos. Os fanáticos são possuídos pelo arquétipos dinâmicos transpessoais que derivam-se da coletividade inconsciente.“

Para aqueles interessados em entender mais o assunto eu recomendo um estudo sério da psicologia de C.G. Jung.

Bolsa Família - Além de Bom é Mágico ??? (2)

2009-10-23T19:49:00.000-07:00

Uma longa discussão foi travada por conta de um artigo "científico" sobre se o bolsa família gera renda (veja post anterior). Para quem quiser conferir, o artigo está no link:

http://www.ipc-undp.org/publications/mds/33P.pdf

(Agradeço aqui Warrior e Delmar pelos esclarecimentos).

O objetivo do presente post e fazer uma análise desse artigo do senhor Paulo Henrique Landim Junior e seu prof. Dr. Naercio Aquino Menezes Filho:

A idéia do trabalho desses autores é confrontar dois grupos: aqueles que mais se beneficiaram com o bolsa família, e o os demais que servirão como grupo de controle aos dados observados.

“Para aprofundar esta análise, destacamos os municípios onde mais de 50% da população é beneficiada pelo Programa Bolsa Família. Esses municípios foram comparados com outros, onde uma parcela menor da população é beneficiada. Para isso foram criados e analisados os dois grupos de municípios: aqueles em que mais de 50% da população é beneficiada pelo PBF (grupo 1) e aqueles em que menos de 50% da população é beneficiada pelo PBF (grupo 2).” (página 10)

Feito essa divisão, é analisado, para cada grupo, o aumento do PIB e o aumento do bolsa família e constatado que com uma margem de confiança de 62,38% (ver regressão econométrica nas páginas 16 e 17) que o aumento do PIB e o aumento do repasse per capita nos municípios mais beneficiados são correlacionados.

Agora vamos refletir nesses números: por que eles são óbvios? A resposta é porque quase 62% da população ativa desses municípios recebeu o bolsa-família (página 11).

Sejamos mais radiciais para entender a questão. Vamos imaginar um outro cenário…Antes do bolsa-família, esses 62% da população não recebiam nada. Então, a partir de um certo ano, o governo passou a repassar o BF a essa população. Será que haverá alguma corelação do repasse com o PIB desses municípois? É evidente que sim, a população que contriui com o PIB do município quase triplicou.

O BF destinado a esses 712 municípios mais beneficiados não vieram deles (apenas uma fração ínfima – o PIB total desses municípios é de R$33.350.080.000,00 (página 11)), mas dos outros 4789 municípios da união. Isso chama-se repasse, e é o propósito do programa (transferir renda dos mais pobres para os mais ricos). O PIB influenciado pelo BF cresceu nessa região porque diminuiu (o PIB influenciado pelo BF) em outro lugar. É como tirar a água de um balde e jogar em outro, sugerir que como o primeiro balde está ficando seco, os baldes ficarão sem água.

Ainda, analisando o trabalho:
“Estimou-se um aumento de 0,06% no PIB per capita para cada aumento de 1% no valor de repasse per capita.”

Vamos aceitar a margem de confiança de 62% e concordar que para os 472 municípios mais beneficiados com o BF, ocorreu um aumento de 0,06% no PIB per capita para cada aumento de 1% no valor de repasse per capita, e, o que o estudo não fala, que nos demais municípios, de onde saiu esse dinheiro, o BF impactou negativamente no PIB. Daí, temos que é inaceitável concluir o seguinte:

“(..). Com base nessas informações é possível obter o benefício estimado da expansão do Programa Bolsa Família no ano de 2006. Para isso basta multiplicar 0,06 por 30,34. O valor obtido, 1,82%, é o impacto estimado do aumento de 30,34% no repasse per capita sobre o PIB dos municípios [TODOS]. Em 2006 o PIB brasileiro foi R$ 2.369.797.000.000 e, portanto um aumento de 1,82% neste significa um acréscimo de R$ 43.139.784.588,00.”

Bolsa Família - Além de Bom é Mágico ???

2009-10-16T20:54:00.000-07:00

Saiu no Estado de São Paulo os resultados de um estudo sobre o impacto da ampliação do Bolsa Esmola na Economia. Basicamente é o seguinte: com os 1,6 bilhão de Reais adicionais investidos no programa (de 2005 a 2006.), o governo impulsionou o PIB em 0,6% (43,1 bilhões de reais).

http://digital.estadao.com.br/download/pdf/2009/10/16/A9.pdf

O significado disso é muito óbvio: de acordo com o estudo o estado não deveria perder seu tempo a não ser fazer algo que multiplica por 25 o dinheiro investido! O que não fica claro é como isso é possível. A explicação apresentada no jornal é o chamado multiplicador keneysiano. As pessoas inclusas no projeto fazem girar as engrenagens econômicas.

Bom, é díficil acreditar que demanda simplesmente gere renda... Existe um interessante post do Guilherme Stein "A Miséria do Multiplicador Keynesiano: A Lei de Say corretamente entendida", sobre esse problema. Talvez o programa tenha afetado a economia local (regiões com mais bolsas famílias distribuídas), e o jornal "estrategicamente" omitiu esse fato.

(Será? Bom houve uma longa discussão sobre o assunto no blog do JPK).

É até vazio dizer mais alguma coisa sem ter acesso ao trabalho (tive acesso e publicarei os resultado). Por outro lado, as pessoas que criticam o projeto (sem pesar seus benefícios) parecem que estão anos luz de conhecer os fatos; Simplesmente não dá para discutir se o projeto é ou não bom. Isso é ponto pacífico. Algumas discussões cabíveis: por que publicar que o bolsa família aumenta o PIB? Como melhorar o projeto?

Bolsa Esmola - Melhor programa ever

2009-09-24T10:27:00.000-07:00

Tomo esse post como uma nota mental: "o bolsa esmola é o melhor programa ever". Comecemos pelos básico... O governo é uma máquina pesada, pesadíssima. O imposto brasileiro incomoda, drena 40% da renda. Isso deveria tornar o país numa social democracia: duas pessoas trabalham para sustentar uma terceira. Mas, por "algum motivo" a renda não é distribuida.

Uma pessoa do grupo dos 1% mais ricos "pode gastar em três dias o equivalente ao que um brasileiro do grupo dos 10% mais pobres levaria um ano para gastar". Ou ainda, a riqueza dos 1% mais ricos corresponde a renda dos 45% mais pobres. Uau... Comparemos isso com outros países do mundo, e encontramos 11 países em situação pior (dos 212 países analisados pela ONU): Namíbia, Lesoto, Serra Leoa, República Centro-Africana, Botsuana, Bolívia, Haiti, Colômbia, Paraguai, África do Sul. Parece ruim, não é!? Bom, é pior.
A parcela de 1% mais rico da população é aquela que tem renda per capita igual ou superior a R$4500,00.

Então voltemos ao problema do governo.. O super estado com um monte de funcionários, escolas, universidades, etc... consumindo recursos e mais recursos, não consegue fazer o óbvio: tirar esses milhões de brasileiros da miséria (uma distribuição equalitária de 33% da renda seria suficiente para isso). Mas o que? Que absurdo! Sair por ai distribuindo o meu dinheiro suado!!! Deixa para lá... É mais justo o governo saquear 40% da renda para não fazer nada, né!?

Do Browser para Impressora - Considerações Finais

2008-08-13T15:36:00.001-07:00

Problemas com XML-FO
Solução Flying Saucer

Apesar de ser apreciável a iniciativa da Apache com o XML-FO, o Apache FOP não está suficiente maduro para ser utilizado em qualquer
ocasião. Uma interessante alternativa é outro projeto que realiza uma transformação XSL mas diretamente para PDF. Esse é o projeto Flying
Saucer, que contém entre outras coisas suporte para CSS3. Para o meu problema, O Flying Saucer tem mostrado como a melhor solução em termos de precisão além de contar com qualidades como flexibilidade e eficiência.

Podemos verificar no projeto que ele faz uso do iText para gerar o arquivo PDF, mas tem a possibilidade de utilizar renderizadores para arquivos de saída diferentes.

Procedimento necessário

Instalar o Flying Saucer e suas dependências no Classpath do seu projeto. No caso de um projeto WEB, adicionar as bibliotecas no
diretório WEB-INF.

Utilizar o JAPX (The Java API for XML Processing ) para converter um arquivo XML num documento DOM (org.w3c.dom.Document).


DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
InputSource inputSource = new InputSource(new InputStreamReader(arrayInputStream, "ISO-8859-1"));
builder.setEntityResolver(new CatalogResolver());
Document doc = builder.parse(inputSource);

Passar o documento para o Flying Saucer:


ByteArrayOutputStream bos = new ByteArrayOutputStream();
ITextRenderer renderer = new ITextRenderer();
renderer.setDocument(doc, rootPath);
renderer.layout();
renderer.createPDF(bos);

PROBLEMAS COM ANÁLISE SINTÁTICA
Solução XML Catalog

Cabe aqui uma observação sobre o uso do Docbuilder – o analisador sintático (parser) de XML da especificação JAPX. O comportamento padrão do DocumentBuilder é processar o arquivo de origem com base nos recursos descritos nele mesmo, incluindo seus descritores como o DTD ou
XSD. O problema que a declaração do tipo do documento (Document Type Declaration or Doctype) geralmente aponta para a URL do publicador. Por exemplo :


DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd

E especificações grandes como o Xhtml são particionados em vários fragmentos dtd que apontam para outros resultando numa míriade de documentos virtualmente remotos.

Para que o Docbuilder faça a análise sintática, é necessário que o processo tenha acesso a essas localizações. Num servidor de aplicação, acessos remotos poderiam ser impedido por questões de segurança. Nesse caso é preciso ter uma cópia de cada recurso localmente e utilizar um proxy que converta as localizações virtualmente remotas para os arquivos locais.

Na verdade, seria possível abrir arquivo por arquivo e procurar as referências remotas e trocá-las por referências locais, mas isso poderia dar um trabalho demasiado grande e sujeito a erros.

XML CatalogO propósito do XML Catalog da Apache Foundation (explicado em detalhes nesse artigo) é servir de proxy para o analisador sintático encontrar os recursos descritos nos documentos com localizações universais. A solução é bem simples. Uma objeto (Factory) cria o proxy com base num arquivo properties localizado no mesmo nível que o classloader. Isso é feito de forma transparente, ao instanciar um objeto da classe CatalogResolver.

A solução passo a passo seria a seguinte:

Procure o projeto catalog da apache. Coloque o resolver.jar no seu classpath... (WEB-INF,etc)

Baixe o sgml-lib da w3c. Adicione o contéudo do sgml-lib no diretório de códigos-fonte da sua aplicação.

Adicione também o arquivo Catalog.properties.


relative-catalogs=no
catalogs=sgml-lib/xml.soc
verbosity=0
prefer=system
allow-oasis-xml-catalog-pi=no
static-catalog=yes

E adiciona o suporte ao catálogo no Parser.

builder.setEntityResolver(new CatalogResolver());

Problemas com Mime Type
Solução: Especificar o Mime Type

Ter um arquivo PDF em memória, não garante sua renderização correta no cliente. Essa questão é resolvida com atributos MIME. Aespecificação dos Servlet descreve como os tipos MIME podem ser especificados na interface de resposta (Response) do Servlet.

 response.setContentType("application/pdf");
response.setHeader("Content-disposition", "attachment; filename=NotaFiscal.pdf");
response.setContentLength(bos.size());
OutputStream os = response.getOutputStream();
bos.writeTo(os);
os.flush();
os.close();

Problemas com o processo manual de imprissão
Solução: Incluir Javascript no PDF

Em casos extremos, fornecer um arquivo PDF para o usuário, com o Adobe Acrobat Reader instalado em sua máquina não é o suficiente paraque ele se sinta a vontade para imprimir o documento corretamente. Para evitar maiores transtornos com a parte de treinamente, é possível automatizar o processo de impressão.

Para isso, felizmente, o arquivo PDF permite a inclusão de scripts que, por sua vez, permitem a interação entre os recurso da máquinacliente e o documento a ser exibido/imprimido. É uma excelente oportunidade para demonstrar como a API do iText pode incluir Script em um PDF ao mesmo tempo que automatizo a ação de imprimir na máquina cliente. Para realizar tal tarefa é necessário duplicar o documento a ser imprimido.

 PdfReader reader = new PdfReader(bytes);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
com.lowagie.text.Document document = new com.lowagie.text.Document(new Rectangle(585, 936), 0 ,0 ,0 ,0);
PdfWriter writer = PdfWriter.getInstance(document, bos);
document.open();
PdfContentByte cb = writer.getDirectContent();
document.newPage();
PdfImportedPage page = writer.getImportedPage(reader, 1);
cb.addTemplate(page, 0, 0);

Agora, basta incluir o fragmento Javascript via PDFWriter:


writer.addJavaScript("this.print({bUI: false,bSilent: false,bShrinkToFit: true});" + "\r\n"+ "this.closeDoc();");
document.close();
return bos;

Ufa! Isso é tudo.

Do Browser para Impressora - Parte 3

2008-08-13T15:29:00.000-07:00

Teoricamente, recuperar a saída de um Servlet (em geral um documento em texto como o HTML, mas pode ser qualquer arquivo incluso na resposta do servidor) mesmo que seja um JSP, deveria ser fácil. O JSP é convertido em uma classe Java que segue uma interface da especificação do Java Servlet com todas os métodos necessários para recuperar sua saída. Infelizmente, as classes geradas encontram-se em um contexto que o Classloader que executa os servlets não tem acesso. Então, para acessar as saídas dos JSPs é necessário uma abordagem mais indiretas. Na arquitetura J2EE, temos os seguintes recursos à nossa disposição:

Filtros: antes do envio da resposta ao cliente a cadeia de filtros intercepta a mensagem e pode enviar uma nova mensagem baseado na mensagem interceptada;
RequestDispatcher.include: esse (novo) método permite um servlet programaticamente adicionar o conteúdo de outro, o que é semelhante a tag jsp:include;
new URL(urlLocation).openStream: método que abre uma conexão com a localização urlLocation e retorna um stream de dados para leitura;

A solução utilizando url.openstream é simples, mas exige uma nova conexão para o servidor de aplicação proveniente dele mesmo. E é preciso tomar o cuidado utilizar a mesma sessão do usuário. Para isso, basta concatenar a url solicitada como jsessionId.

Adapter Pattern

O uso de filtros ou do include method exige o uso de classes que sigam assinatura HttpServletResponse e do ServletOutputStream e que ao mesmo tempo, guarde as informações das chamadas em algum tipo de repositório. Essa é uma interessante aplicação do Adapter Pattern. O Adapter Pattern pode ser sumarizado da seguinte maneira.

Problema: (Múltipla herança) É desejado o comportamento de um objeto que infelizmente não segue uma assinatura específica.

Solução: Criar uma classe que implemente a interface e direcione as chamadas de forma apropriada ao objeto cujo comportamento é desejado.

Sendo o repositório escolhido para informações, um vetor de bytes. Escolhemos o ByteArrayOutputStream, que pode ser visto como um OutputStream e cujo resultado é guardado no vetor de bytes. Isso nos permite criar um objeto adaptado a interface ServletOutputStream e cuja implementação fica a cargo do ByteArrayOutputStream. Facilita também, utlizar o PrintWriter que já realiza as operações de Writer do ServletOutputStream. Esse PrintWriter deverá escrever diretamente no objeto ByteArrayOutputStream. Isso é feito ao passarmos esse objeto no construtor do PrintWriter.

Uma vez que temos essa classe, implementar a classe ServletResponse é muito simples:

public class FakeServletResponse extends HttpServletResponseWrapper{

private ByteArrayOutputStream contentBuffer;

private PrintWriter writer;

private FakeServletOutputStream servletOutputStream;

public FakeServletResponse(HttpServletResponse response) {

super(response);

}

public PrintWriter getWriter() {

if(writer == null){

contentBuffer = new ByteArrayOutputStream();

writer = new PrintWriter(contentBuffer);

servletOutputStream = new FakeServletOutputStream(writer, contentBuffer);

}

return writer;

}

public ServletOutputStream getOutputStream() throws IOException {

getWriter();

return servletOutputStream;

}

public byte[] getData() {

getWriter().flush();

return contentBuffer.toByteArray();

}

E então podemos utilizar o include method:

private FakeServletResponse includeJsp(ActionMapping mapping, ActionForm form, HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException {

request.getSession().setAttribute("geraNota", Boolean.TRUE);

FakeServletResponse fakeServletResponse = new FakeServletResponse(response);

BuscaNotaAction buscaNotaAction = new BuscaNotaAction();

buscaNotaAction.execute(mapping, form, request, fakeServletResponse);

RequestDispatcher requestDispatcher = request.getRequestDispatcher("/jsp/operacoes/notaFiscal/imprimeNota.jsp");

requestDispatcher.include(request, fakeServletResponse);

return fakeServletResponse;

}

Do Browser para Impressora - Parte 2

2008-07-23T11:47:00.000-07:00

Ao invés de utilizar o browser para enviar um documento HTML para a impressora, podemos fazer uso de técnicas mais indiretas. Para isso, devemos utilizar um padrão que facilite manipulação de seu conteúdo. O padrão apropriado é o XHTML. Antes de explicar como o XHTML pode ser usado para transformação de um documentos em comandos de impressão, consideremos outros benefícios de se utilizar o XHTML no lugar do HTML.

XHTML

Uma das interessantes convergências tecnológicas é o padrão XML. O XML é uma especificação de texto com marcações derivado do SGML, que utiliza uma gramática mais restrita.

Por uma especificação de texto com marcações eu quero dizer que o XML possui marcadores que definem uma certa propriedade do texto: por exemplo que um certo fragmento é um paragrafo (

Isso é um parágrafo

), ou o nome de diretor de cinema(Tim Burton, etc. Por uma gramática mais restrita eu quero dizer que a definição do que pode e o que não pode no XML é mais simples. Para maiores informações veja: diferenças entre o HTML e o XML.

Essas características tornam mais fácil a construção de analisadores sintáticos. Por esse motivo, o XML é utilizado como base para uma gama de atividades relacionadas com troca de informações por arquivo texto. O XHTML foi criado para agregar, ao HTML, esses valores.

O XHTML é basicamente o padrão HTML como algumas adaptações para contemplar as restrições do XML. Nada muito complicado. E esse rigor trouxe algumas vantagens adicionais:
Adaptabilidade – o conteúdo é facilmente convertido para outros formatos;
Previsibilidade – enquanto existe um padrão definido para renderizar um documento HTML o mesmo não acontece para um documento mal-formatado. Um navegador ao renderizar um documento desse tipo entra no modo chamado quirks. Não existe um padrão para o modo quirks de tal sorte que o resultado pode variar em cada navegador. A fácil verificação que um documento é aderente a especificação do XHTML torna supérfluo a renderização por modo quirks. Também, os criadores de parser são guiados por uma especificação mais simples o que os leva a cometer menos erros;
Legibilidade – o documento é mais legível para máquinas e seres humanos devido a simplicidade da gramática;

Vejamos esse primeiro quesito. O XHTML permite o uso de uma família de linguagens de transformação chamado XSL (Extensible Stylesheet Language). O XSL é a definição da W3C que trata transformações no XML. Essa tecnologia define como um XML pode ser transformado para um XHTML, um arquivo texto qualquer ou num XSL-FO. É possível inclusive delegar aos navegadores essa tarefa de transformação. Muitos navegadores modernos, inclusive o Internet Explorer 5.0 suportam o uso do XSL para realizar transformações nos documentos.

XML-FO

XML-FO é um padrão de descrição para impressão. O XML-FO não possui todos os detalhes da impressão, mas é suficientemente rico para conter grande parte das descrições utilizadas na impressão. Note que o XML-FO é também um documento que segue a especificação XML. Basicamente, seu uso consiste de uma transformação subseqüente em que o documento é finalmente convertido para um de impressão: tipicamente o PDF.

No site da Antenna House é possível encontrar scripts de transformação do XHTML para fo ( xhtml2fo.xsl). Agora, com o uso de bibliotecas de manipulação do XML como o Xalan, é possível com um comando converter o XHTML para XSL-FO.

java -classpath $CLASSPATH org.apache.xalan.xslt.Process -IN -XSL xhtml2fo.xsl -OUT -tt

Docbook

Para exemplificar o mecanismo de transformação de um XML para PDF, vou utilizar um script Ant que utilizo para converter meus arquivos docbook para PDF. Para o XHTML o mecanismo é o mesmo, o que muda é o arquivo XSL responsável pela transformação.

Docbook que é uma linguagem própria para documentação cujo enfoque é a semântica. A filosofia básica por trás do Docbook é discriminar o valor semântico de cada parte de um texto. Por exemplo: para um computador o fragmento

título

não significa necessariamente o começo de uma seção ou capítulo; No Docbook é possível especificar exatamente esse tipo de informação (começo ou fim de uma seção, capítulos, ênfase, etc)... mas o padrão não fala nada sobre a formatação. Fica a cargo de outros mecanismos cuidarem para que elementos sejam corretamente formatados.

Um projeto para converter o docbook poderia conter os seguintes elementos:

Ambiente de desenvolvimento com Java 1.4, Apache Ant e Apache Fop (já inclui o Xalan e o Xerces) instalados.
Diretório src incluindo os fontes em docbook.
Diretório output onde serão gerados os arquivos em pdf.

Na raiz do projeto, poderia ser criado o script do Ant (build.xml) responsável por invocar as classes responsáveis pelo processamento. O Ant dispõe de mecanismos para invocar a máquina virtual do Java para executar um comando específico. Felizmente, nem mesmo isso é necessário, porque essas bibliotecas já dispõe de tags para que realizam a transformação do documentos:

xslt classpathref="xalan.classpath" style="${fo.stylesheet}" extension=".fo" basedir="${source.dir}" destdir="${fo.dir}"
include name="${target.name}.xml" /
/xslt

fop format="application/pdf" fofile="${fo.dir}/${target.name}.fo" outfile="${fo.dir}/${target.name}.pdf" /

Filme: Obrigado Por Fumar

2008-07-18T06:14:00.001-07:00

Obrigado Por Fumar (Thank you for Smoking) - 2006

Filme escrito e dirigido por Jason Reitman, produzido por David Sacks e baseado na novela de Christopher Buckley. Duração de 92 minutos.

"Obrigado Por Fumar" é um aclamado filme, vencedor do globo de ouro 2006 e sucesso em bilheterias (com faturamento superior a 39 milhões de dólares). O filme conta a história de Nick Naylor (Aaron Eckhart), vice-presidente da empresa Academia do Estudo do Tabaco, um lobby da indústria tabagista, e como ele usa suas habilidades de persuação para defender os interesses de seus superiores.

Direção muito interessante: ao contrário do que se pode esperar, o filme não mostra um quadro contaminado por fumaça em que o próprio telespectador tenha dificuldades em respirar. Aliás, o filme não mostra nehuma pessoa fumando. Também não faz uma crítica raivosa à indústria do cigarro. Seus argumentos são sutis, inteligentes e bem-humorados. Mas, a mensagem não passa despercebida pelo público, apenas não o agride. Por exemplo, logo no começo do filme Nick se apresenta como um representante de um dos maiores assassinos: a indústria tabagista, responsável por mais de 100 mil mortes nos EUA. Num dos encontros com o M.O. D. (do Inglês “Merchants of Death”, mercadores da morte, uma espécie de esquadrão das indústrias que mais matam: armamentista, tabagista e a de bebidas alcoólicas), Nick provoca seus colegas, lançando uma competição para determinar qual das indústrias teria matado mais. Dessa forma, o filme brinca com a sátira e o cinismo dos personagens caricaturais (cada um, como uma metonímia, representa a própria indústria à qual se quer criticar) sem cair no maniqueísmo, nem no melodrama.

A história começa num talkshow onde os convidados são Nick, representantes de associações anti-tabagistas e um garoto que adquiriu câncer depois de fumar. Diante de uma platéia hostil e de uma situação delicada, Nick reverte o jogo fazendo com que pareça que a indústria do Fumo apoia o garoto com câncer, ao passo que os anti-tabagistas o condenam:

“É do nosso maior interesse manter Robin vivo e fumando. As pessoas contra o fumo querem que Robin morra”.

Assim, logo na primeira cena, é possível ter uma noção de como os diálogos irão se desenvolver. O filme é uma seqüência de situações em que o personagem principal usa (e abusa) de seu poder de persuasão e argumentação para atingir os objetivos de quem representa. No decorrer da narrativa, a vida profissional desse insensível, porém extremamente perspicaz, lobista é despudoradamente retratada. No entanto, para não cair na armadilha do maniqueísmo, o filme também constrói a imagem de Nick como um sujeito simpático e pai carinhoso, que quer seu filho por perto e precisa conviver com a desaprovação da ex-esposa em relação à influência que seu trabalho e estilo de vida exercem sobre o garoto.

O maior opositor de Nick Naylor é o Senador Ortolan Finistirre (William H. Macy), um ambientalista de Vermont que quer introduzir na legislação uma lei solicitando a figura de caveira com ossos cruzados nas estampas dos pacotes de cigarro. Porém, em todos os embates entre os dois, Nick parece sair sempre vitorioso. Inclusive, o filme acaba logo após o derradeiro desses embates.

No plano profissional, após a aparição no talkshow, Nick consegue convencer seu chefe a empreender sua influência na indústria do entretenimento e colocar de volta cenas de estrelas fumando nos filmes. Tais idéias e iniciativas são bem rebecidas pelo misterioso bilionário Captain, czar da indústria do Tabaco, que incumbe à Nick a missão de, presentear com uma pasta abarrotada de dinheiro o famoso cowboy dos comerciais da Malboro. O intuito do presente é corromper o vaqueiro para dissuadi-lo de prejudicar a indústria tabagista pelo fato de ter contraído câncer. Ao inferir que o caubói aceita o dinheiro, mais uma vez, o filme joga com a elasticidade da ética e dos valores morais de cada personagem.

Nas cenas que mostram o envolvimento de Nick com a jornalista, Heather Holloway (Katie Holmes), as distorções morais ficam bem claras, principalmente quando ele a diz que sua motivação é pagar a hipoteca. Mais à frente, a jornalista repete a mesma desculpa depois de seduzi-lo para escrever uma matéria bombástica, que temporariamente destrói a carreira de Nick.

Assim, mais importe que questionar os valores da indústria tabagista é a forma como o filme disserta sobre a poder da sedução e, principalmente, da persuasão e de como eles flexibilizam os princípios éticos e valores morais. Os argumentos dessa dissertação estão pulverizados por todo filme e são mais visíveis nos trechos em que o personagem principal conversa com seu filho Joey explicando e defendendo seu trabalho. Por exemplo, no dia da carreira, o senhor Naylor explica para a classe de Joey: “Assim como as estrelas de cinema, minha profissão é conversar”. Naylor, por fim, coloca em dúvida a autoridade dos adultos para falar sobre determinados assuntos: “Quem disse isso? (...) Minha opinião é que vocês devam pensar por si próprios.”

Em outra cena, o filho pede ajuda ao pai para responder uma lição de casa: “Por que o sistema americano é o melhor sistema do mundo?”. “Foi sua professora que formulou essa questão?” _ questiona. Naylor então explica que essa questão é vazia. O menino poderia responder o que ele quisesse porque não se pode afirmar que o sistema americano é o melhor do mundo.

Nessa linha, o que ocorre também numa cena, em que, na missão de convencer Hollywood a colocar cenas de pessoas fumando, o lobista leva seu filho consigo. Após as reuniões de negócio, mais uma vez os dois personagens dialogam e o filho questiona sobre a questão moral do trabalho do pai: “e se você não estiver certo?”. Nick alega que defender a indústria tabagista é como defender um sabor de soverte.”Não existe quem está certo”. A distância entre os dois pontos dessa analogia não é ignorada pelo garoto que insiste com o pai que não falava de sabores de sorvete. Naylor conclui que cabe às pessoas a decisão e é importante que usufruam da liberdade de escolha.

Where does AMD go to?

2008-07-17T18:59:00.000-07:00

7 trimestres consecutivos no vermelho!!! E o que podemos esperar da AMD? Ok! Você pode não gostar da AMD, mas acentuar o monopólio da Intel não seria o futuro dourado para o mercado de computadores.

Acho que o pior já passou. As maiores besteiras da AMD já foram feitas. Ex: atraso de uma CPU decente por 14 meses (se é que podemos chamar o "fraco" Phenom 9950 como decente). Finalmente a AMD trouxe novidades que despertam interesse além da mera apelação de preços baixos. São eles o Chipset 780g, o Radeon HD4800 e o Ultra Puma (plataforma para notebook) .

Primeiro, o elogiado chipset 780g é o primeiro processador gráfico integrado que pode substituir uma placa-gráfica de "verdade". E ainda pode trabalhar em conjunto com as placas da série HD3400 tornando (o conjuto) comparáveis as HD3800. Sem contar que consome menos energia e são beeeem mais baratos.

Depois, a série HD4800 que desbanca a poderosa Nvidia gtx 260 e gtx 280 em dois aspectos. O primeiro aspecto é o desempenho: temos o HD4870 superior ao gtx 260 e o HD4870 x2 superior ao gtx 280. Depois o preço... a série estava bem mais barata que o salgados preços da concorrência. Tanto que a Ndivia já baixo em mais de 30% o preço de suas placas e elas continuam, digamos, 30% mais caras. Wow. Quem diria isso depois do fiasco da série 3800.

Finalmente o Ultra Puma... Vamos à história:
Eu nunca me baseei no nome de um fabricante para comprar um computador. Acho que a Intel abusa do fato de ser a líder do setor e cobra bem mais caro por seus produtos. Mas, ultimamente a Intel tem praticado preços compatíveis: suas melhores CPUs podem ser o dobro do preço por dispor do dobro do desempenho. Justíssimo! Embora as CPU de desempenho medianos e inferiores (low e mid-market) são mais caras que a concorrente por dispor do logo azul, e ainda, a Intel aproveitar para ganhar com os demais componentes da arquitetura (como a placa-mãe). Placas-mãe da arquitetura AMD são geralmente 50% mais baratas do que as "equivalentes" Intel.

Exatamente por esses motivos que os computadores daqui de casa são AMD. Como eu nunca comprei os computadores high market, não vi sentido em pagar mais para usufruir do mesmo desempenho. Bom... todos os computadores, com uma exceção: o notebook. Até pouco tempo atrás era impossível encontrar um notebook a preço e desempenhos competitivos da marca AMD. Meu pobre notebook é um Kennex dual Core T2130 , 2Gb de RAM, 120Gb HDD Sata, (etc blá blá) com um detalhe interessante... uma placa de vídeo HD2300. Tudo isso por módicos 2000 reais.

Mas uma pena... após o lançamento do Ultra Puma é possível encontrar um notebook HP com Ultra Turion 2.4GHz, 2Gb de RAM, 160Gb HDD Sata (etc blá blá) com o processador onboard HD3200 (graças ao mobile 780g) por módicos 700 dólares. Aproximadamente o preço do Kennex graças aos custos de importação daqui do Brasil com o dobro do desempenho (e da durabilidade da bateria).

Opa! A AMD volta a vida. Ou quase... Infelizmente, para a AMD, as críticas não pontuam com precisão os atributos de suas plataformas. Não é incomum você encontrar, na comparação de Phenom com os Core 2 Duo, placas de vídeo High Market. Isso é injusto porque tira a vantagem da plataforma AMD de já vir com uma placa de vídeo (chipset 780g) que entre outras coisas realiza decodificações multimídia.

Enquanto que a ausência de placas de vídeos não fazem sentido para computadores acima de 800 dólares, esse não é o mercado mais comum para maior parte dos países em desenvolvimento, como o Brasil. Pagamos cerca de três vezes em dólares PPP o preço de um notebook. Então precisamos considerar faixas de valores mais estreitos. Isso me leva a seguinte análise:

	Core 2 Duo Q6600 250USD			Phenom 9950 250USD
Categorias/Quesitos	Custo ao Consumidor	3DMark06	Explicação	Custo ao Consumidor	3DMark06	Explicação

Own IGP Onboard	100	300	Intel 775pin	80	3000	780g
Better IGP Onboard	70	1500	Nvidia 7050	80	3000	780g
Low Offboard + mainboard	120	2000	HD3400	130	4500	780g + Hybrid CrossFire
Mid Offboard + mainboard	220	4000	HD3850	130	4500	780g + Hybrid CrossFire
HighMid Offboard +mainboard	260	6000	HD4850	260	6000	HD4850
High End OffBoard + Mainboard (CrossFireX)	380	8000	HD4870	380	8000	HD4870

Adicionais
+High End Mainboard	100	9000	HD4870 + mainboard DDR3 + E6600
+High End CPU	300	10000	HD4870 + mainboard DDR3 + Q9550

Essa tabela resume a comparação das plataformas Intel e AMD considerando preços médios (google products) e benchmarks disponíveis na internet (Tom Hardware, etc). Podemos ver que a AMD não pode oferecer CPUs competitivas para os verdadeiros entusiastas. Mas enquanto o conjunto CPU + GPU + Placa-Mãe não ultrapassa 400 dólares, a AMD mostra uma vantagem consistente.

Fica os segmentos de mercados designados para cada companhia, particionado pelo poder aquisitivo. Isso não é nenhuma virada da empresa do logo verde, mas já é um alívio para o mercado a beira do monopólio.

E para quem quiser saber do HP de 700 dólares... aqui está!

Analisando o Debian

2008-07-05T13:30:00.000-07:00

Já faz algum tempo que eu estudo as comunidades de software livre. Para mim, sempre foi um desafio conseguir analisá-las de uma forma sistemática e consistente. Em 2006, eu pensei em materializar meu estudo. Tive várias idéias, mas pouca coisa foi implementado. Uma dessas idéias era avaliar o "poder" de uma comunidade pela dependência que outros projetos teriam do projeto dessa comunidade. Essa análise poderia ser feita com ajuda do sistema de pacotes do Debian.
O Debian é uma das mais reconhecidads distribuições do Linux, sendo base para várias outras distribuições como Ubuntu, Knopixx, etc. O que a distribuição Debian fez, que as outras distribuições não fizeram foi trazer um sistema eficiente para instalação de programas ao Sistema Operacional. O eficiente sistema de pacotes do Debian é baseado no utilitário apt-get que antes de baixar e instalar o programa desejado com um simples comando, descobre todas as dependências (e as dependências das dependências) daquele pacote e caso algum esteja faltando, pergunta ao usuário se quer as instalar tais dependências. Se o usuário confirmar a seleção, o utilitário baixa e instala todas as dependências e, lógico, o progama escolhido.
Analisando o código fonte do apt-get, eu descobri que toda a informação de depedências encontra-se no arquivo Packages de uma distribuição debian. O arquivo Packages é um arquivo texto com blocos de informações sobre cada um dos pacotes.


Package: 3270-common
Priority: optional
Section: net
Installed-Size: 96
Maintainer: Bastian Blank 
Architecture: i386
Source: ibm-3270
Version: 3.3.4p6-3.3
Depends: libc6 (>= 2.3.6-6)
Recommends: x3270 (= 3.3.4p6-3.3) | c3270 (= 3.3.4p6-3.3), pr3287 (= 3.3.4p6-3.3)
Filename: pool/main/i/ibm-3270/3270-common_3.3.4p6-3.3_i386.deb
Size: 21910
MD5sum: 209bb0595c53421c433f4524147d6335
SHA1: c89e5ef06fa0978b5a0935c90273b5c5997b2142
SHA256: 881cf62382b9e1945155bdd366645d9660c1848aaab3a58e73d2bdfaa49301ae
Description: Common files for IBM 3270 emulators and pr3287
3270-common contains files referenced in other 3270 packages

Bom, agora é hora de procurar uma ferramenta já disponível para trabalhar com grafos. Tenho uma experiência negativa com SGB (Stanford Graph Base, do Donald Knuth), então espero que o arcabouço que eu encontrar seja mais amigável. E eis que surge o jung (Java Universal Network Graph).

Bom, é muito simples utilizar o JUNG e ele fornece um monte de coisas como diversos algoritmos diferentes de visualização, análise de grafos, etc. Munido desse poderoso arcabouço tentei VISUALIZAR O DEBIAN. Parece ser uma tarefa bem mais complicada do que eu imaginei...

Ciência do Trânsito

2008-06-28T17:35:00.000-07:00

Com todo a tecnologia que mudou a sua paisagem, o homem moderno se acostumou a olhar o congestionamento como apenas mais uma mazela urbana. Encontrar certas vias engarrafadas no final das tardes ou no começo da manhã se tornou uma rotina. Mas compreender o funcionamento dessa complexa rede de transporte afim de propor alternativas coerentes e eficientes não é uma tarefa para qualquer um.

Motivados por isso, engenheiros, cientistas e urbanistas começaram a estudar o trânsito como uma ciência. Essa é origem do livro A física do trânsito do especialista na teoria de trânsito veicular, Boris Kerner, físico pesquisador da Daimler Chrysler na Alemanha. No livro, Kerner explica que o princípio da teoria do trânsito está na definição de três fase para o trânsito.

A primeira é o que ele chama de fluxo livre (do inglês, free flow). Nas condições de fluxo livre, o motorista pode escolher a velocidade e o comportamento que desejar. Mesmo que um motorista trafegue em velocidade mais lenta, outros motoristas conseguem se desviar dele.

Se a quantidade de veículos aumenta, os motoristas não terão opção senão guiar na mesma velocidade do carro mais lento da pista, porque para evitar colisões, os veículos guiam em velocidade igual ou inferior ao veículo a frente ou tentam escolher uma pista em melhor situação. Com o número de veículos suficiente, todos as pistas estarão em situação semelhante. O fluxo já não é livre, mas é sincronizado (synchronised flow). Todos juntos, a uma velocidade sincronizada, eventualmente chegam a algum lugar. Como a avenida Rebouças, em São Paulo, pouco antes do horário de pico. Os carros seguem lado a lado, quase encostados em seus vizinhos. A velocidade beira os 40km/h, mas, considerando o caos subseqüente, que pode (e normalmente vai) se instaurar, está ótimo. Nessa hora o motorista tem a noção desesperadora de que, se ocorrer um acidente ali na frente, o trânsito terá problemas, mas segue otimista, com fé na ordem natural das coisas.

No entanto, esse mesmo equilíbrio delicado pode ser abruptamente interrompido por, digamos, um eventual pneu furado em algum veículo. A partir desse instante, o trânsito se torna instável e o que Boris Kerner chama de congestionamentos dinâmicos (moving jams) começam a emergir. Os veículos se movem durante breves intervalos e voltam a esperar o movimento dos veículos da frente ou pela luz verde do semáforo.

É interessante notar como os físicos comparam os veículos com partículas conscientes. Diferente das moléculas, os veículos evitam colisões enquanto tentam se mover. Esse esforço para atingir seus destinos e evitar colisões agem de forma similar as forças de atração causadas pelas pontes de hidrogênio na água. Isso sugere que a densidade de veículos tem efeito semelhante ao calor na água. Se o calor aumenta, as partículas se movem mais rapidamente até que as pontes de hidrogênio não consigam mais aglutinar as moléculas levando ao estado gasoso. Quando as moléculas de água cedem energia, as forças de coesão acabam aglutinando as moléculas, primeiro para o estado líquido e por fim para o estado sólido.

A analogia serve ao trânsito como uma luva. No fluxo livre, os veículos agem como se estivessem no estado gasoso, bastante disperso, e com liberdade de movimentos e velocidades bem diferentes. No fluxo sincronizado, os veículos seguem em velocidades similares como um líquido escoando e no congestionamento, os veículos se movem como o teto de uma caverna de gelo que parte degela e enquanto outra parte congela.

Para saber mais:

- http://physicsworld.com/cws/article/print/996

- http://www.thp.uni-koeln.de/~as/Mypage/traffic.html

- http://en.wikipedia.org/wiki/Fundamental_diagram_of_traffic_flow

- http://en.wikipedia.org/wiki/Three_phase_traffic_theory

Editado: Analogia com a água e referências.

Could Reactos be good for community?

2008-06-28T13:33:00.000-07:00

Many Foss evangelists could not understand how the ReactOS project is so important. So, despite my poor English knowledge, I will try to summarize some important questions here.

First, Open Source is about choice, freedom, words that do not go with with monopoly even when the monopolist is an open software foundation or project. The bigger the community, the more human resources it will have. However, lesser will be the voice of each member. So, conflicting ideas may lie in different communities of different sizes, proportional to its acceptance. Once implemented, that idea could seem more interesting than another and change the equilibrium of these communities to its side. So, in the long term, the fragmentation of a community could be better than a mere monopoly. And Reactos is an amazing ideia, for example, to fully use all drivers, softwares, architecture from the dominant operation system.So, many things already exist, it will be a waste to rewrite everything because of pure arrogance.

Second, Windows compatibility is a very very important thing, nowadays. Focusing only on Foss community, more than 30% of all projects in Sourceforge are only targeted Windows Plataform. Outside Foss world, how may programs in use were developed only for Windows? There is a real problem of installed base of applications not to be ignored. Windows compatibility will benefit the market by weakening monopolist forces such as Metcalf Law, Cost of Transition, etc... In the end, with Windows compatibility, your investment in software will not be a hostage to a company.

Shall we (re)summarize it?

_ ReactOS is a very healthy manifestation of freedom.
_ How good is software reuse? How good is it to be able use all drivers, softwares, architecture already made for Windows?
_ Windows compatibiltiy is not a "would be" but a "must be" in IT manangemant nowadays.
_ And last but not least, ReactOS strengthens Windows user's position against Redmont's giant, at the same time it weakens the inherently monopolist forces of software market (Metcalf Law, Cost of Transition, etc).

Do HTML para impressora - Parte 1

2008-04-17T23:00:00.000-07:00

Certas vezes, nós nos deparamos como a necessidade de fazer um objeto de apresentação para situações bem diferentes como o Browser e a impressora. A briga é boa: podemos criar objetos especializados para cada meio ou criar um objeto versátil o suficiente para atender os meios alvos. A seguinte proposta se guia pelo segundo caso objetivando a codificação de um único código para realizar uma tarefa específica.

Imagine uma aplicação com a seguinte funcionalidade: A aplicação tem basicamente a função de buscar notas por um certo critério, exibir e imprimir a nota procurada. Um operador informa os campos chaves da nota. No passo seguinte, a aplicação devolve uma página com os dados da nota e uma formatação que mimetize ao máximo o layout originial da nota. Eventualmente, como essa nota está integrada a uma aplicação web, a página conterá outras “informações” como logo, links de navegação etc que não tem nada a ver com a nota mas apenas com a aplicação que a contém.
Sem um tratamento adequado, o conteúdo da página não pode ser utilizado na impressão da nota dentro nos específicos formulários. Felizmente para isso, o HTML e CSS fornecem um ferramental que permite escolher informações que cabem a renderização em um contexto e não em outros. O atributo media da tag “link” do HTML permite que um determinado estilo seja aplicado para uma mídia específica como tela ou impressora. Além disso, atributos CSS 2 permitem excluir itens da renderização. Com esses dois conceitos, é possível escolher os elementos que serão apresentados em uma mídia e em outra não, e como serão apresentados. Finalmente o CSS 3 traz atributos específicos a impressão como tamanho da página, margens, etc que ajudam a definir com precisão o layout da impressão.
Nessa implementação, será criado um arquivo de estilo destinado a impressão (printer.css) que é ligado ao HTML pelo comando abaixo.

link rel="stylesheet" type="text/css" href="/css/printer.css" media="print"

O Arquivo é definido como abaixo:
body {
font-family : sans-serif;
font-size : 12px;
margin: 0%;
padding: 0%;
width: 8.125in;
}
.advertising {
display : none !important;
}
.hideToPrint {
display : none !important;
}
.transparentPrint{
visibility: hidden !important;
}
* {
border-collapse: collapse !important;
}
td {
border:none !important;
}

img {
display : none;
}
@page{
margin : 0%;
size: 8.125in 13in; /* width height */
}
Observe que a classe transparentPrint utiliza um atributo de visibilidade enquanto que a classe hideToPrint utiliza um atributo que define se um objeto deve participar da renderização. Objetos com atributos ocultos ocupam o espaço que seriam renderizados. Na verdade eles são renderizados como se fossem transparentes. Já os objetos com atributo display: none não ocupam espaço. No nosso caso, esse recurso é utilizado para os cabeçalhos ocuparem os espaços necessários no formulário sem que sejam imprimidos (os cabeçalhos dos campos dos formulários já estão impressos).
A página com a nota é definida com mesma escala e precisão do formulário. Por exemplo, para um formulário é definido em polegadas (8 ¼ x 13), da mesma forma que os campos. Utilizamos a definição de página:
@page{
size: 8.125in 13in; /* width height */
}
No HTML (ou JSP), definimos os campos com o mesmo cuidado:
tr class="transparentPrint table_header" style="height: 0.375in"
td style="width: 7.5in"/td
td style="width: 0.625in; font-weight: bolder;"Nº/td
/tr
tr style="height: 0.25in"
td style="width: 7.5in" /td
td style="width: 0.625in;"
bean:write name="nota" property="numeroNota" /
/td
/tr

Com isso, conseguimos definir um HTML com definições precisas para impressão e visualização. Num cenário mais simples poderíamos associar um comando Javascript no botão de impressão.

input type="button" class="hideToPrint" value="imprimir" onclick='window.print();'/

Infelizmente, os navegadores de Internet interferem na impressão com suas próprias definições do tamanho do papel, margens e até cabeçalhos e rodapés o que nos impede tomarmos tal abordagem.

Javascripting in Java

2008-04-17T09:12:00.000-07:00

Linguagens dinâmicas apresentam várias vantagens sobre as linguagens compiladas. Uma dessas vantagens é a habilidade de adicionar código em tempo de execução com facilidade. Por exemplo, imagine um servidor que de alguma forma receba e processe comandos. Num ambiente Java (onde o servidor é um programa Java assim como os comandos são objetos Java) é um certo malabarismo com o Classloader para fazer isso.

http://www.javaworld.com/javaworld/jw-06-2006/jw-0612-dynamic.html?page=2

Enquanto que esse dinamismo é ainda “sustentável” para Classes, a situação é mais complicada para fragmentos de código. Nesse caso é preciso compilar uma classe Java e carregá-la. Com Javascript, a situação é outra. Uma vez que a linguagem é interpretada, é simplesmente trivial adicionar fragmentos de código. Para provar isso vou implementar um programa que imprime gráficos, para funções arbitrárias de uma variável x “real” (aliás, radicalmente arbitrárias... não irei nem mesmo validar se a entrada é de fato uma função).

Inicialmente definimos uma interface para a função. Não queremos que o código cliente seja impregnado com detalhes técnicos do funcionamento do javax.script. Queremos definir a interface mais simples possível sem comprometer o desempenho da aplicação.

 public interface Function {
  double[] function(double xInit, double xfinal, double step);

  public double function(double x);
 }

Agora faremos teste com uma função bem conhecida x^2 (ou f(x) = x*x). Aqui o teste unitário da função:

 /**
  * Test of function method, of class RhinoCalc.
  */
 @Test
 public void functionXQuadrado() throws Exception {
  setFunction();
  double xInit = 0.0;
  double xfinal = 10.0;
  double step = 1;
  double[] result = function.function(xInit, xfinal, step);
  assertTrue(Arrays.equals(new double[] { 0, 1, 4, 9, 16, 25, 36, 49, 64,
    81, 0 }, result));
  for (int i = 0; i < result.length; i++) {
   System.out.println(result[i]);
  }
 }

Para implementar a classe vou seguir os passos mais simples para adicionar o Javascript. Isso se resume a carregar o motor de scripts, adicionar a função e realizar a chamada necessária.Para carregar o motor de scripts:

 public RhinoFunction() {
  ScriptEngineManager mgr = new ScriptEngineManager();
  jsEngine = mgr.getEngineByName("JavaScript");
 }

Atribuir uma função arbitrária:

 public void setFunction(String function) throws ScriptException {
  jsEngine.eval("function f(x) { \n" + " return  " + function + ";}");
  invocableEngine = (Invocable) jsEngine;
 }

e invocar uma função:

 public double function(double x) {
  try {
   return (Double) invocableEngine.invokeFunction("f", x);
  } catch (Exception e) {
   Logger.getLogger(RhinoFunction.class.getName()).log(Level.SEVERE,
     null, e);
   throw new RuntimeException(e);
  }
 }

 public double[] function(double xInit, double xfinal, double step) {
  double deltaX = xfinal - xInit;
  int size = (int) Math.ceil(deltaX / step);
  double[] result = new double[size + 1];
  int i = 0;
  for (double x = xInit; x < xfinal; x += step, i++) {
   try {
    result[i] = (Double) invocableEngine.invokeFunction("f", x);
   } catch (Exception ex) {
    Logger.getLogger(RhinoFunction.class.getName()).log(
      Level.SEVERE, null, ex);
    throw new RuntimeException(ex);
   }
  }
  return result;
 }

Agora um teste que exige mais desempenho. Podemos utilizar a classe para gerar gráficos de funções. Aqui um modelo que resume o funcionamento dessas classes:Ao pressionar o botão “plot” o seguinte método atualiza o modelo do plano cartesiano e solicita a atualização do painel.

 private void plotButtonActionPerformed(java.awt.event.ActionEvent evt) {
  CartesianPanel painel = (CartesianPanel) this.graphicPanel;
  try {
   rhinoFunction.setFunction(polinomioTextField.getText());
  } catch (ScriptException e) {
   e.printStackTrace();
   JOptionPane
    .showMessageDialog(
    this,
    "O interpretador não conseguiu interpretar a função escrita.",
    "Função Inválida", JOptionPane.ERROR_MESSAGE);
  }
  painel.setFunction(rhinoFunction);
  double initialX = Double.parseDouble(initialXTextField.getText());
  double finalX = Double.parseDouble(xFinalTextField.getText());
  double initialY = Double.parseDouble(initialYTextField.getText());
  double finalY = Double.parseDouble(finalYTextField.getText());
  painel.getCartesianPlan().setDimension(initialX, finalX, initialY, finalY);
  painel.repaint();
 }

Eu adicionei alguns métodos de “zoom” com o mouse de forma que o programa tivesse mais dinamismo. Essas funcionalidades foram implementadas tanto no painel do desenho que sofre a ação como numa classe especialista “adapter” para o mouse. Isso é praticamente um completo programa de “plot” extramente simples e compacto que ilustra as facilidades do JFC e javax.script.Outras ConsideraçõesClaro que o exemplo poderia ser estendido para compreender outros conceitos e funcionalidades facilmente implementadas com JFC (como a possibilidade de impressão do gráfico), a habilidade de desenhar retângulos com a área selecionada, a possibilidade de arrastar o gráfico deslocando o ponto inicial, etc. Mas isso vai longe: uma longa caminhada do ArcTest para o Kplot... http://java.sun.com/applets/jdk/1.4/demo/applets/ArcTest/example1.htmlhttp://edu.kde.org/kmplot/

Objetos versus Arquivos (Squeak vs Eclipse)

2008-04-02T04:18:00.001-07:00

Objetos ou Arquivos

No Unix, os arquivos são utilizados como a metáfora comum para uma ampla variedade de propósitos. Nesse mundo, dispositivos, processos, recursos do sistema são mostrados como arquivos. Apesar das limitações, esse é um conveniente meio de realizar diversas tarefas administrativas. Operações com direcionamento são utilizados de forma sistemática para arquivos ou dispositivos (ex: ls > ls.txt ou ls > /dev/lpt1 ). No windows, todos recursos são objetos, inclusive os arquivos. Isso também proporciona uma forma conveniente para manipular tais conceitos. Mas, não vemos no Windows a mesma facilidade de manipulação para fins administrativos que temos no Unix.

Um cenário semelhante acontece com as plataformas de desenvolvimento. De um lado, temos o Java/Eclipse, onde cada classe é representado por arquivos do SO e do outro lado, Smalltalk/Squeak as classes são objetos armazenados em memória e de alguma maneira persistido no computador (a tal imagem da área de trabalho). No caso dessas duas plataformas, fico com o Java, porque ela não me bloqueia a alteração das classes. Basta um bloco de notas para fazer alterações. Assim, é possível delegar para outros programas funções como backup, transmissão de informação, versionamento.... O que é mais fácil, compartilhar uma classe em Java ou em Smalltalk!? E, dentro do ambiente Eclipse, temos quase a sensação que a classe não é um mero arquivo, mas de fato um modelo de objeto, com propriedades e funções, com várias formas de se apresentar.

Não quero aqui desprezar a idéia da representação de objetos, mas reforçar a idéia de que a interoperabilidade é peça fundamental na arquitetura de um sistema. Vale mais um monte de arquivos, que se possa manipular da forma do que objetos que sejam de difícieis de mexer.

Ask me - The Smiths

2008-03-14T04:19:00.001-07:00

Shyness is nice, and
Shyness can stop you
From doing all the things in life
You'd like to

Shyness is nice, and
Shyness can stop you
From doing all the things in life
You'd like to

So, if there's something you'd like to try
If there's something you'd like to try
ASK ME - I WON'T SAY "NO" - HOW COULD I ?

Coyness is nice, and
Coyness can stop you
From saying all the things in
Life you'd like to

So, if there's something you'd like to try
If there's something you'd like to try
ASK ME - I WON'T SAY "NO" - HOW COULD I ?

Spending warm Summer days indoors
Writing frightening verse
To a buck-toothed girl in Luxembourg

ASK ME, ASK ME, ASK ME
ASK ME, ASK ME, ASK ME

Because if it's not Love
Then it's the Bomb, the Bomb, the Bomb, the Bomb, the Bomb, the Bomb, the Bomb
That will bring us together

Nature is a language - can't you read ?
Nature is a language - can't you read ?

SO ... ASK ME, ASK ME, ASK ME
ASK ME, ASK ME, ASK ME

Because if it's not Love
Then it's the Bomb, the Bomb, the Bomb, the Bomb, the Bomb, the Bomb, the Bomb
That will bring us together

If it's not Love
Then it's the Bomb
Then it's the Bomb
That will bring us together

SO ... ASK ME, ASK ME, ASK ME
ASK ME, ASK ME, ASK ME
Oh, la ...

Servlet - Mensagens Assíncronas

2008-03-02T05:06:00.000-08:00

Meu trabalho de conclusão de curso foi sobre um sistema de comunicação de bibliotecas. Desenvolvi o trabalho inicialmente nas aulas de XP e mais tarde, junto com o co-autor da monografia, Leandro Bororo.

Todo o trabalho gira em torno de dois problemas: exportar os dados da base para um formato especial, denominado MARC, e importar os dados desse formato para o banco. Podemos separar isso na discussão legal e na discussão chata. A discussão chata é justamente os objetivos básicos do projeto supracitados. A discussão legal é como criar uma interface WEB para esse componente que permita o acompanhamento do processo de importação ou exportação. Obviamente vou falar sobre o segundo caso.

Desenvolver uma interface WEB para o MARC não é nenhum problema. No entanto, acompanhar a importação/exportação e permitir que o sistema trabalhe com arquivos grandes (mais de 10 megabytes) é outra história. A própria natureza de uma aplicação WEB torna a solução síncrona problemática. A análise de um arquivo MARC pode demorar bastante. O suficiente para a conexão HTTP (cliente-servidor) finalizar por timeout. Além disso, não seria a implementação mais responsiva (se todas as informações são direcionadas para a saída padrão, essas serão exibidas com sorte na linha de comando ou em algum arquivo de registro do servidor, em todo caso, não visível para o cliente). Para resolver isso, o tratamento da informação deveria ser assíncrono.

Inicialmente, poderíamos pensar em enviar as mensagens diretamente para o browser. Mas isso não é possível fazer diretamente. De fato, é o navegador faz as solicitações (request) de um certo recurso (disponível numa localização específica - URL). Uma alternativa seria o uso de Ajax (Asynchronous Javascript And XML) que daria a sensação de que o browser é capaz receber notificações do servidor. Na verdade, no Ajax, é o navegador que faz chamadas remotas de tempos em tempos (sem que o usuário tome alguma ação específica). O fato de a primeira requisição bloquear.

Abaixo, segue o funcionamento da comunicação síncrona entre Browser e servidor que mostra porque o browser irá bloquear ao enviar o arquivo para processamento:

public Response processar (Request request) {
   // magia negra para pegar arquivo do request 
   File file = pegaArquivo(request);
   
 // magia negra para processar o  arquivo
   Resposta resposta = processa(arquivo);
   
 // magia para transformar resposta em  response
   return transforma(resposta); 
 }

A conversa do navegador com o servidor é feito por ciclos de requisições e respostas. Se for necessário que numa requisição o servidor processe um dado arquivo, é preciso esperar todo o processamento para se obter a resposta do servidor. Pode-se separar o processamento da submissão do arquivo, delegando a responsabilidade para outro processo. Exemplo:

public Response processar (Request request) {
  // magia negra para pegar arquivo do request
     File file = pegaArquivo(request);
  
 // apenas grava o arquivo.. uma outra linha de execução processa o arquivo.  
     grava(arquivo); 
     return paginaSucesso();
 }

Se o processamento do arquivo é feito na mesma linha de execução da submissão, o cliente só terá uma resposta após o processamento do arquivo.

Para o servidor processar o arquivo de forma assíncrona é necessário que primeiro um "Servlet" processe e grava o arquivo num repositório temporário (seja ele uma fila JMS, um caixa de email, um diretório, etc) e um outro processo, de tempos em tempos, verifique o conteúdo desse repositório.

Esse outro processo pode atualizar um arquivo de log a medida que for necessário (por exmplo: a medida que os registros Marcs forem processados) . Dessa forma, o cliente poderá "requisitar" o conteúdo do arquivo quantas vezes quiser.

// isso é fácil...
 public Resposta processar(Request request) {
  descobreIdArquivo(request);
  // conteúdo atual do arquivo
  String arquivo = leArquivo(idArquivo);
  return converteParaResponse(arquivo);
 }

A síntese da solução é a seguinte: Num primeiro momento o usuário faria o "upload" do arquivo. Depois o usuário deveria listar o arquivo em importação e consultar os detalhes da importação. O mesmo pode ser feito para a exportação. Uma fila de mensagens assíncronas e um processo em execução paralela devem ser implementados.

Implementamos o processo da seguinte maneira:

O servidor recebe um arquivo, via FormFile (essa classe é um utilitário da biblioteca commons-upload [do projeto Commons da Apache Software Foundation] para tratar multipart/form-data de uma requisição HTTP) e o grava num diretório específico. Em seguida, envia um objeto comando como mensagem para uma fila (com o nome do arquivo já atribuído a uma de suas propriedades). Por outro lado, o sistema mantém uma reserva (pool) de trabalhadores que consomem os "trabalhos" enviados para a fila. Cada processamento é registrado por um registrador (logger) num mapa cuja chave é o nome do arquivo. Um Servlet controla o ciclo de vida desses trabalhadores. Os trabalhadores devem por isso, realizar pequenos blocos de operações e verificar se pode executar o próximo bloco, para evitar bloquear o servidor caso seja necessário reiniciá-lo. Abaixo, segue como foi implementado o trabalhador:

 @Override
 public void run() {
  try {
   while (condicao) {
    Command command = works.take();
    if (NO_MORE_WORK == command) {
     break;
    }
    try {
     while (command.hasWork() && condicao) {
      command.process();
     }
    } catch (Exception e) {
     e.printStackTrace();
    }
    command.finish();
   }
  } catch (InterruptedException e) {
  }
 }

Nesse trecho de código, o objeto works representa a fila de trabalhos (BlockingQueue do pacote utilitário de concorrência do Java 1.5 e superiores). Ele será o repositório da comunicação Produtor-Consumidor. Command é a classe que implementa o padrão Command [Gof], o comando que será executado. A variável condicao permite que o trabalhador verifique se deve continuar a execução do trabalho atual. Aqui a implementação do comando para a Importação do MARC:

 private class ImportMarcCommand extends Command {
  private LenientMarcStreamReader reader;
  private MarcManager marcManager;
  private FileInputStream inputStream;
  private String nomeArquivo;
  private FileChannel channel;

  @Override
  public boolean hasWork() {
   return reader.hasNext();
  }

  @Override
  public void process() throws Exception {
   marcManager.parse(reader.next());
   marcManager.getLog().setAvailable(channel.position());
  }

  public ImportMarcCommand(String nomeDoArquivo, boolean sobrescreveItem,
    boolean sobrescreveExemplar) throws NamingException,
    IOException {
   marcManager = new MarcManager(sobrescreveItem, sobrescreveExemplar);
   Logger.getInstance().getLogs().add(marcManager.getLog());
   this.nomeArquivo = nomeDoArquivo;
   File file = new File(nomeDoArquivo);
   inputStream = new FileInputStream(file);
   channel = inputStream.getChannel();
   marcManager.getLog().setInitialAvailable(file.length());
   reader = new LenientMarcStreamReader(inputStream);
  }

  @Override
  public void finish() {
   marcManager.getLog().setFinalDate(new Date());
   // vou fechar o stream por educação. se eu não conseguir, não vou
   // ligar.
   if (inputStream != null) {
    try {
     inputStream.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   // tenta apagar educadamente.
   File f = new File(nomeArquivo);
   if (!f.exists() && !f.canWrite()) {
    f.delete();
   }
  }
 }

Algumas observações:

O ImportMarcCommand processa um registro MARC por vez (então, o processo pode ser finalizado logo que o registro atual for processado).

O objeto reader é responsável por identificar o registro e mover o indicador da posição de leitura do arquivo.

O objeto channel permite que essa informação (sobre o indicador da posição seja computado) seja computada no cálculo do total decorrido.

O Logger é o repositório com as informações sobre o histórico de cada processamento (tempo inicial, final , etc).

No método finish, é registrado o fim do processamento e o arquivo é apagado.

 public class ThreadMonitorServlet extends HttpServlet {
  private static final long serialVersionUID = 1L;

  @Override
  public void destroy() {
   for (int i = 0; i < workers.length; i++) {
    workers[i].setCondicao(false);
    try {
     queue.put(ImportWorker.NO_MORE_WORK);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
   super.destroy();
  }

  static final int capacity = 10;
  final int numWorkers = 3;
  public static BlockingQueue queue = new ArrayBlockingQueue(
    capacity);
  ImportWorker[] workers = new ImportWorker[numWorkers];

  @Override
  public void init(ServletConfig servletConfig) throws ServletException {
   super.init(servletConfig);
   for (int i = 0; i < workers.length; i++) {
    workers[i] = new ImportWorker(queue);
    workers[i].start();
   }
  }
 }

O método init recebe o evento de inicialização do servidor. Nesse momento, o Servlet "contrata" os trabalhadores que serão responsáveis pelo processamento dos comandos, isso é, o Servlet atribui a lista de trabalho e inicia as threads. No método destroy o Servlet recebe o evento para finalizar e então muda a condição de execução das threads de tal forma que elas parem sua execução.Declarado no web.xml da seguinte maneira:


    <servlet>

        <servlet-name>monitor</servlet-name>

        <servlet-class>

            br.usp.ime.colmeia.async.ThreadMonitorServlet

        </servlet-class>

        <load-on-startup>1</load-on-startup>

    </servlet>

Depois disso, tem-se a ação para listar a situação do processamento de cada arquivo.

GPGPU - Parte I

2008-02-11T16:55:00.000-08:00

Utilizando a placa de vídeo para realizar operações matriciais.

Essa é uma idéia que ouço desde quando entrei na USP em 1998. Basicamente, as placas de vídeo são capazes de realizar operações matriciais de "uma só vez". Peço aos mais entendidos que me corrijam quando eu estiver (muito) errado.

Isso pode parecer meio estranho mas muitas das transformações de imagens apresentadas por sua placa de vídeo são série de transformações lineares. Dito isso, é um desperdício de tempo e processamento multiplicar uma matriz por outra com três laços aninhados! Aliás, é um desperdício deixar sua planilha eletrônica resolver equações lineares e outros problemas lineares computando um elemento da planilha por vez.

Chegou a hora de dar um basta nisso. Já não era sem tempo. Com avanço das placas de vídeo e das linguagens de renderização (pasmem! eu pensei que isso já seria possível a 10 anos atrás) é possível, por exemplo, multiplicar um vetor por um escalar em tempo constante.

Vamos por colocar as mãos na massa... O que é necessário ? Pelo que eu investiguei, é preciso do OpenGL 2.0 (mais especificamente o GLSL que a linguagem de programação de shaders) ou uma das edições recentes do DirectX (9 em diante).

Peraí... alguém me explica: isso é complicado mesmo ou por que ninguém fez nada até agora? E pra que essa linguagem GLSL. Porque, conforme veremos, enviar blocos de código para a Placa de Vídeo executar requer uma certa sofisticação tecnológica que tanto a Kronos como os fabricantes de placas de vídeo não nos deram.

Um passo por vez... o que é OpenGL? Isso pode parecer uma pergunta besta mas na verdade entender o significado do OpenGL ajuda a compreender a sofisticação do processo. O OpenGL não é uma API para interagir com a placa de vídeo! Nada disso... o OpenGL é na verdade uma API para a renderização de gráficos. O programador dispõe de uma linguagem para descrever o modelo gráfico que desejar e os drivers das placas de vídeo (que implementam o OpenGL) transformam esse modelo em chamadas de baixo nível para a placa. Essa últimas realizam as computações necessárias e emitem seus resultados para o monitor.

Veja que o programador não programa diretamente a placa para realizar as operações lineares. Também, observe quanto o OpenGL é diferente do DirectX que fornece através do seu componente Direct3D chamadas de baixo nível a placa de vídeo (o que favorece o desenvolvimento de jogos _ Por outro lado, a linguagem de renderização do OpenGL favorece o desenvolvimento de programas gráficos profissionais). Perceba que no OpenGL o desenvolvedor descreve os vários conceitos presentes no o 3D Studio : cenário, fontes de iluminação, textura dos objetos, a câmera etc. Bom é através de um mapeamento desses conceitos para a computação tradicional é que é possível implementar o GPGPU.

A Mino Carta: "Narciso acha feio o que não é espelho"

2007-08-13T19:15:00.000-07:00

Em sua postagem em 01 de agosto de 2007, intitulado "Caixa Preta" o senhor Mino Carta coloca a questão do aeroporto de Congonhas como um problema inventado pela oposição para arranhar a imagem do governo:

Ocorre que nos empenhamos em praticar o verdadeiro jornalismo, baseado, em primeiro lugar, na verdade factual. Que eu saiba, ninguém se queixava, até três semanas atrás, nem graúdo, nem miúdo, quanto à localização do aeroporto, embora protestasse, com razão, contra o apagão, contra os atrasos constantes e insuportáveis. Os defeitos de Congonhas só passaram a ser apontados depois do acidente, o qual, nas circunstâncias, ocorreria de qualquer maneira. Tal é a verdade factual, assim como o são as chuvas torrenciais que desabaram sobre São Paulo.

Indignado, (será que as convicções políticas do Mino Carta interferiram em sua memória!? Custava fazer uma pesquisa e verificar a verdade de suas afirmações!?) postei em seu blog:

Mino,

O senhor está de brincadeira! Quantos paulistanos já não reclamaram do Aeroporto !? Na televisão, um sem número de vezes. Até no Faustão já apareceu uma cidadã se queixando e o apresentador ironizou ao dizer que daqui a pouco um avião deveria pousar em cima do outro no aeroporto. Francamente, estamos cansados de Congonhas e já faz muito tempo.

Logo, uma legião de fãs começou a defender o jornalista (divirtam-se). Chamo a atenção para o comentário de um de seus defensores, o Francenildo:

Ao sabidão logo abaixo: traga uma só, uminha, qualquer que seja, matéria que prove o que dizes sobre as tais frequentes reclamações da mídia e dos paulistas cansados, relacionadas à Congonhas. Está óbvio que os paulistas se indignaram tanto que ficaram cansados, ou melhor, fartos e exaustos com o monstruoso problema de ter que descer, contrariados, num aeroporto tão mal localizado. Lembro o rapaz que a autorização para operar Airbus foi dada pelo privata-mor fhc, pai do filho que a tua mídia nunca soube...mas traga notícias anteriores ao começo do golpe, ok?. Vamos lá, pela certeza com que repreendestes o Mino deves ter muitas delas à nos mostrar, não é mesmo?

O que coloco a seguir é o que não foi publicado pela censura do senhor Mino Carta:
Primeiro que fiz a seguinte busca no google: aeroporto congonhas, para verificar quantos links eu precisaria percorrer para encontrar uma, "uminha só", notícia que falasse mal de Congonhas antes da data fatídica: 17 de julho. Quarto Resultado... Globo Online... Avião derrapa no Aeroporto de Congonhas, postado no dia 16 de julho.

Postei a respota mais ou menos assim:
Respondendo ao senhor Reginaldo, segue o link tal publicado que o quarto resultado da busca no google por Aeroporto de Congonhas.

Claro que eu fui um tosco com esta respostinha medíocre. Minha esposa tratou de fazer uma intervenção bem mais didática:

Dê uma olhada nessas notícias referentes ao aeroporto de congonhas:

http://g1.globo.com/Noticias/SaoPaulo/0,,AA1335284-5605,00.html

http://www.tvcultura.com.br/reportereco/materia.asp?materiaid=440

Foram anteriores ao acidente, para citar alguns exemplos. Aliás, Lygia Horta, citada nas reportagens, ajudou a fundar a Associação dos Moradores de Moema em 1986 para, entre outras coisas, reclamar do aeroporto.

Mas, para falar em reclamações graúdas, que tal uma ação civil pública contra a Anac e a Infraero, onde vc poderá ler frases do tipo: “Quantas vidas mais serão colocadas em risco para que medidas efetivas e satisfatórias sejam tomadas? Quantos incidentes ainda terão que ocorrer para que as autoridades se conscientizem dos valores constitucionais máximos, dentre eles o direito à vida e à integridade física?” (p. 24)
Vale lembrar q a ação foi movida em 24 de janeiro deste ano, ou seja, mais de 6 meses antes da tragédia.
Veja o texto na íntegra aqui (aliás, vc pode ver no corpo do texto da ação, diversas notícias de jornais apontando problemas no aeroporto desde bem antes da tragédia):

http://producao.prsp.mpf.gov.br/news/internews/intcong.pdf

Resumo da ópera, de vez em quando falamos sem saber dos fatos. Isso pode acontecer com qualquer um, inclusive com o nosso querido Mino Carta. ;)

Conclusão... depois de postado isto, o blog não aceitou mais nenhum comentário exceto este:

enviado por: Maurício Gil
Conciso e preciso.
Parabéns, mais uma vez.
Em: 13/08/2007 11:43:53

Mino/Narciso, cuidado para não se afogar nesse rio virtual chamado internet, onde há pouco ou nenhum lugar para aqueles que não aceitam críticas e sim apenas elogios...idéias refletidas no espelho de seu ego.

O argumento anti-álcool

2007-08-10T08:10:00.000-07:00

A lógica contra a produção do álcool é mais ou menos a seguinte:

Os produtores capitalistas, produtores do combustível de humanos e máquinas irão preferir vender combustível mais caro para os mais ricos do que comida barata para os mais pobres. Máquinas e homens irão competir por combustível... Mas enquanto os ricos terão dinheiro para comprar comida e combustível o que sobrará aos pobres!? Vale lembrar que não importa se a produção é de cana ou de milho, a competição é pela terra e não pelo grão. Ainda, mesmo que o país agrícola taxe o produtor de combustível de maneira diferenciada ao produtor de comida, o governo teria maiores dificuldades em repartir o "bolo", haja vista que os governos que temos não são as instituições mais eficientes e, além do que, a comida estará mais cara.

Ora, esquecem os "amigos" comunistas que a venda de biocombustível dará aos países agrícolas uma oportunidade ímpar de participar da economia mundial como protagonistas, e não meros figurantes. Isso trará mais justiça à economia mundial (melhorará a distribuição de renda entre países ricos e pobres), mas é bom lembrar que o maior fator de atraso dos países do Terceiro Mundo, não é a ordem mundial. O biocombustível tornará os "países agrícolas" mais ricos porém não mais justos.

Os governos dos países agrícolas terão mais trabalho em dividir a riqueza. Mas, seria este o grande mal? Parece discurso de governante incompetente.

Initial Post

2007-08-10T06:24:00.000-07:00

Apenas para avisar (aos desavisados) sobre o título: eu não pretendo colocar 42 opiniões neste blog. Nem, 42 opiniões em cada post. Nem um série de 2, 3 e 7 opiniões, etc, etc. Foi só uma forma de dizer que este blog não é sobre nada em específico ao mesmo tempo que é sobre tudo.