O Peczenyj

Mudando de endereço

2009-01-03T15:22:00.002-03:00

Foram centenas de posts desde que comecei a usar o blogspot como valvula de escape.

Agora adquiri um domínio próprio e estou usando o wordpress como engine de blog, com MediaWiki para salvar os posts mais importantes daqui.

Atualizem os seus feeds: pacman.blog.br, estou desativando este site. Obrigado a todos pela audiência :)

Novas Distribuições Linux

2008-12-22T13:44:00.003-03:00

Diariamente eu leio noticias sobre novas distribuições, brasileiras ou internacionais.

Até que ponto isso é realmente necessário? Não seria melhor tentar focar em uma das excelentes distribuições que existem hoje em dia ou então tentar ajudar a manutenção de pacotes ou mesmo traduzir documentação?

Acho que produzir uma distribuição é um bom aprendizado, porém produzir algo que sera dificil de manter e atualizar pode ser bem penoso.

Tirando o Mofo

2008-11-24T18:26:00.004-03:00

Fiquei uns dias sem postar, hehe.

Tive pouco tempo livre, afinal além de pegar alguns projetos novos (e ter que aprender muito no processo) ainda tem a faculdade, que agora chega ao fim do semestre com algumas provas.

Nesse tempo também participei de alguns eventos legais, a começar pelo workshop de design patterns ministrado pelo Bruce Eckel (Thinking in Java, Thinking in C++). Foram 3 dias imerso em um mundo de orientação a objetos com exemplos em Java e Python. O Bruce é um cara muito bacana, tive a oportunidade de conversar bastante com ele e descobri que tinhamos algo em comum: uma graduação em física incompleta (chegamos a conclusão que não foi um tempo perdido pois aprendemos a resolver problemas, ou pelo menos demorar bastante tempo até desistir). Também tive a oportunidade de participar de um Coding Dojo onde resolvemos o problema da notação de trits (ao contrário, diga-se de passagem) usando Haskell. A ideia do Dojo é sensacional!

Também participei da PyConBrasil 2008. Foi um evento muito bom, excelente organização, sem falar que a sessão aberta com o Bruce sobre os rumos do Python foi o ponto forte, que surgiu totalmente do acaso. Python é uma linguagem muito interessante, com uma comunidade consideravel. Quem não usa python devido a indentação obrigatória do código usa um dos argumentos mais ridículos possiveis :)

Outro evento sensacional foi o workshop de Domain-Driven Design ministrado pelo Philip Calçado na Caelum/RJ. DDD é sobre comunicação, um ponto essencial no desenvolvimento de software nos dias de hoje. O Phillip foi responsavel, ainda que indiretamente, pela minha vinda a globo.com, porém só agora pudemos tomar aquele chopp e conversar sem ter 12 horas de diferença.

Sabado passado começou o curso on-line e intensivo de BDD on Rails com RSpec ministrado pelo Danilo Sato pela eGenial. Esta valendo a pena, pois parte daquela premissa que sempre defendi que temos que testar o nosso código e, para isso, existem varias abordagens e frameworks.

Estou preparando outros posts, devo atualizar este blog em breve.

Fear, uncertainty and doubt

2008-10-24T10:02:00.003-03:00

Fear, uncertainty and doubt (ou simplesmente FUD) não é algo novo. Volta e meia alguma instituição ou candidato a utiliza de forma a enfraquecer o(s) seu(s) adversário(s), geralmente os projetos open-source são vitimas frequentes.

Hoje, no Rio de Janeiro haverá o ultimo debate entre os candidatos a prefeito. Não sou de usar blog técnico como meio de propaganda politica porém não posso ficar de braços cruzados enquanto um candidato utiliza FUD, Boatos e Mentiras. Aqui e aqui vemos alguns exemplos extremamente baixos, que qualquer pessoa com um minimo de instrução deveria perceber. Até quando isso será permitido? E o TRE? E os panfletos apócrifos apreendidos?

Felizmente o outro candidato, cujo partido possui uma cor verde interessante, não responde na mesma moeda pois seria facil usar coisas desse tipo, mas que não acrescentam nada.

Realmente a melhor forma de se proteger do FUD é informando a população, cobrando das autoridades cabíveis e destacando o quão antiético é esse tipo de abordagem. Felizmente cada cidade tem o prefeito que merece.

Policia do RS usa MSN

2008-10-07T14:06:00.003-03:00

Pelo que eu vejo nesse link, a Policia do RS está utilizando o MSN, que é um messenger bem comum hoje em dia, para receber chamados de socorro.

Com protocolos livres como o Jabber e clientes livres como o Pidgin, sera que uma alternativa mais barata e eficiente não poderia ser desenhada?

Da forma como é hoje, um serviço de segurança esta nas mãos de software/serviço e protocolo proprietário e fechado, e isso me preocupa como cidadão!

Chrome: o browser da google

2008-09-02T16:48:00.007-03:00

As noticias apareceram em todas os sites especializados: o google estaria lançando hoje uma novidade chamada chrome, um browser baseado em Webkit disponivel por enquanto para Windows XP e Vista.

Até um gibi foi disponibilizado, então esperando até as 4 PM consegui fazer o download em uma maquina virtual e pude testa-lo um pouco.

A performance parece ser muito boa, apesar da virtualização. Não observei travamentos ou comportamentos estranhos (como os que ocorrem no Safari para Windows). O visual e as tabs são realmente práticas, com muita área para ver o site e icones intuitivos.

Bem interessante é o gerenciador de tarefas, (Controlar Pagina Atual > Desenvolvedor) onde podemos ver o consumo de cpu, memória e rede de cada aba (que rodam como processos independentes).

E também temos acesso a informações de memória bem detalhadas (infelizmente estáticas, gostaria que houvesse algo como o top do unix, quem sabe no futuro...).
]

O histórico é limpo e muito bonito

E um recurso que eu gostei bastante do novo Opera, mas com uma nova roupagem: ao abrir uma nova aba temos uma pagina com os favoritos e snapshots das paginas.

Por fim, basta instalar com um clique o plugin flash para navegar no Youtube ou Globo Videos

Outras coisas que percebi: a pergunta para salvar as senhas dos sites é muito mais discreta, aparecendo acima do site após o login (não é aquele alert que surge do nada). O Gmail parece ter uma boa performance e o gtalk funcionou sem maiores problemas. Com 6 abas o consumo de memória foi de 144408k - e ainda podemos comparar com outros browsers abertos!

Sinto falta de usar '/' para fazer pesquisas na pagina (quem usa Vim entende disso) mas o Ctrl + F funciona bem. Para configurar o tamanho da fonte basta usar Ctrl + (mais) e Ctrl - (menos) para alterar o tamanho do texto, Ctrl 0 para voltar ao normal. E, a mais interessante, não há necessidade de um campo de texto para pesquisas rapidas ao google ou outro buscador: basta digitar os termos no lugar da url (bem intuitivo, aliás). O download de algum arquivo é simples e bonito também.

Bom, até então eu gostei, só aguardo a versão para Linux e quero por as mãos no tão falado codigo fonte logo-logo :)

Link para download: http://gears.google.com/chrome

Edit: o Chrome tem o mesmo problema que o Firefox tinha para gerenciar senhas: ele mostra a senha sem pudor algum:

Poderia ter um recurso mais seguro como o da senha mestra do Firefox, parece que não pensaram (tanto) na nossa privacidade. Quem sabe no futuro isso não será corrigido?

Despedida do Antonio

2008-08-29T21:13:00.003-03:00

Esta foi a ultima semana do Antonio na globo.com. A despedida foi em grande estilo, com direito a galeria gourmet. Fica o exemplo e a saudade desse grande colega.

Em clima de festa com direito a montinho e tudo:

Fico feliz por ter surpreendido do Antonio nesses poucos meses que trabalhei com ele, agora os desafios são outros (aka Expurgo...)!

Toninho, boa sorte no Yahoo!

SQL Injection - A fina arte de criar paginas realmente inseguras

2008-08-25T13:11:00.005-03:00

Este post diz tudo:

Por mais que existam alertas sobre os perigos de SQL Injection, muita gente resolve ignorar e criar sistemas cujas consultas ao banco de dados são feitas através de concatenações de strings com os dados oriundos do usuário.

Uma das primeiras coisas que aprendi quando trabalhava como testador foi tentar este código em telas de login:

' or '1' ='1



Imagine que o impacto dessa belezinha em uma query como esta:

"SELECT USUARIO FROM TABELA WHERE USUARIO = '" + usuario + "' AND SENHA = '" + senha + "'"

temos, então:

SELECT USUARIO FROM TABELA WHERE USUARIO = 'qqCoisa' AND SENHA = '' or '1' ='1'


Consegui efetuar o login devido a extrema preguiça do desenvolvedor que nunca se interessou em estudar um pouco de segurança, muito menos sabe o que é um prepared statement. Isso no melhor dos casos, posso querer inserir um DROP TABLE da vida facilmente, pois o sistema está, literalmente, de pernas abertas.

Recentemente um colega testou esse tipo de ataque contra um site de uma instituição por curiosidade. Ele conseguiu obter um arquivo contento a senha e o IP do banco de dados e conseguiu acessa-lo, perceberam o perigo?

Sinceramente? Se eu vejo um site que cai nesse truque eu não sinto pena. Não vou zoar ou fazer algo maléfico, as vezes até tento avisar, mas não sei se vale a pena: ou o sistema custou muito barato ou custou muito caro, foi produzido por uma consultoria que lucou 1980% em cima do salario do estágiario e que, por mais documentos que tenham produzido não conseguiram fazer algo básico: um site seguro contra hackers que estudam pela Wikipedia.

Se o seu site não pode receber aspas simples, duplas ou %, tenha MUITO medo, pois alguem VAI fazer algo em breve...



Closures em Java - Parte 2
2008-08-11T10:48:00.003-03:00
Ainda sobre a Closures do java 7, agora será possivel fazer isso:

public class A {
        public static void main(String args[]) {
            @Shared int acumulador = 0;

            {int => int } xxx  = { int i =>  acumulador += i; i};

            System.out.println(xxx.invoke(1));
            System.out.println(xxx.invoke(2));
            System.out.println(xxx.invoke(3));
            System.out.println("o valor do acumulador eh " + acumulador );

        }
}


Só eu estou achando divertido?

http://gafter.blogspot.com/2008/08/java-closures-prototype-feature.html


Closures em Java
2008-08-08T19:23:00.003-03:00
Olha o que vai ter no java 1.7

public class A {
        public static void main(String args[]) {
                exec( { int a, int b => a + b });
                exec( { int a, int b => a * b });
                exec( { int a, int b => 
                        System.out.println("closure " + a + ":" + b); 
                        (a * a) + (b * b) 
                });
        }
        public static void exec({ int, int => int } closure){
                System.out.println(closure.invoke(3,2));
        }
}


$ java -Xbootclasspath/p:./closures-2008-08-04/lib/closures.jar   A
5
6
closure 3:2
13


Divertido :)

Fonte:
http://guj.com.br/posts/list/99477.java


Parsing de XML na linguagem ABC
2008-08-08T15:01:00.002-03:00
A maior parte das linguagens de progração em uso pelo mundo tem pelo menos 1024 bibliotecas para trabalhar com arquivos XML. Me espanta saber que muitos querem "gravar e ler" arquivos nesse formato mas não fazem ideia do que é um XML!

Eis um bom começo:
http://www.w3schools.com/xml/default.asp

Acho que nenhuma linguagem tem mais variações sobre o mesmo tema que Java: http://guj.com.br/artigos.jsp#87031


Testable & Untestable Code
2008-08-08T14:29:00.001-03:00
Leitura recomendada:

http://misko.hevery.com/2008/07/24/how-to-write-3v1l-untestable-code/
http://www.testingreflections.com/node/view/7221


The Good, the Bad and the Ugly
2008-08-07T18:40:00.005-03:00
Depois de ter visto algumas vezes "Era uma vez no Oeste" (com Charles Bronson tocando harmônica), finalmente pude conferir o clássico "Três Homens em Conflito" (The Good, the Bad and the Ugly) do mestre Sergio Leone.  

Clint Eastwood, Eli Wallach e Lee Van Cleef estão perfeitos nessa história cheia de sangue, traições e a obcessão pela riqueza. As panorâmicas de Leone sobre o desertico velho oeste e a caracterização dos homens embrutecidos daquela época, onde a vida não valia mais do alguns dólares, são majestosas, com direito à mostrar parte da guerra civil americana.



Esqueçam aqueles filmes de indios e tiros falsos: são personagens densos, únicos, em um momento diferente da história, com momentos fantásticos (como a cena em que o "Feio" monta um revolver com as peças de outros). Sem falar no olhar mortal do "Olhos de Anjo" Lee Van Cleef, que passa uma frieza na espinha...

- "When you have to shoot, shoot. Don’t talk!"

Sem falar no maravilhoso tema de Ennio Morriconi, clássico absoluto. O estilo Western não é vazio como muitos pensam, basta saber apreciar.


Voltas às Aulas e o Java - parte 2
2008-08-07T17:43:00.003-03:00
Existe o clássico problema de determinar se um aluno passou ou não de ano quando são informados as notas e o número de faltas.

Vejamos: 
1) O número de faltas é acima do permitido?. Aqui entra um if dos bons com uma comparação numérica, quando um número é maior ou igual a outro.
2) A média é basicamente somar as X notas e dividir por X (se for média aritmética). Somar e dividir são operações matemáticas básicas.

Uma forma de fazer é:
 if( numero_de_faltas > maximo_de_faltas_toleradas) {
   // reprovado por faltas
} else if ( media_do_aluno < media_para_passar ){
  // reprovado por nota
} 
// se nem um nem outro, esta aprovado


O ruim dessa abordagem é que o aluno estar aprovado é uma condição "que sobra". Se passarmos a focar a aprovação do mesmo ficaria assim:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
   // aprovado!
} else {
  // reprovado!
}

É claro que eu posso que eu posso querer saber o motivo pelo qual o aluno foi reprovado:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
   // aprovado!
} else if(numero_de_faltas > maximo_de_faltas_toleradas){
   // reprovado pelo número de faltas: ignoro a média.
} else {
  // aqui só sobra a reprovação por nota, 
  // basta fazer a tabela-verdade dessas expressões
}

Se o foco do professor for o algoritmo, isso é o que deveria ser analisado. Quem implementa corretamente um método que recebe X notas e um número de faltas e consegue responder a essas perguntas consegue descrever facilmente os casos de teste para verificar se a implementação corresponde ao que se espera.

Um programa que tenha algum tipo de interação (seja Swing ou console) ajuda a fazer um macarrão de código, mesclando o algoritmo com o controle de estado dos "menuzinhos". No fim vemos laços de repetição aonde não são necessários, calculo de média errado, etc.

Ok, não acho que um marinheiro de primeira viagem devesse começar por JUnit, mas uma com boa noção dos fundamentos da linguagem e evitando a interação desnecessária com o usuario (poderia ser usado até os parâmetros do main), acredito num melhor desempenho. O risco é o aluno acreditar que java  é dificil ou que tudo se resume a getters/setters e gigantescos try/catch's onde as exceptions são varridas pra debaixo do tapete. 

Eu colocaria TDD num segundo momento, mas ai sem perdão, ensinando o caboclo a fazer do jeito certo o quanto antes. O que é dificil se eles conseguem passar sem saber fazer aritmética básica.


Algumas pessoas PRECISAM fazer programas interativos
2008-08-06T15:05:00.006-03:00
Este código:
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv){
        int i;
        double total =0;

        for(i=1;i < argc;i++){
            total = total + atof(argv[i]);
        }

        printf("A soma dos %d parametros eh %f\n",(argc - 1),total);

        return 0;
}


É limpo, prático e scriptável. Não preciso fazer pergunta nenhuma nem tratar nada que o usuario informe: no maximo posso ver o número de parâmetros e reclamar. Basta saber como funciona o laço for e saber que argc é o número de parâmetros que eu passei para o programa e argv é um vetor de strings (que, em C puro, são vetores de chars) onde cada elemento é um parâmetro. O primeiro é sempre o nome do programa (a posição 0, que eu pulei).

$ gcc -Wall soma.c
$ ./a.out 1 2 3 4 5
A soma dos 5 parametros eh 15.000000


Eu compilo e pelo para que todos os warnings possiveis sejam mostrados. Novamente não tive nenhum problema e o código funciona bem. Nem um flush de stdin foi preciso. Se eu colocar uma palavra no meio, como abóbora, será ignorado.

Não é mais facil assim do que fazer milhões de menus? Nem precisa de system("pause") system("cls")!


Test Driven Development - parte 1.
2008-08-06T14:31:00.008-03:00
Veja este código:

 public void testEhPar() throws Exception{
  assertTrue("2 deve ser par",algoritmo.ehPar(2));
  assertTrue("4 deve ser par",algoritmo.ehPar(4));
  assertTrue("6 deve ser par",algoritmo.ehPar(6));
  
  assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
  assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
  assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5));  
 }


Dentro de uma classe de teste, usando o framework JUnit, a leitura dessas linhas é a seguinte:

Eu tenho um objeto chamado algortimo.
A chamada algoritmo.ehPar(2) deve retornar true, pois 2 é par, e este método informa se o parâmetro informado é, ou não, par.
O método assertTrue recebe dois parâmetros: uma mensagem informando o significado deste teste, e o resultado do mesmo.

Se o método estivesse com algum problema e retornasse false, isso:

assertTrue("2 deve ser par",algoritmo.ehPar(2));

seria o mesmo que

assertTrue("2 deve ser par",false);

Logo, o teste falha, pois 2 deve ser par.

Esta é uma forma programática de garantir o comportamento do código que eu desenvolvo: testando. Se o meu método só depende dos parâmetros informados, é muito simples verificar o seu funcionamento.

Desenvolvendo os testes antes de implementar o código, tendo apenas as assinaturas dos métodos (por isso recorri a uma interface aqui, lembra?), eu posso pensar nos comportamentos esperados e, então, vou desenvolvendo até que todos os testes estejam passando.

Não é nada fácil, funciona melhor quando o projeto que estás desenvolvendo está começando, porém os resultados são excelentes: veja o quanto de tempo estás economizando! Se tu pretendes determinar se um código teu está funcionando por programas que perguntam os valores, escrever 

$ ant clean test


é muito mais rápido! 

O problema surge quando queremos fazer algo complexo, pois a dificuldade de testar mostra problemas na arquitetura adotada, por exemplo. Quanto temos objetos que tem objetos, herança, polimorfismo, tecnicas mais avançadas podem ser usadas como usar Mocks de objetos (e prover os mecanismos para injetar estes Mocks).

No caso desse exemplo, esta é uma solução:
public boolean ehPar(int numero){
      return numero % 2 == 0;
}


Muitos alunos desconhecem as operações de divisão e módulo entre inteiros. O 1, inteiro, dividido por 2, inteiro, não é 0.5, (em java), e sim 0, pois este é o resultado da divisão inteira. O resto da divisão, simbolizado por %, retorna 1. Dessa forma, o resto da divisão de um numero par por 2 é 0, caso contrario é um número inteiro. São operações básicas que precisam ser dominadas. Repare que eu fiz um código que funcione, não tentei nada mais maquiavélico que dê 0.0001 milissegundos mais rápido. Evite a otimização precoce.

Programar profissionalmente é uma tarefa de muita responsabilidade. Desenvolver testes para garantir a qualidade provê excelentes resultados a longo prazo.


Trocar de Emprego
2008-08-06T14:19:00.004-03:00
Completando 6 meses de globo.com, refleti sobre a opção que fiz quando resolvi trocar de emprego. Vi essa semana muitas pessoas com duvidas de como ou quando fazer uma opção parecida, por isso resolvi colaborar.

A primeira coisa que devemos pensar é na nossa carreira. As vezes chegamos ao limite na empresa onde estamos, ou não há perspectivas, ou a situação está ruim, etc. São muitas as coisas que podem acontecer. Com um mercado com falta de mão-de-obra qualificada, muito profissional é assediado por empresas, prometendo as vezes salário maior, ou então surge uma oportunidade fora do estado. O que fazer?

Todas as oportunidades devem ser vistas de forma crítica. Analise o futuro, a distância, o ambiente de trabalho e, também, a remuneração. Eu sempre escolhi o trabalho à remuneração, mas trabalho que paguem abaixo do esperado eu simplesmente não considero. Escolher um emprego vendo apenas o salário engana: imagine ganhar 20% a mais em um emprego mais longe, onde vais perder mais tempo no trajeto, será que compensa? Ou então sair de um ambiente legal para uma confusão absoluta, onde domingo é dia útil de trabalho? Pois é.

Feito isso, temos que pensar em coisas práticas: todas as exigências são atendidas? Tem empresa que só se preocupa com diploma e certificações, mesmo que a sua bagagem supere todas expectativas. Se a empresa é em outra cidade ou estado, temos que analisar o custo de vida, mudança, lugar aonde morar (em grandes centros urbanos é sempre caótico, veja isso com muito cuidado).

O currículo precisa estar atualizado. Ja leu isto aqui? E isso?

Nas entrevistas seja sincero e tenha confiança: tu és um produto, tens que te vender. E, se mentir, babau, vão descobrir mais cedo ou mais tarde... Pra isso, podes estudar bastante algum assunto (eu vim lendo as apostilas da Caelum na viagem de carro que fiz de PoA ao RJ).

Por fim, planeje bem a transição: vale a pena sair com as portas abertas, caso ocorra algum problema. Seguindo estes passos é relativamente fácil optar por trocar, ou não, de emprego.

O importante é se sentir bem aonde estás trabalhando e colaborar para que o ambiente evolua, caso contrario podes ficar fazendo o mesmo trabalho, da mesma forma, por muito tempo: até que um estágiario possa ficar no seu lugar ;-)

Ps: como vai o seu inglês?


Voltas às Aulas e o Java
2008-08-04T12:20:00.005-03:00
Na época de volta às aulas nas faculdades percebe-se uma grande invasão de alunos desesperados em foruns de informática para resolverem os seus execícios. É facil reconhecer um aluno em pânico com o seu primeiro while ou algum exercício sobre Fibonacci: eles não tentam, simplesmente colam o enunciado do problema esperando a resposta pronta.

Entretanto tão bizarro quanto são os exercícios propostos: um programa que leia pergunte 2 numeros e retorne a soma, ou um programa para calcular alguma coisa que pergunte ao usuário... perai, pergunte? Um programa perguntando? Como?

Este é o típico programa 'interativo' com o usuário. Quando não usa a entrada padrão (algo completamente misterioso para boa parte dos alunos), usam algum recurso SWING. Mas sera que ninguem pensa o quão PREJUDICIAL são estes exercícios?

Normalmente o aluno se preocupa com a apresentação do mesmo, fazendo frescuras de menuzinhos, asteriscos pra lá e pra cá... e o algoritmo que é bom nada. Sinceramente: dane-se os menuzinhos. Sabem quantos programas com menuzinhos e que vão perguntar alguma coisa pro usuario vcs vão fazer na vida profissional de vcs? 0! Zero! Nenhum!

Existem muitas formas de interação com o usuario, hoje em dia vc pode ter interfaces web, por exemplo. Eu acho que, num primeiro momento, a única interação com o usuario deveria ser escrever na tela. Nada mais que isso se o camarada não sabe o que significa um NullPointerException.


Exemplo pratico:

- Prepare um diretório para trabalhar (suponho que vc vai usar linux, senão deve ser facil portar este exemplo para outros sistemas operacionais).
- Crie um diretorio lib e copie o junit-4.4.jar pra lá (use o google pra baixar esse arquivo, se vc não conseguir saia do curso de informática).
- Crie a estrutura abaixo, ainda no diretório de trabalho:
src/java
src/test
- Instale o aplicativo ant (de novo o google te ajuda, alias vc tem algum JDK instalado, certo??).
- Crie um arquivo chamado build.xml no diretorio de trabalho.
- Baixe o arquivo ant-junit.jar daqui [ http://www.java2s.com/Code/Jar/ANT/Downloadantjunitjar.htm ] e copie o .JAR para ~/.ant/lib (se não existe, crie).

Agora vem a proposta: baseado nessa interface:

public interface Algoritmo{
/* dado um numero, retorna true se for par */        
boolean ehPar(int numero);
/* calcula o valor absoluto ou modulo de um numero, ex: -1 vira 1, 1 vira 1 */
int calculaModulo(int numero);
/* calcula algum termo da série de fibonacci: se 0, mostra o primeiro, se 1 mostra o segundo...*/
int calculaFibonacci(int elemento);
/* calcula o fatorial do numero indicado */
long calculaFatorial(int numero);
}


Vais criar uma classe chamada, digamos, SuaClasse que implementa esta interface (percebeu que tudo deve ficar em src/java não é?). Não pense na implementação dessa classe ainda.

No diretorio src/test vc vai salvar esta classe:

import junit.framework.TestCase;

public class AlgoritmoTeste extends TestCase{
 Algoritmo algoritmo;
 public void setUp(){
  algoritmo = new SuaClasse();
 }
 
 public void tearDown(){
  algoritmo = null;  
 }
 
 public void testEhPar() throws Exception{
  assertTrue("2 deve ser par",algoritmo.ehPar(2));
  assertTrue("4 deve ser par",algoritmo.ehPar(4));
  assertTrue("6 deve ser par",algoritmo.ehPar(6));
  
  assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
  assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
  assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5));  
 }
 
 public void testCalculaModulo() throws Exception{
  assertTrue("modulo de  3 deve ser 3",algoritmo.calculaModulo(3) == 3);
  assertTrue("modulo de -3 deve ser 3",algoritmo.calculaModulo(-3) == 3);
  assertTrue("modulo de  5 deve ser 5",algoritmo.calculaModulo(5) == 5);
  assertTrue("modulo de -5 deve ser 5",algoritmo.calculaModulo(-5) == 5);  
 }
 
 public void testCalculaFibonacci() throws Exception{
  assertTrue("elemento  0 da serie fibonacci deve ser   0",algoritmo.calculaFibonacci(0) == 0);
  assertTrue("elemento  1 da serie fibonacci deve ser   1",algoritmo.calculaFibonacci(1) == 1);
  assertTrue("elemento  2 da serie fibonacci deve ser   1",algoritmo.calculaFibonacci(2) == 1);
  assertTrue("elemento  3 da serie fibonacci deve ser   2",algoritmo.calculaFibonacci(3) == 2);  
  assertTrue("elemento  4 da serie fibonacci deve ser   3",algoritmo.calculaFibonacci(4) == 3);
  assertTrue("elemento  5 da serie fibonacci deve ser   5",algoritmo.calculaFibonacci(5) == 5);
  assertTrue("elemento  6 da serie fibonacci deve ser   8",algoritmo.calculaFibonacci(6) == 8);
  assertTrue("elemento  7 da serie fibonacci deve ser  13",algoritmo.calculaFibonacci(7) == 13);  
  assertTrue("elemento 11 da serie fibonacci deve ser  89",algoritmo.calculaFibonacci(11) == 89);
  assertTrue("elemento 13 da serie fibonacci deve ser 223",algoritmo.calculaFibonacci(13) == 233);  
 }
 
 public void testCalculaFatorial() throws Exception{
  assertTrue("Fatorial de  1 deve ser        1",algoritmo.calculaFatorial(1) == 1);
  assertTrue("Fatorial de  2 deve ser        2",algoritmo.calculaFatorial(2) == 2);
  assertTrue("Fatorial de  3 deve ser        6",algoritmo.calculaFatorial(3) == 6);
  assertTrue("Fatorial de  4 deve ser       24",algoritmo.calculaFatorial(4) == 24);
  assertTrue("Fatorial de  5 deve ser      120",algoritmo.calculaFatorial(5) == 120);
  assertTrue("Fatorial de  6 deve ser      720",algoritmo.calculaFatorial(6) == 720);
  assertTrue("Fatorial de 10 deve ser 3628800L",algoritmo.calculaFatorial(10) == 3628800L);  
 }
}


Uma ideia sobre o JUnit pode ser encontrada aqui: [ http://guj.com.br/java.tutorial.artigo.40.1.guj ], alias o guj, na sessão de tutoriais, explica varias coisas, é ótimo material de referência!

Ok, vc tem a interface que vc deve respeitar e um arquivo de teste. Vamos falar do arquivo de build do ant.

<project name="Meu Projeto" basedir="." default="dist">
        <description>
                Aprendendo a fazer um build.xml para o ant
        </description>

        <property name="lib"   location="lib"/>
        <property name="src"   location="src/java"/>
        <property name="test"  location="src/test"/>

        <property name="build" location="build"/>
        <property name="dist"  location="dist"/>

        <path id="classpath.test"> 
                <pathelement location="${test}" />
                <pathelement location="${build}" />
                <pathelement location="${lib}/junit-4.4.jar" />
        </path>

        <target name="init">
                <!-- Create the time stamp -->
                <tstamp/>
                <!-- Create the build directory structure used by compile -->
                <mkdir dir="${build}"/>
        </target>

        <target name="compile" depends="init" description="compile the source " >
                <!-- Compile the java code from ${src} into ${build} -->
                <javac srcdir="${src}" destdir="${build}"/>
        </target>

        <target name="dist" depends="compile" description="generate the distribution" >
                <!-- Create the distribution directory -->
                <mkdir dir="${dist}/lib"/>

                <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
                <jar jarfile="${dist}/lib/Algortimo-${DSTAMP}.jar" basedir="${build}"/>
        </target>

        <target name="clean" description="clean up" >
                <!-- Delete the ${build} and ${dist} directory trees -->
                <delete dir="${build}"/>
                <delete dir="${dist}"/>
        </target>

        <target name="test" depends="compile">
                <javac srcdir="${test}">
                        <classpath refid="classpath.test"/>
                </javac>
                <junit>
                        <classpath refid="classpath.test" />
                        <formatter type="brief" usefile="false" />
                        <test name="AlgoritmoTeste"/>
                </junit>
        </target>
</project>


A utilização desse arquivo é muito simples, não se amedronte pelo tamanho do arquivo, o formato xml do ant é bizarro e verboso, sou muito mais um Makefile, porém uma vez com ele feito basta ir adicionando coisas "com cuidado". Sem falar que tudo tem documentação oficial cheia de exemplos, só não aprende quem não quer.

$ ant 
isso deve compilar a sua classe e gerar um jar (pode ser util no futuro).

$ ant clean
limpa os diretorios que vc acabou de criar com as suas paradas compiladas.

$ ant test
compila e executa os testes unítarios.

É claro que vc vai dizer, e agora??? Bom, veja isso:

public class SuaClasse implements Algoritmo{
        public boolean ehPar(int numero){return false;}
        public int calculaModulo(int numero){ return -1;}
        public int calculaFibonacci(int elemento){return -1;}
        public long calculaFatorial(int numero){return -1;}
}


Olha que legal! Uma classe que tem o minimo pra compilar! Agora vamos testar...

$ ant test
Buildfile: build.xml

init:
    [mkdir] Created dir: /home/GLOBO.COM/peczenyj/test/junit/build

compile:
    [javac] Compiling 2 source files to /home/GLOBO.COM/peczenyj/test/junit/build

test:
    [javac] Compiling 1 source file
    [junit] Testsuite: AlgoritmoTeste
    [junit] Tests run: 4, Failures: 4, Errors: 0, Time elapsed: 0.005 sec
    [junit] 
    [junit] Testcase: testEhPar(AlgoritmoTeste):        FAILED
    [junit] 2 deve ser par
    [junit] junit.framework.AssertionFailedError: 2 deve ser par
    [junit]     at AlgoritmoTeste.testEhPar(Unknown Source)
    [junit] 
    [junit] 
    [junit] Testcase: testCalculaModulo(AlgoritmoTeste):        FAILED
    [junit] modulo de  3 deve ser 3
    [junit] junit.framework.AssertionFailedError: modulo de  3 deve ser 3
    [junit]     at AlgoritmoTeste.testCalculaModulo(Unknown Source)
    [junit] 
    [junit] 
    [junit] Testcase: testCalculaFibonacci(AlgoritmoTeste):     FAILED
    [junit] elemento  0 da serie fibonacci deve ser   0
    [junit] junit.framework.AssertionFailedError: elemento  0 da serie fibonacci deve ser   0
    [junit]     at AlgoritmoTeste.testCalculaFibonacci(Unknown Source)
    [junit] 
    [junit] 
    [junit] Testcase: testCalculaFatorial(AlgoritmoTeste):      FAILED
    [junit] Fatorial de  1 deve ser        1
    [junit] junit.framework.AssertionFailedError: Fatorial de  1 deve ser        1
    [junit]     at AlgoritmoTeste.testCalculaFatorial(Unknown Source)
    [junit] 
    [junit] 
    [junit] Test AlgoritmoTeste FAILED

BUILD SUCCESSFUL
Total time: 1 second


Agora basta escrever codigo de verdade na SuaClasse e testar, estara pronto quando TUDO estiver passando. São 4 métodos básicos, sabendo lidar com variaveis locais, if e for, vc consegue muita coisa.

Se eu fosse professor eu daria exercícios assim: o projeto deveria compilar e todos os testes deveriam passar senão o aluno leva 0. A nota viria de acordo com o que eu espero, posso usar um EMMA e ver a cobertura de código, posso avaliar a presença de um Javadoc que preste, etc.

Enfim, eu seria um professor muito malvado }-)

Não perca a parte 2 aqui, e uma introdução ao TDD aqui.


Tor: Um sistema anónimo de comunicação na Internet
2008-07-08T16:14:00.001-03:00
Pelo veto ao projeto de cibercrimes - Em defesa da liberdade e do progresso do conhecimento na Internet Brasileira

http://www.petitiononline.com/veto2008/

Se esta lei for aprovada, podemos fazer uso do Tor para navegar tranquilamente.

Tor é um conjunto de ferramentas para um amplo grupo de organizações e particulares que desejam aumentar a sua segurança na Internet. Usar Tor pode ajudar a tornar anónima a navegação e publicação na Web, instant messaging, IRC, SSH, e outras aplicações que usem o protocolo TCP. Tor também disponibiliza uma plataforma para os programadores de software, criarem novas aplicações com funções de anonimato, segurança e privacidade já incorporadas.

Tor pretende defender contra a análise de tráfego, uma forma de vigilância que ameaça o anonimato pessoal e a privacidade, a confidencialidade dos negócios e relacionamentos, e a segurança de estados. As comunicações são enviadas através de uma rede distribuída de servidores chamados onion routers, protegendo-nos de sites Web que constroem perfis com os nossos interesses, pequenos espiões que lêem os nossos dados ou registam que sites visitámos.

A segurança do Tor aumenta à medida que a sua base de utilizadores aumenta e mais pessoas se oferecem para alojar servidores. Por favor considere oferecer o seu tempo ou oferecer a sua largura de banda. Convém lembrar que estamos a lidar com código em desenvolvimento — Não deve usar o Tor se precisa realmente de fortes garantias de anonimato. 

Fonte: http://www.torproject.org/index.html.pt


Sudo
2008-07-03T17:35:00.000-03:00



Erlang é dificil (parte 2)
2008-06-19T15:15:00.002-03:00
Agora vamos usar as funções específicas para manipular listas.

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L), L > 0 -> 
        lists:seq(0,L); % cria uma lista de 0 até L
generate(L) when integer(L) -> 
        % vamos reverter a lista?
        lists:reverse(generate(-L)).


Muito mais simples, certo? Veja o teste:

$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5  (abort with ^G)
1> c(tut). 
{ok,tut}
2> tut:generate(5) ++ tut:generate(-5).
[0,1,2,3,4,5,5,4,3,2,1,0]
3> 


O operador ++ une 2 listas :)


Erlang é dificil?
2008-06-18T19:10:00.002-03:00
Erlang é realmente dificil?

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L) -> gera_lista(L).

gera_lista(L) when L > 0 -> gera_lista_direita(L);
gera_lista(L) -> gera_lista_inversa(-L).

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
        %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
        gera_lista_direita(L - 1,[L | Z]).

gera_lista_inversa(L) -> gera_lista_inversa(L,[]).

gera_lista_inversa(-1,Z) -> Z;
gera_lista_inversa( L,Z) -> gera_lista_inversa(L,0,Z).

gera_lista_inversa(-1,_,Z) -> gera_lista_inversa(-1,Z);
gera_lista_inversa( L,A,Z) -> 
        %io:format("chamando: h(~p,~p,Z)~n",[L,A]), 
        h(L - 1, A + 1,[A | Z]).


Ok, dessa forma é dificil. Erlang é uma linguagem funcional, ou seja, suas funções seguem um raciocínio matemático e não imperativo. Vc sente o problema quando quer resolver algo iterativo ou utilizar variaveis de qualquer forma.

Fiz uma pequena função chamada generate, do modulo tut (de tutorial, uma vez que estou seguindo um). Ela é muito simples, se vc informar 0, ela gera uma lista simples contendo 0. Se vc passar um numero positivo ela gera uma lista de 0 até o número, inclusive. Se o numero for negativo, ele assume que vc quer fazer fazer a lista de forma inversa.

Veja só:
$ erlc tut.erl   # compilando o modulo
$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5  (abort with ^G)
1> c(tut).           # carregando o modulo
{ok,tut}
2> tut:generate(0).  # invocando modulo:funcao(parametros).
[0]
3> tut:generate(10).
[0,1,2,3,4,5,6,7,8,9,10]
4> tut:generate(-10).
[10,9,8,7,6,5,4,3,2,1,0]
5> 


A função generate chama a função gera_lista se o parametro passado for um número inteiro.
A função gera_lista chama a função para gerar a lista direita ou inversa, de acordo com o valor do parâmetro.

Veja só a simplicidade:

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
        %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
        gera_lista_direita(L - 1,[L | Z]).


quando eu chamo gera_lista_direita(10) eu estou, na verdade, chamado a função gera_lista_direita(10,[]), onde eu fico usando uma lista como acumulador.

A operação [L | X] pode ser lida como [ elemento | lista ] , ou seja, eu adiciono um elemento em uma lista. gera_lista_direita(10,[]) vai chamar, então, gera_lista_direita(9,[10]), e depois gera_lista_direita(8,[9, 10]), e assim recursivamente até gera_lista_direita(-1,Z), quando eu retorno a lista. Fica claro se removerem os comentários (%) da frente dos io:format, que é a forma de fazer PPADD (Passei Por Aqui Driven Development) em Erlang.

Erlang precisa de MUITA pratica, principalmente de quem nunca programou em uma linguagem funcional e fica tentado a fazer coisas 'não ortodoxas' ;-)

Ah sim, o google é seu amigo:

http://www.dei.isep.ipp.pt/~paf/orgcdocs/Intro_Erlang.pdf


Tabela do Brasileirão 2008 com links + sed
2008-06-18T15:15:00.002-03:00
O sed é um processador de texto muito versátil.

O links é um browser modo texto com features tão interessantes quanto do antigo lynx.

Ano passado eu postei como imprimir a tabela do brasileirão com um one liner interessante. Agora eu resolvi beber de outra fonte:

#!/bin/bash
TIME=Internacional
COLOR=$(echo -ne '\e[31;1m&\e[m')
URL=http://globoesporte.globo.com/Esportes/Futebol/Classificacao/0,,ESP0-9827,00.html
links --dump ${URL} | sed -r 's/\[[0-9]*\]//;/(^[0-9]|J jogos)/!d' | sed "s/${TIME}/${COLOR}/
         1a-----Libertadores----------
         4a-----Pre-Libertadores------
         5a-----Sul-Americana---------
        13a---------------------------
        17a-----Rebaixado-------------"


O resultado não é tão bom quanto o do ano passado, é verdade, mas não deixa de ser uma alternativa


Gerenciando Inovações
2008-06-13T23:24:00.001-03:00
No ramo da tecnologia da informação, vulgo informática, saber gerenciar inovações é uma arte. Não tenho outras palavras para descrever o fato de vc olhar para uma ideia como o gmail, youtube, icq, orkut ou geocities e dizer "isso tem futuro". Mas não é bem assim.

A história de cada inovação bem sucedida é extremamente complexa: são opiniões diversas, conflitos internos, apostas, brigas e muito trabalho para transformar uma ideia em algo que marque de verdade. Com certeza nada naquilo que temos hoje é o que foi imaginado de primeira, afinal os conceitos evoluem. Com certeza aquele chefe chato que barrava todas as ideias contribuiu, mesmo que indiretamente, para o sucesso da ideia.

Ai tem um ponto interessante: quem não conhece aquele chefe que barra todas as ideias inovadoras? Estes são o outro extremo da coisa! A informática muda muito, as pessoas que tem computador hoje são diferentes das que tinham no passado e assim por diante, é dificil vc inovar sem se arriscar muito: é ai que entra o medo.

Em todos os ramos existe inovação, o que diferencia é a velocidade com a qual as coisas andam. Alguns ramos seguem as mesmas ideias por décadas ou séculos, enquanto outros ramos a escala é de semanas. É dificil não ter medo, afinal ou vc inova ou vc faz coisas loucas, inconsequentes, que podem destruir todo um trabalho de uma vida.

O segredo é saber o que vc quer. Empresas de tamanho médio inovam com algum pé atrás, apostando em formulas consagradas e alguma novidade para quebrar o clima. Empresas grandes não podem se dar ao luxo de inovar sob pena de perder o fio da meada portanto podem comprar as empresas pequenas que, inovando, podem gerar lucro para gigantescas corporações multinacionais. E este é apenas um cenário de muitos que acontecem por ai. Temos empresas que sabem vender o convencional como se fosse inovação, e vice-versa. 

A questão é: como lidar com inovações quando as mesmas podem ser o próximo microsoft bob ou o Iphone? Acho que cada um tem a sua formula: seja inovando ou comprando inovações por chegar a um tamanho que não é possivel não ser burocrata, cada um enfrenta essas novas tendências como acha melhor, trabalhando num ramo muito recente, onde as regras estão sendo escritas por bilhões de pessoas.

A resposta não é algo vago como: dilheiro dá em árvores ou todos tem potencial para ser algo mágico, etc, etc. É necessário entender as inovações que surgiram nos ultimos 10 anos (flash, ajax, orkut, celular, busca por palavras chave, etc) e reconhecer que existem milhões/bilhões de pessoas que contribuem para isso e elas são extremamente intelectualmente ativas. Uma face disso são os projetos open source como Linux, Hibernate e Ruby on Rails que competem de igual para igual com gigantescas corporações.

Resumindo: eu não sei lidar com inovações, mas elas chegam até mim via centenas de privilegiados que bebem da fonte. De alguma forma eu participo delas, mas não sei gerar nenhuma, tampouco saberia gerenciar, mas sei respeitar que o assunto é complexo e, principalmente, causa medo.

Medo de prejuizos. Principalmente se alguem lembrar muito, ou pouco.


Pesquisando nos Grupos do Yahoo
2008-05-28T18:17:00.008-03:00
Meu amigo MrBits me deu essa grande ideia:

#!/bin/bash
QTDE=20
CHARSET=UTF-8
GROUP=shell-script

while getopts g:c:q: OPTION ; do
        case $OPTION in
        g) GROUP=$OPTARG ;;
        c) CHARSET=$OPTARG ;;
        q) QTDE=$OPTARG ;;
        esac
done

shift $(($OPTIND -1))

SEARCH="$@"

if [ -z "$SEARCH" ]; then 
        echo "Usage: $(basename $0) [-q qtde] [-g grupo] [-c charset] search" 
        exit 1
fi

BASEURL="http://br.groups.yahoo.com/group"
URL="${BASEURL}/${GROUP}/msearch?submit=OK&charset=${CHARSET}&cnt=${QTDE}&query=${SEARCH// /+}"  
SEDCMD="/message/!d;/${GROUP}/!d;/.*[0-9]/!d;s#/group#${BASEURL}#g;s/<[^>]*span>//g;s/$/<br \/>/"

LYNXOPT="-dump -force_html -assume_charset=${CHARSET}"
lynx $LYNXOPT <(  curl -b /tmp/cookie$$ -sL "${URL}" |  sed "${SEDCMD}" )


Vejamos em uso:
$ ./find.sh              
Usage: find.sh [-q qtde] [-g grupo] [-c charset] search

$ ./find.sh -q 10 getopts # procurando por getopts limitando a 10 registros
   [1]Re: [shell-script] Script de busca de mensagens
   [2]Re: [shell-script] Re: script iterativo / passo a passo
   [3]Re: [shell-script] Script de Backup
   [4]Re: [shell-script] Script de Backup
   [5]Re: [shell-script] Script de Backup
   [6]Re: [shell-script] Script de Backup
   [7]Re: [shell-script] Echo e executa: superecho
   [8]Re: [shell-script] testar se parametro $1 foi passado
   [9]Re: [shell-script] Echo e executa: superecho
   [10]Re: [shell-script] testar se parametro $1 foi passado

References

   1. http://br.groups.yahoo.com/group/shell-script/message/26373
   2. http://br.groups.yahoo.com/group/shell-script/message/26204
   3. http://br.groups.yahoo.com/group/shell-script/message/26078
   4. http://br.groups.yahoo.com/group/shell-script/message/26076
   5. http://br.groups.yahoo.com/group/shell-script/message/26075
   6. http://br.groups.yahoo.com/group/shell-script/message/26072
   7. http://br.groups.yahoo.com/group/shell-script/message/25742
   8. http://br.groups.yahoo.com/group/shell-script/message/25720
   9. http://br.groups.yahoo.com/group/shell-script/message/25719
  10. http://br.groups.yahoo.com/group/shell-script/message/25718


Divertido, não? o default é procurar no grupo shell-script do yahoo, mas ele pode investigar em qualquer um.

Valeu Mr.Bits!!


Francisco Ayala: Ciencia e Religiao
2008-05-27T23:18:00.002-03:00
Interessante conclusão do Francisco J. Ayala:

Considere que pelo menos 20% das gravidezes notoriamente terminam em aborto espontâneo. Se isso resulta de anatomia divinamente inspirada Deus é o médico que mais realiza abortos.


Vale a pena ler o resto aqui

O começo:
Ex-padre defende que Deus e teoria evolutiva de Darwin são compatíveis

Para um professor universitário, Francisco J. Ayala passa muito tempo na estrada. 
Biólogo e geneticista evolutivo na Universidade da Califórnia em Irvine, ele freqüentemente fala em universidades, igrejas e qualquer outro lugar, geralmente em defesa da teoria da evolução e contra argumentos do criacionismo e seu primo ideológico, o design inteligente.



Hello World orientado a objetos
2008-05-21T13:47:00.005-03:00
Hoje em dia é raro um desenvolvedor conhecer bem apenas uma linguagem. Em nome da multidisciplinaridade, decidi mostrar algums exemplos do mesmo programa: uma classe HelloWord com um construtor que recebe uma mensagem ("ola mundo") e um método show() que imprime essa mensagem.

Vejamos um exemplo em C++

#include <iostream>
#include <string>
using namespace std;

class HelloWorld{
        string mensagem;
        public:
        HelloWorld(string mensagem) { // construtor!
                this->mensagem = mensagem;
        }
     
        void show() { // metodo show
                cout << "mensagem: " << this->mensagem << endl;
        }
};
int main()
{
        HelloWorld obj("ola mundo");
        obj.show();
        return(0);
}


Agora o mesmo código em Java:

package Hello;

public class HelloWorld{
        private String mensagem;
        public HelloWorld(String mensagem){ 
                this.mensagem = mensagem;
        }
        public void show() { 
                System.out.println("mensagem: " + mensagem);
        }
        public static void main(String [] args){
                HelloWorld obj = new HelloWorld("ola mundo");
                obj.show();
        }
}


Agora, percebam a simplicidade do Ruby:
class HelloWorld
        def initialize(mensagem)
                @mensagem = mensagem 
        end
        def show 
                puts "mensagem: #{@mensagem}"
        end
end

obj = HelloWorld.new "ola mundo"
obj.show


Agora em Perl (sim, Perl!)
package HelloWorld;

sub new
{
        my ($class, $mensagem) = @_;
        my $self = {  mensagem => $mensagem  };
        bless $self, $class; # abençoando a variavel!
        return $self;
}

sub show
{
        my $self = shift; # sim, ela vem como argumento!
        print "mensagem: " . $self->{mensagem} . "\n";
}

my $obj = new HelloWorld("ola mundo");
$obj->show(); # parece artificial, não?

1;


PHP também é: 
<?php

Class HelloWorld{
        var $mensagem = "";
        function HelloWorld($mensagem){
                $this->mensagem = $mensagem;
        }
        function show(){
                echo "mensagem : " . $this->mensagem . "<br/>";
        }
}

$obj = new HelloWorld("ola mundo");
$obj->show();
?>


Por fim, vamos criar um tipo usando JavaScript
function HelloWorld(mensagem){
        this.mensagem = mensagem;
        this.show = function(){
                alert("mensagem: " + this.mensagem);
        }
}

var obj = new HelloWorld("ola mundo");
obj.show();


Edit: Python, atendendo a diversos pedidos
class HelloWorld:
    def __init__(self, arg):
        self.message = arg

    def show(self):
        print "mensagem: ", self.message

hello = HelloWorld("Ola Mundo")
hello.show()


A diferença entre uma linguagem e outra está (entre outras coisas) na sintaxe: em Perl eu tenho que criar os mecanismos na mão (com bless e receber $self) mas em Java e Ruby é tudo muito natural. Em Javascript eu não tenho uma construtor propriamente dito (muito menos classes) mas uma função (e crio um objeto dando um new nessa função). 

Vou abordar o tema "herança" no proximo post, espero que seja útil :)


CRDS - Conselho Regional de Desenvolvedores de Software
2008-05-02T16:07:00.002-03:00
Num futuro não muito distante, o carlinhos está desenvolvendo um pequeno sistema de contas a pagar para a Padaria do Manoel. Entretando o seu local de trabalho recebe uma visita de um fiscal do CRDS!

- Pronto 
- Sr Carlos Silva?
- É ele.
- Meu nome é Teobaldo, sou fiscal do Conselho Regional de Desenvolvedores de Software. Fiquei sabendo que nesse recindo está sendo desenvolvido um "software".
- Exato! To desenvolvendo um...
- Antes de mais nada, qual a sua formação?
- Sou formado em ciências da computação pela faculdade VIVA VIVER, do Acre, na modalidade EAD. Meu trabalho de conclusão foi "um sistema escrito em java para a web 2.0".
- Puxa, ultimamente só tem dado essa faculdade. 
- Po, ela custa 49,99 por mês...
- É claro. Continuando, onde está a ART desse sistema?
- Bom, é um sistema pequeno, com menos de mil linhas, precisa ART?
- Claro, e vc pode imprimir o boleto pelo site da CRDS, não tem desculpas.
- Ok. Eu pagarei...
- E onde está a documentação do sistema? Cadê o levantamento de requisitos, análise de impacto, análise de riscos, análise...
- EI! O meu sistema foi feito utilizando metodologias ágeis! É uma mistura de SCRUM com XP proporcionando um contrato de escopo aberto onde eu tento atender as necessidades do cliente, evitando burocracia, trabalhando em sprints de 15 dias...
- Ok, mas o CRDS exige essa documentação no template .doc que vc pode baixar do site
- Mas q .doc ?? Ta maluco, eu uso openoffice no meu linux.
- Linux ?? Vc desenvolve em um sistema operacional não homologado pela CRDS? Se ainda fosse Ubuntu...
- Mas Ubuntu é linux.
- Chega, se não tem documentação, como vc sabe que o sistema funciona?
- Eu uso testes unitários!
- Humm... teste precisa de um profissional habilitado em testes.
- Mas eu uso JUNIT, veja!
- Ei... q java esquisito é esse com esses @ e esses "maior e menor"?
- Isso se chama Annotations e Generics! Ta desde o Java 1.5
- Desculpe mas o CRDS só permite o uso de Java 1.4.2 que é a versão homologada para o Windows E Ubuntu.
- E se eu estivesse usando MacOS ?
- MacOS não foi homologado pelo CRDS ainda.
- Mas java é multiplataforma!
- Certo certo... e o modelo ER?
- Eu uso Hibernate para Abstrair o modelo ER..
- Hibernate ? Ok, terei que embargar o seu sistema...


TDD com Perl
2008-05-02T15:00:00.003-03:00
É possivel fazer Test Driven Development com Perl? Mas claro :)

Artigo interessante sobre Test::More:
http://www.testingreflections.com/node/view/5333

Tutorial bem sucinto:
http://www.wgz.org/chromatic/perl/IntroTestMore.pdf

Excelente apresentação:
http://wellington.pm.org/archive/200606/tdd/


Pra descontrair...
2008-05-02T14:48:00.003-03:00




Regulamentar a profissão dos outros é refresco
2008-05-02T14:26:00.005-03:00
Na onda da campanha contra a regulamentação das profissões da área de informática

Eu, que trabalho como Analista de Sistemas e tenho Bacharelado em Física incompleto, tenho uma grande inveja do Phillip Calçado, que trabalha na Austrália, e postou recentemente sobre essa “lei”.

http://blog.fragmental.com.br/2008/03/21/ainda-bem-que-estou-aqui/

Cito a opinião da Sociedade Brasileira de Computação 

1. Exercício da profissão de Informática deve ser livre e independer de diploma ou comprovação de educação formal.
2. Nenhum conselho de profissão pode criar qualquer impedimento ou restrição ao princípio acima.
3. A área deve ser Auto-Regulada.


Parece que os politicos querem saber mais de informática do que quem é da área (se bobear ninguem sabe o que é a ACM, devem achar que é um politico a pouco falecido). Fico com pena de algumas pessoas egoístas que pensam “tenho diploma, logo essa lei me favorece”. A nação brasileira frperde como um todo, retrocendendo décadas numa das atitudes mais lastimáveis de todos os tempos.

Parafraseando o Rodrigo Kumpera:

Para ser programador vamos precisar ter diploma, enquanto isso para fazer política basta assinar o nome. Regulamentar a profissão dos outros é refresco.


Segue a thread: http://br-linux.org/2008/campanha-contra-o-projeto-de-lei-6072007-de-regulamentacao-das-profissoes-da-area-de-informatica/


Código transparente, contas fechadas ?
2008-05-02T14:24:00.001-03:00
Engraçado como começamos a falar em “Transparência de Contas” e aparece gente dizendo q queremos acabar com o FISL. Parece que a ideia é “Aceite o FISL como ele É ou tu és contra o software livre no Brasil (e provavelmente usa Windows em casa)”.

Mesmo que o FISL acabasse (o que não vai acontecer, e ninguem quer) existem dezenas de eventos acontecendo pelo Brasil afora (alguns com palestrantes internacionais até). O FLISOL aconteceu em diversas cidades simultaneamente, por exemplo. Esses eventos só tendem a crescer e se profissionalizar, criando todo um ecossistema de divulgação de conhecimento técnico.

“Código transparente, contas fechadas” é um lema perigoso que pode acabar com a reputação da comunidade de software livre brasileira.


Manipulando logs com AWK e SED
2008-04-26T14:41:00.006-03:00
Eis que a lista de shell script traz um bom desafio.

Galera, tenho o seguinte log.:

AAAA-------------campo_1-------------campo_2-----campo_3----campo_4---------- 
teste_1 371508787 371547453 38666 testetesteteste

BBBB-------------campo_1-------------campo_2-----campo_3----campo_4---------- 
teste_2 4625081503 4651313710 26232207 testetesteteste

Estou a tentar usar o awk com a seguinte função : 
awk '$1~"teste_" {print $5";"$4}' teste > teste_.csv

a funcao busca realmente o que desejo:
$5 $4
testetesteteste 38666
testetesteteste 6232207

porem,, gostaria que seprasse da forma:

AAAA------------- 
testetesteteste 38666 
BBBB------------- 
testetesteteste 26232207 

Alguém tem uma dica de como fazer?

Ah... o bom e velho SED pode resolver isso

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Ok, ok, ta muito complicado, mas veja só:

$ sed -rn '/^[^-]+-+/h;/^teste_/{x;p;g;p}' arquivo.log 
AAAA-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_1 371508787 371547453 38666 testetesteteste
BBBB-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_2 4625081503 4651313710 26232207 testetesteteste

Vamos explicar
1) a opção -n serve para informar ao sed "imprima apenas quando eu mandar"
2) a opção -p serve para utilizar expressões regulares extendidas
(assim não preciso escapar o quantificador + , que significa "um ou
mais vezes", assim como os parentesis, para informar os grupos).

Eu fiz uma sacanagem. o comando h quarda o padrão num espaço chamado espaço reserva, tipo uma memória do sed, sobreescrevendo. Assim no espaço reserva eu tenho a ultima ocorrencia de uma linha do tipo,  ^[^-]+-+      ,que traduzindo significa: tudo o que começa com um ou varios caracteres diferentes de -, seguidos de um ou varios - (no caso
do AAAA------------- ... ).

Agora, quando eu encontro uma linha que começa com teste_ eu:

x) troco essa linha com a linha que esta na memória (a atual
'teste_...' vai, outra volta).
p) imprimo a linha que veio (AAAA---------- ...)
g) pego a linha da memória (teste_...)
p) imprimo a linha cachorrona

Só que não fica como vc quer. Ai vc precisa fazer a sacanagem:

se uma linha NÃO tem o que eu quero, então eu a manipulo habilmente
até que ela chegue ao que eu quero

Eu poderia ter usado varias tecnicas mas... uma vez com sed, podemos continuar nele.

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log

eu transformei a primera ER em  (minha_ER).* -- ou seja, criei um grupo para o que me interessa. basta fazer:

s/(minha_ER).*/\1/

para que toda a linha seja reduzida ao que a minha ER casa. em outras palavras, eu apaguei o resto da linha.

na outra eu fui mais sacana pois eu tenho 2 grupos e troco toda a linha pelos grupos, na ordem inversa. coisa de quem toma muito café e não tem escrupulos.

Vamos ver a versão AWK?

$ awk '/^[^-]+-+/{match($0,/^[^-]+-+/); x=substr($0,1,RLENGTH)}
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

x, nesse caso, armazena aquele pedaço da linha anterior, que eu descobri o que é via match. match procura uma expressão regular numa string, nesse caso em $0, e seta um valor na variavel RLENGTH, que é onde a expressão acaba. basta pegar essa parte da string e guardar na variavel x, que sera lida depois.

Aqui fala um pouco dessas duas funções: http://people.cs.uu.nl/piet/docs/nawk/nawk_92.html

Eu poderia ter resolvido dessa forma também
$ awk '/^[^-]+-+/{sub(/-[^-]+.*$/,"-");x=$0} 
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Entretanto aqui eu faço uma substituição grosseira do resto da linha que tem o AAAA------... por -, abusando do .* (e o fato dele ser guloso). Parece mais simples, mas está sujeito à falhas, embora não consigo pensar em nenhuma situação que seja possivem demonstrar.

AWK & SED são ferramentas sensacionais para esse tipo de problema ;-)


Sbado dia 26 de Abril tem FLISOL na PUC-Rio !!
2008-04-25T12:46:00.004-03:00


Em 26 de abril, será realizado o FLISOL - Festival Latinoamericano de Instalação de Software Livre - evento de divulgação de Software Livre da América Latina. No Rio de Janeiro quem está organizando este evento é o SL-RJ. Segundo o coordenador Carlos Ferreira, “É uma ótima oportunidade para levar seus amigos para passar este dia tão importante, participando das palestras ou instalando legalmente seu computador”. O Local onde será realizado, é a PUC-Rio - Pontifícia Universidade Católica do Rio de Janeiro - Auditório do RDC, localizado na Rua Marquês de São Vicente, 225, Gávea - Rio de Janeiro, RJ - Brasil - 22453-900. Das 8:30 às 17:00.


Veja mais informações aqui:
http://installfest.info/FLISOL2008/Brasil/RioDeJaneiro

Software disponível

    * Linux: Ubuntu
    * Openoffice e Firefox.
    * Para quem desejar, existe a opção de receber um cd da distribuição Linux Ubuntu versão 7.10, para isto basta levar um cd virgem. 

Palestras

Veja aqui a grade de palestras completa.

Iremos disponibilizar uma máquina e uma pessoa para ficar durante todo o evento à disposição das pessoas interessadas em conhecer um determinado programa ou recurso, tirar dúvidas e/ou obter dicas.

Como ajudar?

Você pode ajudar o evento de diversas maneiras. A mais simples é divulgando-o para os seus amigos, na sua escola ou no seu trabalho.

Se você quiser, pode ser um instalador ou palestrante no InstallFest. Envie um e-mail para Carlos Ferreira  ou Luiz Aldabalde  falando um pouco sobre a sua experiência com GNU/Linux ou qualquer outra aplicação livre que seja instalada durante o evento.

Caso queira ajudar de qualquer outra forma, entre em contato conosco por e-mail. Toda a ajuda é bem vinda!

O que devo fazer para me preparar para o Install Fest?

ATENÇÂO: Maquinas do tipo Desktop(com gabinete) só poderão entrar no Campus da PUC-Rio até as 12:00 horas, após este horário somente laptops dentro de mochilas.

Checagem de Hardware: No Windows, vá até o Painel de Controle e escolha Sistema. Liste:

    * Placa de rede (marca, modelo, configuração)
    * Placa de vídeo (marca, modelo, configuração)
    * Placa de Som (marca, modelo, configuração)
    * CPU (Processador)
    * Memória RAM
    * Modem (marca, modelo, configuração)
    * Espaço livre em disco (mínimo de 5.0 Gb)
    * Componentes SCSI (se houver algum) 

* Faça backup dos seus dados. Por precaução, você deve fazer uma cópia dos seus dados importantes no computador do seu amigo ou em CD-ROM.

* Particionamento do disco: se você souber como fazer, faça uma partição de no mínimo 5.0 Gb. Quanto maior for essa partição, mais utilidades do Linux poderão ser instaladas. Se você não souber fazer isso, nós faremos no dia do Install Fest. Apenas irá demorar mais tempo.

* Desfragmento do disco: Se você não souber fazer o particionamento, desfragmente o seu disco. Se você não souber fazer isso, ou não quiser, nós o faremos no dia do Install Fest. Apenas a sua instalação demorará mais que se você o tivesse feito antecipadamente. Para desfragmentar no Windows, primeiro desabilite todos os programas. Isso incluirá ICQ, navegadores, anti-vírus ou qualquer outra coisa que você estiver rodando. A seguir, clique em Iniciar, Programas, Acessórios, Desfragmentador de Disco. A seguir, clique em Iniciar na janela que aparecer nesse instante.

* Os custos de transporte do seu PC são de sua responsabilidade.

* Trazer para o Install Fest o Gabinete,Teclado, mouse e ainda, cabos de comunicação CPU-Periférico e cabos de força. Enfim, tudo o que é necessário para fazer seu computador funcionar. Se possível, traga também os manuais do seu hardware.

Apoio

CASA DO MOODLE http://www.casadomoodle.com

Responsáveis

Coordenador:  
          o Carlos Henrique Lucas Ferreira  

Colaboradores:
          o Luiz Guilherme Aldabalde
          o Avalci Suzano
          o Carlos Eduardo(Cadunico)
          o Luis Felipe Costa
          o Bruno Garcia
          o Josir Gomes


Sobre o FISL e tudo mais
2008-04-20T21:40:00.001-03:00
Rapidamente, foi ótimo reencontrar os amigos de Porto Alegre. Os ultimos dias do FISL me cansaram demais, porém foi ótimo conversar pessoalmente com o Aurélio (alias o livro dele é ANIMAL! vale a pena adquirir!), rever o Julio Neves, a galera do Tchelinux, sem falar na galera que eu conheci no evento (que eu insistia em trocar o nome, procedência, etc). Um abraço especial pro Marcelo Martins, que deve estar em Torres agora.

Destaque para a palestra do Guilherme Chapiewski.

Devo me preparar melhor para os próximos eventos, tanto em Poa ano que vem quanto os próximos eventos (como o FLISOL dia 26 de Abril na PUC-RJ, sem falar no Hack'n Rio). To doido pra ir no Javauy 2008 mas acho que não vai rolar :( Estou cheio de ideias!

Peço desculpas a todos que não conseguiram me encontrar ou que não pude conversar direito! Forte Abraço!


Um corretor ortográfico em gawk
2008-04-13T14:39:00.003-03:00
Ano passado eu publiquei uma pequena nota sobre um pequeno corretor ortográfico feito em Python.

No artigo do Peter Norwig, ele explica o principio estatístico do algoritmo. No final, ele mostra varias implementações do algoritmo (em D, Java, Ruby e até Erlang).

Depois de muito pesquisar, decidi fazer uma versão em gawk. A primeira tinha 30 linhas e não funcionava muito bem, arrumando e testando cheguei a esta forma final com apenas 15 linhas.

Eu chamo de linha um statement completo do awk. Perceba que nenhuma linha dessas possui o separador de statement ; (ponto-e-virgula), exceto quando estou utilizando o for no estilo C.

# Usage: gawk -v word=something -f thisfile.awk [ big.txt [ big2.txt ... ]]
# Gawk version with 15 lines -- 04/13/2008
# Author: tiago (dot) peczenyj (at) gmail (dot) com 
# Based on : http://norvig.com/spell-correct.html
function edits(w,max,candidates,list,        i,j){
       for(i=0;i<  max ;++i) ++list[substr(w,0,i) substr(w,i+2)]  
       for(i=0;i< max-1;++i) ++list[substr(w,0,i) substr(w,i+2,1) substr(w,i+1,1) substr(w,i+3)] 
       for(i=0;i<  max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+2)] 
       for(i=0;i<= max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+1)] 
       for(i in list) if(i in NWORDS) candidates[i] = NWORDS[i] }

function correct(word            ,candidates,i,list,max,temp){
       edits(word,length(word),candidates,list)
       if (!asort(candidates,temp)) for(i in list) edits(i,length(i),candidates)
       return (max = asorti(candidates)) ? candidates[max] : word }

BEGIN{ if (ARGC == 1) ARGV[ARGC++] = "big.txt" # http://norvig.com/big.txt
       while(++i<=length(x="abcdefghijklmnopqrstuvwxyz")) alpha[i]=substr(x,i,1)
       IGNORECASE=RS="[^"x"]+" }

{      ++NWORDS[tolower($1)]   }

END{   print (word in NWORDS) ? word : "correct("word")=> " correct(tolower(word)) }


Veja o script em funcionamento:
$ time gawk -v word=somethink -f spelling.awk
correct(somethink)=> something

real    0m4.862s
user    0m4.702s
sys     0m0.093s



Participe do Domingão do Faustão
2008-04-05T16:35:00.002-03:00
Vou fazer uma propaganda descarada: o Domingão do Faustão lançou o quadro Dança da Galera!

Para participar, basta seguir as instruções aqui e enviar o seu vídeo!

2008 promete muitas novidades! Aguardem!


Venha Tomar um Chimarrão no Estande da Globo.com!
2008-04-04T15:35:00.002-03:00
Acompanhando o post do Guilherme, dia 18 eu devo aparecer por Porto Alegre, para o FISL.

Venha Tomar um Chimarrão no Estande da Globo.com durante o FISL!


Programando em C para console -  parte 1
2008-04-02T14:10:00.003-03:00
(Depois de um fecundo primeiro de Abril... )

Cada vez mais eu me espanto com a quantidade de novatos que tentam fazer programas para o "modo console" que não fazem o menor sentido.

Programas com menuzinho (1 - saque , 2 - deposito, 3 - sair) ou do estilo "digite um numero (q para sair)" são totalmente contra-produtivos. O novato perde TEMPO fazendo um monte de código desnecessário quando esquece o que deveria fazer (o tal do algoritmo).

Veja um exemplo: um programa que receba uma quantidade variavel de números e que imprima a soma dos mesmos. IMHO a forma mais interessante para fazer isso é pegar os números como argumentos do programa principal. Vc cria um programa console absolutamente limpo e facil de scriptar, por exemplo.

Veja só:

#include <stdio.h>

int main(int argc, char *argv[]){
        double soma = 0.0;

        printf("A soma dos numeros eh %g\n",soma);

        return 0;
}


Feito esse simples arquivo, vamos compilar
$ gcc -Wall soma.c
$ ./a.out 1 2 3 4 5 
A soma dos numeros eh 0


Ai vc fala "po, ta errado!", mas claro, eu primeiro escrevi a base do meu programa. Perceba que eu compilei com a opção -Wall, que me informa todos os warnings que a compilação pode gerar (o que sempre é uma excelente pratica, eu procuro compilar sempre com 0 warnings).

Feito isso, vamos definir 2 coisas:
 - O algoritmo da soma e
 - Possiveis fluxos de excessão.

Vou partir do suposto que, se vc digitar alguma coisa que não seja um numero, eu vou ignorar e considerar como 0. Caso eu não informe nenhum numero ao programa, isso significa que estou faltando com alguma coisa, nesse caso vou informar uma mensagem elucidativa sobre o uso do programa.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
        int i;
        double soma = 0.0;

        if(argc == 1){
                fprintf(stderr,"Faltando Argumentos!\n");
                fprintf(stderr,"Uso: %s x1 [ x2 .. xN ]\n",argv[0]);
                return 1;
        }

        for(i=1;i<argc;i++) 
                soma += atof(argv[i]);

        printf("A soma dos numeros eh %g\n",soma);

        return 0;
}


Todos os argumentos que eu passo para o programa, incluindo o nome do mesmo, ficam no vetor argv, e o número de argumentos fica na variavel arcc. Dessa forma, o nome do programa é o argv[0] e, se eu não passar nenhum argumento adicional, argc será 1. A função atof converte a string para um número de ponto flutuante e retorna 0 se não for possivel converter.

Simples, não? Agora vamos executar:

$ ./a.out          
Faltando Argumentos!
Uso: ./a.out x1 [ x2 .. xN ]
$ echo $?
1
$ ./a.out 1 2 3 4 5
A soma dos numeros eh 15
$ echo $?
0


A mensagem de uso utiliza uma notação no manual de alguns programas do mundo unix: colocar os argumentos opcionais entre colchetes. Eu informo que preciso de pelo menos um argumento. Caso eu entre no fluxo de excessão, o meu main retorna um valor diferente de 0 para o sistema operacional que pode ser capturado pela variavel de ambiente $? (nesse caso estou em um linux utilizando o bash, em outros sistemas mais exotéricos como o Windows eu não imagino como vc poderia capturar essa informação, tampouco imagino se ela seria util).

Perceba que eu posso criar um script extremamente simples para utilizar esse programa, assim como testar o resultado é uma tarefa de um grep (ou diff). Eu poderia juntar um script de teste e um makefile nesse post mas estou esperando um exemplo um pouco mais interessante.

Eu criei um programa sucinto, facil de entender e muito util, sem ter que perguntar para o usuario nada. transformar esse programa num que calcula a média, por exemplo, é uma tarefa de colocar apenas uma linha (na verdade uma subtração e uma divisão) a mais. Espero que os programadores novatos se inspirem nessa forma de pensar e que utilizem os programas básicos do unix como o grep, cat, diff, cp, etc, para seus futuros trabalhos.


Java 1.7 vai ter Ponteiros!!!
2008-04-01T19:28:00.005-03:00
Sensacional.

Um dos recursos mais uteis do C finalmente conquistou o mundo java: a notação de ponteiros do Kernighan & Ritchie.

public class Example{
    public static void main(String [] args){
       int *x, y=0;
       x = &y;
       System.out.println("O valor de x eh " + *x);
    }
}

Agora será possivel fazer, em java:

- Passar primitivos por referência.
- Usar malloc, realloc e free.
- Utilizar ponteiros void para converter uma URL em String, ou um Throwable em um List.
- Sem falar que as Strings terão um caracter a mais no fim: o famoso \0 (na verdade a classe String deve desaparecer no Java 1.8, sendo substituida pelo bom e velho array de char)

Parabéns Sun!


WhiteSpace Server Pages
2008-04-01T18:59:00.001-03:00
E... para completar o dia: 
<?WhiteSpace
Say hello.   
          
       
          
        
          
        
          
         
          
         
         
         
         
         
          
          
          
          
          
          
          
          
          
          
         
          
          
          
          
          
         
           
          
           
          
           
          
           
          
           
          
           
          
           
         
           
    
       

                                          

                                                          




                          
    
 

                                          
 
     
 
                                                                          
 
      
    
 
                                        

                                                                          
 

 


 

                                  
 
  
  
      
        
    
                                                                  
 

    
    
 
                                

                                                                  
 

    
        
   
 

                                                          
       
       
 
   
  
 
?>



Novas Tecnologias .Net
2008-04-01T18:51:00.002-03:00
A Microsoft resolveu contra-atacar a proposta da SUN com o FSP que, de uma tacada só, 6 novas linguagens no mundo dot NET: vejam exemplos dos novissimos ABAP .Net, ASM .Net, BrainFuck .Net, JCL .Net e VHDL .Net.

Para a parte web, vc poderá utilizar qualquer uma destas linguagens. Todas serão compiladas para CLI pelo ISS. A nova tecnologia permite, inclusive, rodar um .BAT, veja os exemplos abaixo!

<?ABAP
  REPORT ZHB00001.
  WRITE: 'Hello world'.
?>


<?ASM
 SECTION .data

 msg db "Hello, world!",0xa ; 
 len equ     $ - msg

 SECTION .text
 global main

main:
        mov     eax,4 
        mov     ebx,1   
        mov     ecx,msg
        mov     edx,len 
 int     0x80

 mov eax,1
        mov     ebx,0      
        int     0x80
?>


<?BRAINFUCK
  ++++++++++[>+++++++>++++++++++>+++<<<-]>++.>+.+++++++
  ..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.
?>


<?MSDOS
  @ECHO OFF
  REM Hello World for DOS batch

  ECHO Hello World!
?>


<?JCL
  //HERIB    JOB  ,'HERIBERT OTTEN',PRTY=12
  //* Hello World for MVS
  //HALLO    EXEC PGM=IEBGENER
  //SYSPRINT DD SYSOUT=*
  //SYSUT2   DD SYSOUT=T
  //SYSUT1   DD *
  Hello World!
  /*
  //
?>


<?VHDL
  ENTITY helloworld IS
  END helloworld;

  ARCHITECTURE hw OF helloworld IS

  BEGIN

  ASSERT FALSE
  REPORT "HELLO, WORLD!"
  SEVERITY NOTE;

   END hw;
?>


Essa microsoft...


FSP - Fortran Server Pages!
2008-04-01T11:21:00.003-03:00
Sensacional.

A SUN está ressucitando uma das mais velozes linguagens de todos os tempos. Uma nova tecnologia web foi anunciada hoje: Fortran Server Pages!


<?FORTRAN
*
C Hello World in Fortran 77
C (lines must be 6 characters indented)
*
      PROGRAM HELLOW
      WRITE(UNIT=*, FMT=*) 'Hello World'
      END
?>


A ideia é atingir um novo patamar em sistemas web.

Fonte: Google


Hackeando um Hello World com sed
2008-03-28T17:55:00.001-03:00
Fantástico o que o sed pode fazer!

$ cat a.c
main(){ 
     puts("hello world"); 
}
$ gcc a.c
$ ./a.out 
hello world
$ sed -i 's/hello world/_ola mundo_/'./a.out 
$ ./a.out 
_ola mundo_



A internacionalização do Engodo (2)
2008-03-12T14:37:00.001-03:00
Excelente artigo do Olavo de Carvalho:

A internacionalização do Engodo (2)


Pra bom entendedor...
2008-03-10T14:07:00.001-03:00


Fonte: http://xkcd.com/378/


Projeto reconhece profissões de TI
2008-03-07T19:14:00.002-03:00
Projeto reconhece profissões de TI, mas exclui criação de conselhos

Fonte: TI Inside

A Comissão de Ciência, Tecnologia, Inovação, Comunicação e Informática (CCT) do Senado aprovou, nesta quarta-feira (5/3), parecer favorável do senador Eduardo Azeredo (PSDB-MG) ao projeto de lei que regulamenta o exercício das profissões de analista de sistemas e técnico de informática. A proposta é de autoria do senador Expedito Júnior (PR-RO) e agora será encaminhada à Comissão de Assuntos Sociais (CAS), na qual receberá decisão terminativa.
(...)
De acordo com a proposta, a profissão de analista de sistemas somente poderá ser exercida por pessoas que possuam diploma de nível superior em análise de sistemas, ciência da computação ou processamento de dados.


Sem comentários...


Sobre o "ensino" de Java hoje em dia.
2008-03-06T08:22:00.003-03:00
Java é uma linguagem orientada a objetos que contem tipos primitivos e wrappers para estes tipos, é executada sobre uma maquina virtual, com suporte a herança simples mas possui interfaces, com mecanismos de sobreescrita e sobrecarga de métodos, com um sistema de tratamento de exceções que te obriga a tratar determinadas situações e por ai vai.

Ao meu ver o estudo da linguagem deveria focar o domínio do mecanismo de herança e a construção de classes, domínio dos métodos, tipos de retorno, escopos de variavel, conversão de tipos, domínio das estruturas condicionais, de loops e de tratamento de erros, domínio das operações matemáticas e lógicas e,principalmente, domínio da classe String (ok, domínio pode ser uma palavra forte, talvez uma boa noção fosse suficiente em algumas situações).

Com disso tudo, o aluno deveria primeiro trabalhar com argumentos de linha de comando (o que vc acha que o main recebe?), depois passar a estudar a leitura e escrita em arquivo texto e, por fim, leitura pela entrada padrão.

Pois leitura pela entrada padrão é o que vc menos vai fazer em Java. Ninguem faz programa com menuzinho em Java pra console no mercado. Temos coisas mais complexas pela frente e sem conhecer tudo aquilo que eu listei antes só é possivel fazer gambiarras (como as famosas class functions, gigantescos métodos que fazem centenas de coisas com nomes adequados do tipo createTree3).

Ensina-se Java ao contrário: primeiro o camarada programa como se fosse C, perdendo tempo em fazer menus e estruturas de controle pois o usuario pode ter dado um enter, tab, "ç" ou ter digitado algo inválido quando deveria aprender os fundamentos da linguagem. Cria-se vícios que pode ser custoso para remover (como encher o código de getters/setters sem necessidade). A prova disso é que invariavelmente temos comparação de Strings usando o operador == quando deveria ser utilizado os métodos adequados para isso (imagina o susto quando a galera descobre o equalsIgnoreCase).

Eu vejo muitos estudantes incapazes de compilar e executar uma classe (o famoso hello world) pois os mesmos nunca fizeram uso da linha de comando muito menos foram apresentados ao conceito de classpath. Vejo barbaridades típicas de quem não conhece (ou não sabe ler) o javadoc das classes básicas. Fico me perguntando quando esses jovens serão capazes de ler um "Effective Java", por exemplo.

Aqui tem um excelente começo.

Espero que os professores acordem para essa realidade e que os alunos percebam que estão sendo prejudicados e passem a estudar por sua conta os tópicos necessários para sair arrasando pro ai.


Melhorando o “try()” do Ruby, a maneira “Groovy” [parte final]
2008-03-05T18:21:00.004-03:00
class Omega
        def a
                self
        end
        def b
                self
        end
        def c
                self
        end
        def to_s
                "Omega"
        end
end

def da? 
        begin
                yield() if block_given?
        rescue => exc
                nil
        end
end

xyz = nil
a = da? { xyz.a.b.c } 

xyz = Omega.new
b = da? { xyz.a.b.c } 

puts "da? com nil -> '#{a}'"
puts "da? com Omega -> '#{b}'"


Executando:
da? com nil -> ''
da? com Omega -> 'Omega'


O que eu fiz? como a expressão xyz.a.b.c poderia retornar algum erro pois um dos métodos poderia returnar nil, bastaria executar em um bloco de código com a ajuda do método da? (péssimo nome, uma corruptela de "da para executar sem erro? se não, me retorna nil e era wilson...), que captura qualquer erro e some com ele.

Ruby é divertido. :)

ps: teste com

a = da? { xyz.a.b.c } || "nao deu..."


Melhorando o “try()” do Ruby, a maneira “Groovy” [parte 2]
2008-03-05T15:32:00.004-03:00
Vou pedir perdão ao meu amigo Urubatan, que publicou um artigo de mesmo nome.

class Omega
   def doIt
     puts "ola"
     self
   end
end

class NullableClass
   def method_missing(*x)
      self
   end
end

class Object
   def existe?
      self
   end
end

class NilClass
   def existe? 
      NullableClass.new 
   end
end

xyz = Omega.new 
xyz . existe? . doIt . doIt

abc = nil
abc . existe? . doIt . doIt


Estou em duvida sobre o nome do metodo, por enquando fica existe? mesmo.

O que isso faz? Imagine que vc tem uma variavel ou atributo de classe que pode ser nil. Se for nil ela vai lançar um um erro em tempo de execução quando vc for tentar chamar algum método que a NilClass não possua (o que geralmente acontece, é semelhante ao NullPointerException do java).

Eu poderia resolver isso alterando o method_missing da NilClass, porém alguns scripts podem estar esperando erros desse tipo. Decidi então criar um método que, para qualquer objeto, retorna ele mesmo (self). Caso seja nil, ele vai retornar um NullableClass (outro nome infeliz, não tenho nenhuma ideia melhor) que simplesmente retorna ele para qq método requisitado.

IMHO pode ser o suficiente quando queremos fazer um teste simples: o objeto é nil? então não faz nada.

Se alguem achar isso util por favor me avise :)

Ah sim, a execução do script acima resulta em:
ola
ola



Escher em Lego
2008-02-27T11:03:00.000-03:00
Sensacional:



Alterando Multiplos Arquivos (versão final?)
2008-02-22T19:27:00.003-03:00
O site Dicas-L trouxe na ultima semana 2 formas de renomear multiplos arquivos (aqui e aqui)

#Forma 1
for o in $(ls -1 *.txt); do
  mv $o $(echo $o | awk -F. '{print $1".htm"}');
done

#Forma 2
for i in `ls *.txt`; do
  mv $i $(echo `basename $i .txt`.html)
done

São ambas formas interessantes, porém ao meu ver consomem muito recursos da maquina, sem falar que são um tanto... feios... (nada contra - o que importa é que funcione)

Vou utiliza-los como exemplo de como podemos tornar algo melhor e mais prático (se o tempo permitir).

Vamos dividir as paradas:

altera() { mv $1 $(echo `basename $1 .txt`.html) ; }

for i in `ls *.txt`; do
  altera $i
done

Agora vamos tomar um cuidado: arquivos com espaço no nome

altera() { mv "$1" $(echo `basename "$1" .txt`.html) ; }

for i in `ls *.txt`; do
  altera "${i}"
done

Bom, o for pode iterar sobre uma lista de argumentos. As mascaras de nome de arquivo são expandidos pelo shell durante a execução, logo...

for i in *.txt ; do
  altera "${i}"
done

Agora, a rotina de alteração do nome do arquivo de destino é complicadissima, depende de um ou mais sub-processos. Isso poderia ser...

altera() { mv "$1" "${1%.txt}.html" ; }

Que, inserido no for...

for i in *.txt ; do
  mv "${i}" "${i%.txt}.html"
done

Interessante, certo? Nenhum sub-processo, exceto o inumeros mv que serão executados. Existem outras formas de fazer a mesma coisa

ls *.txt | awk -F. -v OFS=. '{ O=$0; $NF="html" ;printf "\"%s\" \"%s\"\n",O,$0 }' | xargs -n 2 mv

ls *.txt | sed 's#^\(.\+\)\.[^.]\+$#"&" "\1.html"#g' | xargs -n 2 mv 

(rodem as linhas acima sem o mv do xargs para entende-las -- é metaprogramação)

Agora... tudo isso é muito bonito mas... veja se o seu computador possui os comandos mmv ou rename (que facilitam Absurdamente a tarefa)

rename .txt .html *.txt

mmv "*.txt" "#1.html"

Simples, não?

Tudo depende do tempo que temos e das nossas necessidades. Mesmo que o rename/mmv sejam uteis, pode ser que a forma com awk / sed valha  mais a pena pois o ls pode ser substituido por um find (ja pensou nisso?)


Building Didier Stevens' SpiderMonkey in Cygwin
2008-02-02T14:26:00.000-03:00
Eu estava quebrando a cabeça até que encontrei este post.

O Paul Melson ensinou de forma facil a compilar o SpiderMonkey para Cygwin: agora posso criar scripts usando javascript standalone.

Vantagem: Nenhuma, coisa de nerd :)


Twitter.sh versão 2.0
2008-01-30T09:02:00.000-03:00
O Bruno me deu uma ótima sugestão: um simples usage.

Entretanto ontem eu fiquei batendo cabeça com os inúmeros tac/tail's mas percebi q um sed resolvia a questão. Alias é possivel também passar uma lista de parâmetros também!
#!/bin/bash
TWIURL=http://m.twitter.com   # utilizando versão 'mobile' do twitter
USAGEMSG="Usage: $(basename $0) <twitter-user> [user list...]"

[ -z "$1" ] && { echo "${USAGEMSG}" ; exit 1 ; }
for i in "$@" ; do
    echo "==============================="
    links -dump "${TWIURL}/${i}" | sed -r '1,3d;/^\ +Older [0-9]+/,$d'
done

Agora chega :)


Twitter + shell script
2008-01-29T21:59:00.000-03:00
Como acessar o twitter a partir de um shell script de apenas 2 linhas? Fácil

#!/bin/bash
links -dump http://m.twitter.com/${1} | tac | sed -n '/\*/,$p' | tac | tail +2


Basta informar o username a ser impresso:

$./twitter.sh pac_man
   Twitter

   pac_man pac_man fogo controlado agora. about 1 hour ago

   Previous Updates
     * minha cozinha pegou fogo. about 4 hours ago
     * @gchapiewski To com a cuia, onde se compra a erva (mate)? about 9
       hours ago
     * @pcalcado alias XYZZY='echo -ne Zork!' about 16 hours ago
     * XYZZY about 16 hours ago
     * 4 horas pra montar um armario. Pelo menos jantei pizza. 08:36 PM
       January 28, 2008
     * Odeio fazer mudanc,a! Armario ainda nao ta pronto... 03:41 PM January
       28, 2008
     * Amanha chega a minha mudanc,a. Terei um pc finalmente. 07:41 PM
       January 27, 2008
     * Odeio limpar a areia dos gatos. 07:38 PM January 27, 2008
     * E ainda tenho q desmontar uma geladeira :/ 12:30 PM January 27, 2008


Não consegui fazer com que o links entenda o conjunto de caracteres correto mas... quebra um galho. Depois vou fazer um que submeta um post :)


Nada de muito novo.
2008-01-28T20:27:00.000-03:00
A mudança chegou hoje. Sexta começa a labuta, até lá tem muita coisa pra desencaixotar.


Enquanto isso, no RJ
2008-01-20T15:15:00.000-03:00
Depois de uma semana turbulenta cheguei vivo ao RJ, e continuo até agora.

Não tenho muitas novidades além do calos e da ansiedade - e estou sem PC em casa. 

Logo terei novidades.


Centésimo Post: Uma novidade!
2008-01-09T19:59:00.000-03:00
Um dia eu estava conferindo os sites e blogs do meu bookmark quando vi este post. Fiquei impressionado como tanta coisa fez sentido pra mim.

Eu era só um test developer que tinha começado como testador lá em são leopoldo. Vi sistemas serem feitos de todas as formas, principalmente as erradas. E tive amigos que diziam "isso não se faz mais, hoje em dia se usa hibernate/struts/webwork/...", q coisa não? 

Voltando a vaca fria, fui lendo os posts e artigos do Phillip Calçado - assim como os seus posts no GUJ - e fui acordado para a minha verdadeira vocação: programar. Mas quando li este post eu criei coragem e enviei um email, extremamente humilde, perguntando o que eu poderia estudar para não fazer feio em uma entrevista na globo.com , afinal eu sabia das minhas limitações e, naquela época, eu estava pensando em tentar a vida lá.

Phillip foi super-simpático e conseguiu uma entrevista por telefone. Foi um terror, não estava preparado, eu só queria ter uma idéia, naquela época, do que estudar para conseguir sair da minha função mais reativa, para uma função ativa (o ato de desenvolver o software em si com qualidade e ter orgulho disso). Mas não desisti.

Nas minhas férias eu tive 3 entrevistas na globo.com, sendo a última no sábado pela manhã (eu ia voltar para Poa no domingo). Valeu a pena, quando o telefone tocou e o Guilherme disse "e ai, pacman?" eu gelei.

Tinha sido aceito no grupo mais louco e fera que eu já conheci (e olha que eu ja trabalhei com o Porto e com o Casantos). Fui super humilde em todos os momentos, cheguei a acreditar que não iria conseguir em muitos momentos, mas aconteceu.

Pena que o Phillip foi para Melbourne, queria te-lo conhecido pessoalmente. Por outro lado, eu sempre poderei ler os seus blogs e posts e poderei contribuir no trabalho que ele começou na WebMedia.

Tenho que agradecer a muitas pessoas: Marujo, Marlon, Fernando, James, Marcelo Martins, a galera da HP que me atura a mais de 3 anos e a todos os loucos que me mandam parabéns pelo orkut ou gtalk e que vou sentir falta.

"Trabalhar na Barra da Tijuca, ruim né?"

Poucos sabem das reais dificuldades que eu enfrentei pra chegar ao dia de hoje. E não vou deixar de ser quem eu sou, amigos. Quando ao emprego que eu já tinha conseguido, eu tive que recusar gentilmente.

2008 promete :)


Coisas que eu gostaria de ter escutado antes.
2008-01-07T16:51:00.000-03:00
Tive a (in)felicidade de escolher, no ano de 98, ingressar no curso de Física da UFRGS. Na época eu era Nerd e não entendia nada da vida, afinal eu era um adolescente, achei que estava fazendo a coisa certa.

Dizem que é melhor que a gente se arrependa por algo que fez do que por algo que a gente não fez. Durante o meu curso, optei pelo Bacharelado (um dos cursos mais dífíceis da UFRGS inteira), acreditando que este seria o meu futuro.

Não posso reclamar: tive contato com excelentes professores e ótimos amigos. Conheci o Linux, o Fortran, o Matlab, o Método de Monte Carlo, as Equações Diferenciais e o Cálculo Numérico (sem falar na Mecânica Estatística, no Claudio Schneider,...) e conheci a reprovação, os conceitos 'C' e um primeiro A (em Algoritmos e Programação - onde aprendi Pascal e praticava em um potente 286 com 1 mega de ram).

Graças ao professor Daniel Stariolo tive 3 anos de bolsas de iniciação científica com programação em C. Por intermédio do destino, o Daniel esqueceu de renovar a minha bolsa e precisei procurar emprego para sobreviver.

Este foi o impulso que eu precisava: consegui um emprego na área de testes. Com pouca experiência mas muita nerdisse, comecei na CWI a procurar defeitos nos programas dos outros.

As vezes precisamos acordar: estar dentro de um curso de graduação, principalmente no curso errado, limita um pouco a nossa visão do mundo. A nossa vontade de encontrar um grupo social nos faz crer que estamos fazer o que é certo e que estamos felizes (ou não estamos triste demais).

Coisas que eu gostaria de ter escutado antes:

- Leia muitos e diferentes livros
- Aprenda Inglês (ao ponto de falar bem ao telefone)
- Se tiver a chance: Aprenda a Dirigir. Dane-se que vc não tem carro
- Trate o seu currículo e a sua carreira com respeito
- Aprenda Java, Python, Ruby, Shell, AWK, HTML, C++, LISP, SQL...
- Aprenda BEM e pratique muito.
- Tenha Amizades positivas (do tipo que vão trabalhar com o que vc quer, que pensam parecido com vc, que te ajudem e sejam ajudados por ti).
E o principal,
- Faculdade é parte da nossa carreira. Se vc não estuda diariamente, se vc não se atualiza, se vc não se esforça, vc está perdendo tempo. Mude alguma coisa e não tenha medo de ousar: melhor do que estar a 9 anos no mesmo curso e ficar apatico com perguntas do tipo "não vai te formar?".

Sim, jovens que estão prestando vestibular ou que estão pensando no que fazer ainda, o mundo é cruel e complexo. A melhor maneira de se adaptar ao mundo chamado "Brasil País de Terceiro Mundo" é tenho conhecimento amplo, variado e capaz de gerar mais conhecimento - evitando conhecimentos do tipo 'paranóicos' e 'fanatistas'. 

Quando eu nasci o Brasil era uma ditadura. Meu avô era membro do PC-do-B, já podem imaginar. Eu lembro que ele escutava a Radio de Moscou (na programação de 2 horas em português) todo o dia e acreditava em tudo. Um dia o muro de Berlin caiu... e o mundo pode ver a quantidade de casas sem agua potável ou esgoto na antiga URSS, por exemplo. Tivemos o Collor, o FHC e, agora, o Lula. O Mundo muda, o Brasil mudou. Quem se dedicar a uma vida mais limitada sofrerá com as mudanças futuras e necessárias para que possamos alcançar um bom padrão de vida - ou vai sofrer ao se adaptar a um país melhor lá fora.

Pensem. Leiam. Tenham bons amigos e tenham boas conversas. Se informem diariamente e não fiquem mantendo as mesmas ideias por muito tempo: é necessário fluidez.

E fluidez não se ensina, se aprende aos poucos.

Quem estiver em dúvida sobre o que fazer, seja na vida acadêmica, na carreira profissional ou na vida amorosa, opte por procurar diferentes fontes de informação, dê atenção as fontes de melhor qualidade, raciocine e faça uma escolha - tendo a responsabilidade de arcar com o escolhido.

E se preparem para errar. Só acerta muito quem erra bastante.

Pronto, acabou a sessão "auto-ajuda" de hoje. Não vou prometer que dinheiro é encontrado no Vaso Sanitário ou que o Brócolis torna a Vida mais Feliz. Aliás a felicidade é algo passageiro e momentâneo, o resto das nossas vidas é desprovido de felicidade. É interessante pensar nisso pois precisamos encarar a verdade: o mundo é chato, é feio, é fedido, é cheio de gente que não presta e ainda podemos levar uma bala perdida devido a um debil mental que usa revolver para comemorar o fim de ano. Teremos pouquissimos momentos realmente felizes na nossa vida e são esses momentos que valem a pena.

Um abraço e espero que faça sentido para alguem :)

Feliz 2008!

Ps: é normal rodar em Cálculo I a primeira vez que se faz. Acredite.


Pra bom entendedor...
2008-01-06T16:11:00.000-03:00



Coisas boas do Rio de Janeiro
2008-01-03T18:56:00.000-03:00
Porto Alegre tem coisas boas (chimarrão, redenção, xis do cavanhas, suco da lancheria do parque, gasômetro e polar).

Entretanto o Rio de Janeiro me impressiona cada vez mais. A imensa variedade de sabores (na mesma quadra vc encontra culinária nordestina, frutos do mar, empadas, picanha, sushi e muito, mas muito chopp), as praias, os recantos escondidos (como grumari), a floresta da tijuca, o jardim botânico, a imensa atividade (em TODO o lugar tem algo acontecendo, a qualquer hora).

Fora o Calor...

A personalidade do carioca é um tanto diferente da gaúcha. Falta a estética do frio, o que ja era de se esperar.

Domingo volto pra porto alegre, algumas despedidas irão rolar. Até la estou juntando alguns assuntos nerds para postar aqui :)


Peczenyj agora é cidadão carioca
2007-12-24T12:47:00.000-03:00
Pois é...

Depois de muitas considerações decidi encarar o desafio de me mudar de Porto Alegre para o Rio de Janeiro. Facil não é, tampouco barato.

Recebi uma proposta irrecusável de uma empresa para trabalhar com o middleware de Tv Digital. Vai envolver muitos testes automatizados, java, lua, C, desafios novos, cidade nova, enfim, muita coisa boa. Logo vou postar umas coisas que eu ando aprontando aqui...


No Rio
2007-12-18T19:06:00.000-03:00
3 dias de viagens seguidos. Foi cansativo.

Sábado saimos de Poa para chegar, 9 horas depois, em Curitiba. Muitos desvios na estrada, duas gatas berrando de vez em quando, sol e fome. Chegando, fomos numa churrascaria muito boa chamada Per Tutti e dormimos.

Domingo chegamos em São Paulo - a estrada para lá é hedionda. Depois de descansar um pouco, fomos numa 'lancheria' chamada Fifties, muito boa. Depois tomei um café expresso e dormimos.

Segunda chegamos no Rio. Depois de enfrentar um longo caminho, foi um alívio passar pela Serra das Araras e chegar à cidade. Deixamos nossas duas gatas na avó da Juliana e viemos pra casa, na Tijuca.

Hoje o dia foi cheio, andei um bom pedaço do centro do Rio, andei de metrô, tive conversas interessantes... quinta vou beber com o pessoal do MBB em lugar secreto, até lá terei alguma coisa boa para comemorar (alem de estar na cidade magavilhosa).

Quarta é o dia...


Ferias
2007-12-14T21:24:00.000-03:00
Estou saindo de férias, quando tiver novidades irei postar :)


Testes Unitários com VBScript
2007-12-03T12:49:00.000-03:00
Nas ultimas semanas, tive que aprender VBScript por conta de alguns testes que estão por vir. A sintaxe é bem estranha, mas fazer o que...

Entretanto é simples o suficiente para se desenvolver pequenas rotinas e, de quebra, aprender boas praticas de programação, como TDD, no exemplo abaixo:

' Função a ser testada
' EhPrimo determina se um determinado número inteiro é primo ou não
Function EhPrimo(numero)
   '
   'coloque o codigo aqui :)
   '
   EhPrimo=false ' so pra retornar algo...
End Function

'Coloquei o nome Test para ficar mais facil :)
Sub Test( objQuery, strMessage ) 
   If Not objQuery Then
    WScript.Echo VbCrlf & "ERRO: " & strMessage
    WScript.Quit 'no primeiro teste errado...
   End If
End Sub

' Testando primos
Primos = array(2,3,5,7,11)
For Each Numero  In Primos
  Test EhPrimo(Numero),"Numero " & Numero & " deve ser primo!"
Next

' Testando _nao_ primos
NaoPrimos = array(4,6,8,9,10)
For Each Numero In NaoPrimos
  Test (Not EhPrimo(Numero)),"Numero " & Numero & " NAO deve ser primo!"
Next

' Testando outras coisas
Test (Not EhPrimo( 0)),"Numero  0 NAO deve ser primo!"
Test (Not EhPrimo( 1)),"Numero  1 NAO deve ser primo!"
Test (Not EhPrimo(-1)),"Numero -1 NAO deve ser primo!"


WScript.Echo VbCrlf & "Pronto, passou tudo!"


Pronto, agora 

Qual a vantagem dessa abordagem?
 1) vc se obriga a testar o seu código 
 2) vc descobre quais parametros são uteis nas suas funções
 3) vc especifica o comportamento das suas funções ANTES de implementa-la:)


Evento Tchelinux nesse Sábado
2007-11-28T13:14:00.000-03:00
Nerds do Sul!

Sábado (1 de dezembro) haverá mais uma edição do Tchelinux, dessa vez em Porto Alegre.

Será um dia cheio de palestras de workshops, ao custo de 2 kilos de alimentos não pereciveis.

http://www.tchelinux.org/2007/

Inclusive eu irei ministrar uma palestra sobre AWK/SED no começo da tarde. Destaco também a palestra do Carlos Santos sobre "A História do Unix".

Enfim, um dia cheio de Ubuntu, Python, KDE, Kernel, BSD e muito mais!

Apareçam!


Analise Orientada a Objetos com Java - Parte 1
2007-11-17T15:02:00.000-03:00
Estes dias eu me deparei com um problema bem interessante: uma forma de atribuir professores a disciplinas por meio de um sistema feito em Java. 

Já aviso, estou tentando aprender e achei este exemplo interessante. Este post é uma tentativa de análise orientada à objetos feita de forma progressiva, comentários são bem vindos.

A primeira proposta foram 2 matrizes bidimensionais, uma com os professores disponíveis naquele dia e outra com as turmas, distribuidas ao longo de uma semana. Eu logo percebi que isso podia ser um problema de modelagem, pois se vc vai utilizar matrizes, paineis, interface textual ou seja lá o que for, isto é apenas uma camada - a visão. Um modelo muito mais rico pode ser criado, vejamos este exemplo em Java:

class Professor{}
class Disciplina{}
class Turma{
 Disciplina disciplina;
 Professor  professor;
}
public class Main{
 public static void main(String[] args) {
  Professor  oseias     = new Professor();
  Disciplina matematica = new Disciplina();
  Turma matA = new Turma();
  
  matA.disciplina = matematica;
  matA.professor  = oseias;
 }
}


A minha classe Main mostra como seriam as operações sobre estas 3 classes. Basicamente eu tenho uma classe Professor, uma classe Disciplina e uma classe Turma. Se vc observarem qualquer instituição de ensino vão perceber que uma turma tem-um professor e tem-uma disciplina associados (composição).

Percebam também que eu não fui até uma escola ou universidade e fiquei horas levantando requisitos, criado diagramas uml ou documentos no word - apenas criei uma casca inicial de código (cheio de problemas por sinal). Também não me importo, ainda, com nenhum aspecto temporal. Sem falar que esta escola todos os professores podem dar qualquer disciplina - agora vamos implementar direito.

Vejamos... uma turma não troca de disciplina facilmente, mas de professor sim. Faz sentido, então, ter um setter de professor e um construtor que receba uma disciplina. Outra coisa, eu não defini nada nas outras classes, então está na hora de definir 2 atributos : id (numérico) e nome (String). Vou diferenciar os objetos pelo código, isto é, o seu id, e o nome será utilizado como descrição. Vou sobreescrever os métodos equals e toString.

Como o nome desses objetos é importante, vou coloca-los no construtor também (assim como o id).

class Professor{
 long id;
 private String nome;
 public Professor(long id,String nome){
  this.id = id;
  this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
  boolean test = false;

  if (!(o instanceof Professor))
   test = super.equals(o);
  else 
   test = ((Professor) o).getId() == this.id; 
  return test;
 } 
}
class Disciplina{
 long id;
 private String nome;
 public Disciplina(long id,String nome){
  this.id = id;
  this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
  boolean test = false;

  if (!(o instanceof Disciplina))
   test = super.equals(o);
  else 
   test = ((Disciplina) o).getId() == this.id; 
  return test;
 }
}
class Turma{
 long id;
 private String nome;
 private Disciplina disciplina;
 private Professor  professor;
 public Turma(long id, String nome,Disciplina disciplina){
  this.id = id;
  this.nome = nome;
  this.disciplina = disciplina;
 }
 public void setProfessor(Professor  professor){
  this.professor = professor;
 }
 public long getId(){ return id; }
 public String toString(){ 
  return this.nome + " [" + this.disciplina 
         + "] c/ " + this.professor ; 
 }
 public boolean equals(Object o){
  boolean test = false;

  if (!(o instanceof Turma))
   test = super.equals(o);
  else 
   test = ((Turma) o).getId() == this.id; 
  return test;
 } 
}
public class Main {
 public static void main(String[] args) {
  /* objetos bem comportados */
  Professor  oseias     = new Professor(1L,"Oseias");
  Disciplina matematica = new Disciplina(1L,"Matematica");
  Turma matA = new Turma(1L,"Matematica A", matematica);
  matA.setProfessor(oseias); 
  
  System.out.println("Professor  " + oseias);    
  System.out.println("Disciplina " + matematica);  
  System.out.println("Turma      " + matA);
  
  /* objetos mal comportados 
   * Sujeitos a NullPointerException    */
  Professor juca = new Professor(2L,null);
  Disciplina calculo = new Disciplina(2L,null);
  Turma matB = new Turma(2L,"Matematica B", null);
  matB.setProfessor(null); // nem precisava mas...
  Turma matC = new Turma(3L,"Matematica C",calculo);  
  Turma matD = new Turma(4L,"Matematica D",calculo);
  matD.setProfessor(juca);
  
  System.out.println("Juca?   " + juca);
  System.out.println("Calculo?" + calculo);
  System.out.println("matB?   " + matB);  
  System.out.println("matC?   " + matC);
  System.out.println("matD?   " + matD);
 }
}


Mas que raios eu estou fazendo? veja a saída desse programa:

Professor  Oseias
Disciplina Matematica
Turma      Matematica A [Matematica] c/ Oseias
Juca?   null
Calculo?null
matB?   Matematica B [null] c/ null
matC?   Matematica C [null] c/ null
matD?   Matematica D [null] c/ null


Qual o significado? Bom... eu tenho uma forma razoavel de representar um professor, disciplina e turma, porém não é pratico, o construtor está gigante e, em muitas situações, eu posso ter parâmetros nulos, o que pode ser uma fonte de problemas. Existem muitas formas de refatorar estas classes, eu nem toquei no HashCode, enfim, tem muito pano pra manga. 

Apresento a vcs o desenvolvimento em etapas, iterativo. Eu estou chutando requisitos aos poucos, é verdade, mas eu entrego um codigo testável e completo e cada ciclo. Com os usuarios testando esse código (nesse caso, uma API, mas enfim...)  eu obtenho um feedback interessante. O que vc acha?


Nascimentos
2007-11-08T19:56:00.000-03:00
Coisas maravilhosas acontecem.

Descubro recentemente que um amigo meu virou papai. A pequena Sophia nasceu prematura, logo deve estar aos cuidados da família coruja. Agora descubro que outro amigo será pai: já está na sétima semana. Eta Canoenses!

É... o tempo passa... quando estamos na faculdade descobri que um colega será pai/mãe é incomum, mas com o passar do tempo temos que escutar "e tu, pra quando vai ser?"...

Na hora certa (espero eu).


Ferramentas de Teste
2007-11-06T14:28:00.001-03:00
Excelente comparativo de duas ferramentas gratuitas de teste automatizado para interfaces web.

http://mguillem.wordpress.com/2007/10/29/webtest-vs-selenium-webtest-wins-13-5/

Pelo escore final, creio que muitos projetos web poderiam ser beneficiados pela combinação destas duas ferramentas.


From Nand to Tetris in 12 Steps
2007-11-06T13:50:00.000-03:00
Otimo vídeo - Google Tech Talks October 10 ,2007
 

Link direto aqui.


AWK e Arrays Associativos
2007-10-31T13:09:00.000-03:00
Um grande problema para quem trabalha com arrays associativos no AWK é
com relação a ordem dos elementos quando esta fazendo uma iteração.

Ex:
$ gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
1
3
5
4
2


Eu inseri, nessa ordem, 5, depois 4, depois 2... porém o acesso aos
elementos de um array em um for do tipo
for( variavel in array)

é imprevisive / incontrolável.

Agora vejamos isto:

$ WHINY_USERS=1 gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
5
4
2
1
3


WOW! Através da variavel de ambiente do unix WHINY_USERS agora eu consigo acessar os elementos na ordem em que eles foram inseridos no array!

E para acessar os valores na ordem crescente:
$ WHINY_USERS=1  gawk 'BEGIN{ split("5 4 2 1 3",T)
 asort(T) ;  for(i in T) print T[i] }'
1
2
3
4
5


A variavel de ambiente WHINY_USERS não esta documentada no man, muito menos na documentação que consegui a respeito do gawk. Descobri esta dica no comp.lang.awk e, por incrivel que pareça, tive que vasculhar o codigo fonte do gawk (graças a deus podemos fazer isso) para entender melhor o que essa variavel poderia fazer.

Enfim, fica a dica.


Tchelinux 2007 - Chamada de trabalhos
2007-10-30T14:53:00.000-03:00
Seja bem-vindo à chamada de trabalhos do 2º Seminário do Software Livre Tchelinux que irá acontecer dia 1º de Dezembro de 2007 na UFRGS em Porto Alegre, RS. Antes de enviar sua proposta de palestra, recomendamos que leia atenciosamente o regulamento abaixo:

Sobre o Temário:

A equipe de avaliação de propostas irá selecionar 10 palestras técnicas sobre Software Livre dentro dos seguintes temas:

Sistemas Operacionais
Desktop baseado em Software Livre
Aplicativos Gráficos
Jogos e Multimídia
Linguagens de programação
Ferramentas para desenvolvimento
Banco de dados
Administração de Sistemas
Redes e Segurança da Informação

Sobre as Apresentações:

- Cada palestrante terá 75 minutos para apresentar seu trabalho 
- Os recursos disponíveis serão projetor multimídia e micro-computador rodando Ubuntu Gutsy
- O palestrante deverá permitir que os slides de sua palestra seja publicada no site do grupo
- Não haverá nenhuma remuneração ou reembolso de despesas para palestrantes

http://www.tchelinux.org/papers/

Participem!


Entendendo Ponteiros na linguagem C
2007-10-24T11:09:00.000-03:00
Entender ponteiros (e ponteiros para ponteiros) nem sempre é facil quando estamos vendo C ou C++ pela primeira vez. O conceito é absurdamente simples, assim como os operadores * e &, mas pelo menos para mim demorou um tempão para a ficha cair (e olha que eu utilizava arrays direto e nem me ligava nesse detalhe).

Com auxilio do pre-processador C, vejamos se este exemplo que pode ser elucidativo:

#include "pointer.h" 
int main () 
{ 
        int x = 0;              // variavel de exemplo 
        pointer(int) y;         // ponteiro 

        y = address(x);         // y aponta para o endereco de x 

        x++;                    // incrementamos o valor de x 
        value(y)++;             // incremento indireto (via ponteiro) 

        printf("value   %d %d\n",x, value(y) ); 
        printf("address %p %p\n",address(x), y ); 

        return 0; 
} 


Ou seja, a criação de um ponteiro para uma variavel do tipo inteira é através da macro pointer. Outra macro, address, retorna o endereço de uma variavel e, assim, tenho uma referência aquela variavel. Posso então ter acesso ao valor e até mesmo manipular a variavel original.

Vejamos agora o resultado da execução:
$ ./a.out
value   2 2
address 0xbfffeaa4 0xbfffeaa4


Perceba que eu consegui incrementar a variavel duas vezes (através das duas formas disponíveis). Perceba também que o ponteiro y tem como valor o mesmo endereço de memória que a variavel x, razão pela qual consigo alterar o seu valor.

O codigo gerado pelas macros 

int main () 
{ 
        int x = 0; // variavel de exemplo 
        int * y; // ponteiro 

        y = (&(x)); // y aponta para o endereco de x 

        x++; // incrementamos o valor de x 
        (*y)++; // incremento indireto (via ponteiro) 

        printf("value   %d %d\n",x, (*y)); 
        printf("address %p %p\n",(&(x)), y); 

        return 0; 
} 


Eu recomendo que, uma vez que o conceito tenha ficado claro, que não se use mais este header sob pena de criar arquivos ilegíveis. Por exemplo, tente compilar com a opção de gerar os simbolos para debug (-g) e depois tente debugar esse programa: perceberão que o gdb, por exemplo, não mostra o codigo fonte com tanta clareza.

Para fazer este exemplo, utilizamos este arquivo header:

#define pointer(type)                    type *
#define value(var)                       (*(var))
#define address(var)                     (&(var))



Tropa de Elite 2 - Dia de Treinamento Java
2007-10-07T21:22:00.000-03:00
Seguimos com novos exemplos inspirados na triste realidade da polícia carioca.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{      
 private String nome; 
 private int qtdeVitimas = 1; // ja começa bem!
  
 public Bope(String nome){
  this.nome = nome;
 }  
 // sobrecarga do método ondeTaOBaiano
 public void ondeTaOBaiano(Estudante e){
    e.sabeVoarEstudante();
 }
 public void ondeTaOBaiano(Traficante t){
 t.levaSacoNaCabeca();
 }
 // exemplo de método final!
 public final Doze encontreiOBaiano(Baiano b){
 return b.naCaraNaoQueEhPraNaoEstragarVelorio();
 }
}

public class Treinamento{
 public static void main(String [] xxx){
  // Apresento o capitão nascimento
  Bope instrutor = new Bope("Capitao Nascimento");
  try{
 // de cada 100 policiais que fazem o curso do Bope,
 // so se formam 5, e eu, quando me formei parceiro,   
 // eramos apenas 3.  
        Turma.tentaFazerCursoBopeCom(capitao);
  } catch (PolicialCorruptoEncontrado pce){

  } catch (PolicialFracoEncontrado pfe){

  } catch (PolicialSemABandoleiraNessaAlturadoCampeonato e){

  }
 }
}


SEUS FANFARRÕES!
VCS TEM 10 SEGUNDOS PARA COMPLETAR ESSE CÓDIGO!

- O zero-dois NÃO está escrevendo!
- SEU zero-dois, porque o senhor não escreveu nenhuma linha?
- A-a minha IDE não terminou de carregar, senhor...
- Agora a sua IDE ja carregou, seu zero-dois?
- S-sim senhor...
- Então, seu zero-dois, termine o seu programa, senão todos os seus colegas terão que usar o EDIT do MS-DOS até o fim do curso E A CULPA EH DO ZERO-DOIS!

 

HOMEM DE PRETO QUAL É A SUA MISSÃO?
É APRENDER JAVA SEM PRECISAR DE CERTIFICAÇÃO!
HOMEM DE PRETO O QUE É QUE VC FAZ?
FAÇO CODIGO FONTE QUE ASSUSTA O SATANÁS!
 

Estratégia, do inglês, Strategy...

- Senhor, o zero-cinco está dormindo...


Aprendendo Conceitos antes de Sintaxe
2007-10-04T21:10:00.001-03:00
O homem aprende por dois motivos: por gosto ou por necessidade.

Depois de passar um semestre brincando com Pascal na era pré-google ( quando não encontravamos uma pagina através do yahoo ou cadê, tentavamos urls aleatórias como www.pascal.org - que era a pagina da família pascal ), tive uma disciplina cujo professor só sabia Fortran e C.

Através do MOO descobri o curso on-line da UFMG, e pude dar os primeiros passos em C. Entretanto o foco dessa disciplina não era fazer agenda ou video-locadora - eram programas científicos. Linux, gnuplot, maple... foi um mundo muito divertido.

É claro que algumas coisas eu simplesmente não compreendia: os tais dos ponteiros, por exemplo. Era só ver um * que não fosse multiplicação que eu já tinha dor de cabeça. E assim se passaram alguns anos onde eu apenas reproduzia os comandos que tinha aprendido.

Anos depois, conversando com o CaSantos caímos em uma micro-aula de programação. Eis que ele profere sabias palavras: Ao estudar uma linguagem de programação, a primeira coisa que se precisa estudar são os conceitos e, por último, a sua sintaxe.

Toda a vez que eu entrava em uma lista de discussão ou forum e via as perguntas dos novatos eu lembrava dessa frase. Coisas como dizer que os arquivos .h do C são bibliotecas, colocar system("pause") pro programa não "fechar do nada" e por ai vai. O tipo da coisa que, quem conhece o conceito, não perguntaria.

Por que razão não se ensina os conceitos de uma linguagem logo no começo? Eu só posso pensar que é para os alunos aprenderem de forma intuitiva no começo e resgatar isso mais tarde (talvez em uma cadeira de compiladores, sei lá), mas será que isso acontece? 

Geralmente o trabalho de fim de semestre dessas cadeiras é um CRUD em C com listagem (ou relatório) de alguma coisa ordenada de uma ou mais formas. Cadastrar alunos ou contas bancárias, salvando em arquivo.

Pois bem, se é uma disciplina introdutória, por que raios alguem iria pedir um CRUD?? Meu deus, os alunos mal sabem como compilar o programa, tampouco debuga-lo - No maximo enchem de printf("passei por aqui") - e pedem um programa com 'menu interativo'! Ai o camarada perde metade do tempo fazendo 'menuzinho' com asteriscos ou outro caracter e não consegue implementar a lógica. Quando implementa é aquela maçaroca. O que isso ensina?

Eu daria uma sugestão: quer ensinar C ou Java ou Snobol 4, ensine. Mas não peça um programa CRUD cheio de frescura - peça uma biblioteca. De um arquivo header ou uma interface java e diga: implementem essas funções/metodos ai. Eu vou testar o meu programa com essa biblioteca e espero que tudo funcione.

videolocadora.h
int cadastra_video(char *nome, int preco, int categoria);
int cadastra_cliente(char *nome, char *cpf, char *endereco);
int aluga_video(...);


Enfim, não consigo pensar num exemplo melhor. A ideia é introduzir um desenvolvimento em camadas, deixando o aluno pensar em como ele vai gravar, ler e ordenar os dados sem frescuras de tela, ensinando a fazer testes e também a debugar a aplicação.

Quer ensinar a fazer telinha? Ensina em outra disciplina, nesse caso ensinando técnicas de design apropriadas. Começando pela linha de comando do unix: como pode um aluno se formar sem nunca ter criado o seu próprio grep? Criar interfaces com o usuário não é algo facil, requer muito estudo, principalmente de usabilidade.

Alias fazer "telinhas" geralmente supõe colocar um programa em um estado. Quem aprende o conceito de maquina de estados no momento que esta fazendo esse cadastro? Posso apostar que esse pessoal não sabe o que é stateless e statefull e o professor nem pensa q isso seja importante (aqui eu lembro da agenda de telefones que eu fiz em pascal).

Fica aqui a minha sugestão. Espero que faça sentido :)


Convertendo Números
2007-10-01T19:29:00.000-03:00
Um dos meus primeiros desafios na área de programação foi fazer um conversor de números decimais para romanos. Eu estava aprendendo Turbo Pascal e usava um potente 286 com 1MB de memória - sem HD.

Fiz a maior sequencia de ifs da minha vida. Hoje estava relembrando e resolvi fazer uma versão SED.

/[0-9]*[5-9]...$/q
s/1...$/M&/;s/2...$/MM&/;s/3...$/MMM&/;s/4...$/MMMM&/
s/6..$/DC&/;s/7..$/DCC&/;s/8..$/DCCC&/;s/9..$/CM&/
s/1..$/C&/;s/2..$/CC&/;s/3..$/CCC&/;s/4..$/CD&/;s/5..$/D&/
s/6.$/LX&/;s/7.$/LXX&/;s/8.$/LXXX&/;s/9.$/XC&/
s/1.$/X&/;s/2.$/XX&/;s/3.$/XXX&/;s/4.$/XL&/;s/5.$/L&/
s/1$/I/;s/2$/II/;s/3$/III/;s/4$/IV/;s/5$/V/
s/6$/VI/;s/7$/VII/;s/8$/VIII/;s/9$/IX/
s/[0-9]//g


Tendo um número por linha ja basta. 

$ echo '3999' | sed -f other.sed
MMMCMXCIX


O sed é realmente fantástico! Pena que acima de 5 mil tem que colocar uma barra em cima dos números.


Aprenda Java com os melhores versão Tropa de Elite
2007-09-30T21:01:00.000-03:00
Exatamente: Não vem com essa que vc é istudante, vai tomar tapa na cara se não aprender Java. Saiba que, de cada 100, só 5 terminam o curso. Nem na Sun se treina programador assim.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{
        
 private String nome; 
 private int vitimas;
  
 public Bope(String nome){
  this.nome = nome;
  this.vitimas =0;
 }
  
 public void matou(int tantas_vitimas_agora){    
  this.vitimas = this.vitimas + tantas_vitimas_agora;
 }
 
 public int quantas_vitimas(){
  return this.vitimas;
 }
}

public class Programa{
 public static void main(String [] xxx){
  // Apresento o capitão nascimento
  Bope capitao = new Bope("Capitao Nascimento");
  
  // quando o capitão sobe a favela, é pra matar, não pra morrer
  capitao.matou(1000);
  
  // agora ele subiu o morro de novo, com ele não tem erro.
  capitao.matou(2000);
  
  // e a farda dele não é azul, é PRETA
  System.out.println("O Bope matou: " + capitao.quantas_vitimas());
 }
}


Entendeu? Não?

ENTÃO PEDE PRA SAIR, GUERREIRO!
TU É CORRUPTO, TEU LUGAR É COM .NET, É COM VB! JOCKEY DE IDE! PEDE PRA SAIR AGORA!


Ruby e o method_missing
2007-09-28T11:43:00.000-03:00
Os objetos em Ruby possuem um método chamado 'respond_to?' para verificar se o objeto possui (ou melhor, se ele responde a) um determinado método. Em uma linguagem dinâmica como o ruby, onde podemos incluir um método numa classe em runtime, é um recurso muito necessário, ainda mais se pensarmos em termos de Duck Typing.

Em caso de dúvida, basta fazer um if, afinal chamar um método que não existe causa um NoMethodError, certo?

Depende. Observe:

class A
        def xxx()
                puts "xxx"
        end
        def method_missing(m, *args)
                puts "nao tenho esse metodo: #{m}"
        end
end

a = A.new
a.xxx
# aqui normalmente daria erro e o script seria abortado 
# sem o rescue adequado
a.yyy 


Resultado:
~> ruby A.rb
xxx
nao tenho esse metodo: yyy


Eu sobreescrevi o método 'method_missing', que como o próprio nome indica, intercepta uma chamada a um método inexistente. Divertido, não?


Ruby e suas travessuras
2007-09-24T23:33:00.001-03:00
irb(main):001:0> def some(thing)
irb(main):002:1>    puts "some#{thing}"
irb(main):003:1> end
=> nil
irb(main):004:0> some "thing"
something
=> nil
irb(main):005:0> some = "thing"
=> "thing"
irb(main):006:0> some(some)
something
=> nil



Ajude para ser ajudado.
2007-09-22T15:47:00.000-03:00
Não é incomum encontrarmos pedidos de ajuda (as vezes em caps lock, com a palavra "urgente" e com açassinatos ao idioma corrente) em listas de discussão ou foruns.

Por exemplo:
   no postgresql o comando sql abaixo funciona perfeitamente  
     
   "SELECT c.descricao, u.nome, v.data_venda ,"  
   + "v.valor_total, v.condicao_pagamento, v.codigo"   
   + "from venda v, carro c, usuario u"   
   + "where v.carro = c.codigo and v.usuario = u.codigo";  
     
   mas quando executo no java ocorre erro
  

Não vejo diferença entre falar apenas isso e esta conversa pelo telefone:

- Alo, consultório médico
- Doutor, é a primeira vez que ligo, nunca nos vimos...
- Pronto, me diga o que esta sentindo.
- me sinto mal...
- Ah, tome um chá de joaçaba com mel e 2 anti-coagulantes
- Certo, e quanto a isso aqui na minha perna?
- Humm... vamos ter que operar. Ou espera uma semana que passa...


Enfim...


Resumo do primeiro Chopp on Rails de  Poa
2007-09-22T00:55:00.001-03:00
O pessoal da lista rails-rs organizou um encontro em um local com bastante cerveja.

Acho que a melhor descrição do que poderia ter sido é esta:



Curso de Ruby on Rails em Porto Alegre
2007-09-18T10:11:00.001-03:00
Uma oportunidade imperdível!

A Tech Office IT realiza no período de 24 a 28 de setembro de 2007 em Porto Alegre, o curso presencial Ruby on Rails, voltado a desenvolvedores Ruby que desejam conhecer mais sobre Rails e desenvolvedores de outras linguagens que tenham interesse em ingressar no RoR. O curso objetiva auxiliar o aluno a entender o Ruby on Rails e possibilitar a criação de aplicações o utilizando, além de expor suas vantagens e limitações.

Após o curso o aluno estará apto a desenvolver aplicações WEB utilizando o Ruby On Rails, saberá onde procurar mais recursos para acelerar o desenvolvimento e adicionar recursos na aplicação desenvolvida.

Com carga horária de 20 horas/aula, o treinamento será 100% prático e ministrado em laboratório. Durante o curso, os participantes desenvolverão uma loja de DVDs completa que poderá ser utilizada como exemplo ou como base para o desenvolvimento de uma aplicação mais complexa pós-curso. Mais informações poderão ser obtidas através do site www.techoffice.com.br ou e-mail contato (at) techoffice (.) com (.) br, além do telefone 51.3012.8241.

Mais detalhes sobre o curso de Ruby on Rails

Clique aqui para se inscrever no curso de Ruby On Rails

Se alguem não sabe o poder do Ruby on Rails, veja esse video:




Vagas Abertas!
2007-09-18T09:58:00.000-03:00
Pessoal, trago aqui pelo menos 5 oportunidades de ingressar em uma das maiores empresas de tecnologia do mundo. O ambiente de trabalho é excelente, as condições são muito boas e existem muitas possibilidades de crescimento. Todas as vagas são para trabalhar em Porto Alegre/RS.

Desenvolvedor C# - 3 vagas
Experiência em desenvolvimento/programação de SW em C# e .Net
Conhecimentos sobre UML e OO e design patterns
Conhecimentos sobre XML e XPATH
Inglês avançado/fluente

Desenvolvedor/Testador - 2 vagas
Experiência na área de teste de software
Conhecimento de WebServices e protocolos SOAP e HTTP
Conhecimento de XML, XPATH e alguma linguagem Script
Experiência em OO
Inglês fluente

É claro, caso alguem queira ingressar na área de informática, eu sugiro que pense nessa vaga:
Testador de Software
Experiência na área de teste de software
Conhecimentos em Banco de Dados e SQL (select, update, insert,delete)

Aos interessados enviar email com currículo para tiago (.) peczenyj (at) gmail (.) com


Die Working Hardly
2007-08-29T21:29:00.000-03:00
Sensacional Filme sobre efeitos especiais... sem efeitos especiais.

Foi dirigido pelo Zach Lipovsky, para concorrer no On The Lot, um dos programas mais inteligentes dos ultimos tempos: um reality show sobre cinema e o vencedor ganhou um contrato com a Dreamworks e foi trabalhar com o Steven Spielberg (entretanto não foi o Zach que ganhou)!

Quem não gostaria de fazer isso no seu proprio ambiente de trabalho?



Link aqui.


Metaprogramação com awk e sed
2007-08-28T15:17:00.000-03:00
Criar um programa que cria programas é simples nas linguagens interpretadas.

Criamos o programa em uma string e executamos via eval() ou então gravamos em arquivo e executamos novamente.

Me deparei com o seguinte problema: inverter as palavras de uma frase ou arquivo mantendo a ordem em que aparecem.

É claro que eu pensei em usar o rev, mas ele inverte a linha como um todo. Depois de fazer um laço for muito feio em awk, fiquei pensando em como resolver de forma mais legível.

Tive esta ideia: vou fazer uma lista de palavras, inverte-las com o rev e, para cada palavra, vou substitui-la pela palavra invertida. Beleza, o sed faz isso com um pé nas costas.

Eu tenho um arquivo (poderia ser um named pipe) chamado 'direito' que contem uma lista de palavras sem repetição, com uma palavra por linha. Outro arquivo, com o mesmo conteudo mas revertido via 'rev'.

Uso o paste para colocar os arquivo lado a lado e uso o awk para gerar comandos como este:s/\bpalavra\b/palavra_revertida/g;


Usei o awk pq a sintaxe fica mais clara, o sed ficou muito poluído. Perceba que eu uso o recurso de borda das expressões regulares. Isso me garante que vou trocar uma palavra inteira, e não um pedaço da string.
 
Agora vem o pulo do gato: mando estes comandos via stdin para o sed, fazendo uso de um pipe. eu informo para o sed que os comandos virão pela stdin passando a opção -f -

Vejam o resultado abaixo, espero que seja útil para alguem :)

$ cat stuff
Nosso fórum principal.

Problemas com hardware em geral,

temperaturas, comparação de desempenho,

compatibilidades de componentes, etc.

$ LC_ALL=pt_BR grep -oE '\w+' stuff | sort -u | tee direito | rev > reverso

$ paste direito reverso | awk '{
     printf "s/\\b%s\\b/%s/g;\n",$1,$2 # facil, não?
  }' | sed -f - stuff
ossoN muróf lapicnirp.

samelborP moc erawdrah me lareg,

sarutarepmet, oãçarapmoc ed ohnepmesed,

sedadilibitapmoc ed setnenopmoc, cte.

Como o arquivo possui acentos, precisei setar a variavel LC_ALL para pt_BR, caso contrario a expressão regular \w+ não iria casar com todas as palavras.

Ps: Julio, que tal chamar isso de "Inversor do Tiago"?


Extended Globbing
2007-08-28T15:15:00.000-03:00
Não sei se é conhecimento de todos mas o Bash possui, alem do globbing normal (a expansão * ? e [a-z] de nomes de arquivos e diretórios), um globbing extendido.

Acho que, em alguns casos, podera ser BEM util, eliminando um pipe para um grep por exemplo.

São eles (direto do man)
?(pattern-list)
     Matches zero or one occurrence of the given patterns
*(pattern-list)
     Matches zero or more occurrences of the given patterns
+(pattern-list)
     Matches one or more occurrences of the given patterns
@(pattern-list)
     Matches exactly one of the given patterns
!(pattern-list)
     Matches anything except one of the given patterns

Para poder utiliza-lo precisa executar o shopt conforme o exemplo abaixo

$ shopt -s extglob

$ ls
file  filename  filenamename  fileutils

$ ls file?(name) # padrão pode aparecer 0 a 1 vezes
 
file  filename

$ ls file*(name) # padrão pode aparecer 0 a N vezes
file  filename  filenamename

$ ls file+(name) # padrão pode aparecer 1 a N vezes
filename  filenamename

$ ls file@(name) # padrão deve aparecer 1 unica vez
filename

$ ls file!(name) # divertido esse! padrão NÃO deve aparecer
file  filenamename  fileutils

$ ls file+(name|utils) # cada padrão pode aparecer 1 a N vezes
filename  filenamename  fileutils

$ ls file@(name|utils) # "lembra" um file{name,utils} ;-)
filename  fileutils



JEDI - Java Education and Development Initiative
2007-08-18T15:22:00.000-03:00
JEDI e o ensino de Java gratuito

Iniciado pela Universidade das Filipinas e apoiado pela Sun Microsystems, nasce através do Java Research & Development Center, a iniciativa JEDI (Java Education and Development Initiative), em Fevereiro de 2005.

A partir desta data, o JEDI vem sendo desenvolvido como um projeto colaborativo, que conta com o apoio da comunidade Java em todo o mundo. Tem como principais objetivos o de melhorar a experiência do ensino e da aprendizagem; Aumentar a qualidade dos graduados em Ciência da Computação e Tecnologia da Informação (disponibilizando os materiais de seus cursos gratuitamente para quem se interessar); Aumentar o banco de especialistas em Java e, Fornecer serviços e produtos a altura das necessidades do mercado mundial.

Tecnologia Java

A tecnologia Java está presente, hoje, em 2 bilhões de dispositivos tecnológicos em todo o planeta - e também fora dele, já que podemos localizar dispositivos Java rodando até em Marte. Existem hoje, no mundo, cerca de 579 milhões de celulares com Java, 93 operadoras de telefonia móvel, 750 milhões de cartões SmartCard (do tipo JavaCard) distribuídos, 650 milhões de computadores pessoais e com 2 milhões de cópias da plataforma empresarial J2EE. Por isto, 68% das novas aplicações, hoje, são desenvolvidas em Java, que substituiu o C++ como a competência mais procurada pelos profissionais. É executado em múltiplas plataformas e em uma ampla gama de dispositivos, indo de um pequeno chip em SmartCards aos servidores dos Grandes Data Centers.

Demanda por Profissionais

Com tudo isso, existe hoje, uma demanda por 2 milhões de novos profissionais de TI a cada ano. Desenvolvedores Java, devem prover soluções nas mais diversas áreas de tecnologia. Torna-se crescente a necessidade, por exemplo, do desenvolvimento de soluções para aparelhos celulares que demandam uma integração com sistemas legados, de maneira a fornecer soluções corporativas. A partir disto, o conhecimento de Java e de sistemas abertos, são imprescindíveis para profissionais de TI.

Além da demanda, a tendência é um outro fator motivador para este mercado. No Brasil, esta aponta para direção de trabalhos realizados para clientes de fora do país - o outsourced. É crescente a procura por parte das organizações, o desenvolvimento de projetos baseados em tecnologia Java, distribuindo-se as aplicações desenvolvidas aqui pela Internet.

Todavia, a busca do mercado por esse perfil de profissional vai de encontro com a capacidade de fornecimento do conhecimento Java. O fato é que, o mercado tem dificuldade em encontrar desenvolvedores com competência nos fundamentos de Tecnologia da Informação, orientação a objetos, conhecimento e experiência em Java avançado, competência em comunicação e nas relações interpessoais.

A industria de software supre o despreparo dos profissionais formados pelo mercado, com a necessidade de re-treinamento interno dos novos contratados, muitos graduados sem conhecimento em TI. A grande maioria não tem uma certificação, que tem um valor adicional no mercado, especialmente para trabalhos executados fora do pais. Outro fator que colabora para o despreparo do profissional é fato do treinamento oficial Java da Sun ser relativamente caro e os programas de treinamento interno das empresas atuais serem pouco abrangentes. Disso resulta uma contratação de apenas 5% dos currículos recebidos nas empresas.

Academicamente o treinamento é, muitas vezes gratuito e de boa qualidade, é acessível. Contrastando, os professores não possuem experiência prática das demandas da indústria e não há, por parte de centros acadêmicos, a compreensão com respeito ás preocupações da industria de software, que não conseguem cobrir as necessidades que o mercado exige. Aliado a isso, está a dificuldade de alterar os currículos acadêmicos.

E o JEDI ?

O JEDI, entra neste contexto de forma totalmente gratuita para a comunidade e disponibiliza todo o acesso aos cursos e materiais. O aluno terá ao seu dispor manuais, slides de apresentação das aulas, provas, exercícios e material de referência e vídeo-aulas. Contando ainda com os softwares, o treinamento de instrutores, o acesso a suporte e a lista de discussão da comunidade.

Na Filipinas já existe uma estrutura acadêmica dividida em fases. Na primeira fase foram disponibilizados os cursos de Introdução a programação I (versão 1.3); Introdução a Programação II (versão 1.1) e Estruturas de Dados (versão1.1). Na segunda fase os cursos de Engenharia de software (versão 1.0); Desenvolvimento de aplicações móveis (versão 1.0); Programação Web (versão 1.0). Na terceira fase, os cursos de Web Services; Segurança em Java e Programação, modelagem e análise orientada à objetos. Completando quatro semestres de curso com: Sistemas operacionais; Gerenciamento de projetos orientados à objetos e Inteligência artificial. Todo este material está atualmente disponível para download, em Inglês, no site Java.net.

A comunidade JEDI tem contribuído bastante para o sucesso desta iniciativa, em todo o mundo existem mais de 80 pessoas contribuindo ativamente. Os treinamentos são realizados pelos membros do JEDI que conduzem os testes e recebem cada vez mais pessoas como voluntárias. O JEDI possui, atualmente, parcerias globais nas Filipinas através de JP Petines (Java champion), no Brasil através de Daniel deOliveira (Java champion), na França através de Vicent Brabant (Java champion) e de coordenações na Malásia, Tailândia, Singapura, Japão e Vietnam.

Hoje o JEDI concentra o maior número de membros nas Filipinas. Desde fevereiro de 2005 até abril de 2006 são 110 escolas - 10% de todas as universidades e faculdades das Filipinas aderentes ao programa; Foram realizados 13 treinamentos e formados 207 instrutores multiplicadores, que formaram 1.318 instrutores que atendem a 48.205 estudantes.

Países de Língua Portuguesa

O Brasília Java Users Group - DFJUG é responsável pela coordenação do JEDI em países de língua portuguesa. Angola, Cabo Verde, Guiné-Bissau, Brasil, Moçambique, Portugal, São Tomé e Príncipe; Timor Leste serão países que poderão fazer o treinamento em língua nativa, com todos os recursos que a iniciativa provê. O DFJUG possui mais de 9.900 membros e é totalmente baseado em trabalho voluntário, sem personalidade jurídica e patrocinado pelo Instituto CTS, OSCIP, voltada para a pesquisa e desenvolvimento de tecnologias de software, que fornece ao grupo apoio logístico, administrativo e jurídico.

Atualmente, o Brasil conta, segundo a SUN Microsystems, com 70 mil desenvolvedores Java e 43 grupos de usuários Java, com mais de 25 mil membros participantes. É através do apoio destes grupos distribuídos em todos os estados da nação que esta iniciativa espera se consolidar, para elevar o nível de aprendizado Java, provendo melhores profissionais para atender as exigências do mercado mundial.

Como participar do JEDI ?

No momento estamos trabalhando na tradução e adaptação do material utilizado na Filipinas. Um vez que este esteja concluído, os cursos poderão ser acessados pelo site. Ao concluir o processo cada aluno terá que fazer uma prova presencial para obter a sua certificação, que será oferecida agentes que serão certificados em todo Brasil.

O DFJUG necessita de pessoas para corrigir e dar opiniões sobre todo o material produzido e realizar testes de Stress no site aonde o JEDI será hospedado, isso é um trabalho que somente poderá ser realizado com o apoio de toda a comunidade javanesa existente no Brasil. Quem quiser participar da iniciativa, no Brasil, deve acessar a página do DFJUG (www.dfjug.org) e entrar em contato com o grupo. Junte-se a nós, participe no instrutor ou como aluno desta iniciativa, poderemos assim enriquecer o conhecimento da linguagem e difundi-la de uma forma totalmente gratuita, voluntária e colaborativa, no Brasil e em diversos paises de língua portuguesa, será seu trabalho e seu empenho que ajudará elevar o Brasil ao hall dos melhores desenvolvedores JAVA no mundo.


I Jornada em Defesa do Pensamento Científico
2007-08-16T13:47:00.000-03:00
A disciplina de Metodologia Científica do curso de Geociências e
Educação Ambiental do Instituto de Geociências da USP e a Sociedade
Brasileira de Céticos e Racionalistas realizarão a I Jornada em Defesa
do Pensamento Científico.

Abaixo mais detalhes e a programação:
—————
Data: 18 de setembro (terça-feira)
Local: IGc/USP - R. do Lago, 562 - Cid. Universitária - Butantã - São
Paulo - SP

Programação:
09h10 a 09h30: Abertura Prof. Drs. Arlei Benedito Macedo (USP) e
Renato Sabbatini (Unicamp).
09h40 a 10h20: Analfabetismo científico, Prof. Dr. Renato Sabbatini
(Unicamp).
10h20 a 10h40: Café.
10h40 a 11h20: Criacionismo, Prof. Dr. Mário de Pinna (USP).
11h30 a 12h10: Como vender o pensamento não-científico, Prof. Dr.
Francisco Stefano Wechsler (UNESP)
12h10 a 14h00: Almoço.
14h00 a 14h40: Sensacionalismo e Jornalismo Científico, - Ulisses
Capozzoli - Astronomy Brasil).
14h50 a 15h30: Pensamento Crítico - Panorama da América Latina - Sr.
Alejandro J. Borgo (Pensar - CFI/Argentina)
15h30 a 15h50: Café
15h50 a 16h30: A defesa do pensamento científico nas universidades e
centros de pesquisa (mesa-redonda).
16h40 a 17h10: Resultados preliminares da pesquisa sobre
Pseudociências (alunos do LIGEA)
19h00 a 19h40: Ilusões e equívocos do pensamento humano, - Dr. Sérgio
Navega - (Intelliwise Research and Training).
19h40 a 20h00: Sumário e encerramento, - Prof. Dr. Francisco Stefano
Wechsler - UNESP).

Taxa de inscrição: R$ 60,00
Mais informações: palestrasreflexoes2007@gmail.com


Implementando um Corretor Ortográfico
2007-08-11T23:56:00.000-03:00
O maluco do Peter Norvig (google) publicou no seu site o artigo How to Write a Spelling Corrector. Impressionante o que 21 linhas de Python são capazes de fazer!

>>> correct('speling')
'spelling'
>>> correct('korrecter')
'corrector'


Não é atoa que o Google é o que é hoje em dia.


Linux para Leigos
2007-08-11T10:45:00.000-03:00
Vamos analisar a condição de leigo.

Eu já vi centenas de leigos que, ao sentar no computador, baixavam músicas, videos e jogos com os mais diversos programas, conectavam no irc, msn, icq, colocavam luzinhas e bichinhos animados para acompanhar o cursor do mouse, trocavam as fontes e os temas, procuravam os mais bizarros jogos, encontravam videos extremamente incomuns (sem youtube), etc. Para o que não presta, os leigos tem uma criatividade impressionante!

Quando falamos em um sistema pra leigos não precisamos pensar que as usuarios tem preguiça mental. Eles até podem ter, mas aí cabe aos projetistas desafiar e exercitar essa criatividade do mal e tranformar em criatividade do bem. Qualquer pessoa que senta na frente de um browser vai acabar nas paginas mais escabrosas mesmo que não sabia o que é 'google'. Vai me dizer que, nesse caso, a linha de comando é ameaçadora ou difícil?

Das duas, uma: ou pensamos em uma camada de software para permitir que um usuario abstraia o sistema operacional e as configurações (normalmente se faz isso em sistemas "embarcados") e use todos os recursos multimídia e de troca de informação com a facilidade de um pensamento OU pensamos em sistemas mais inteligentes, com documentação adequada e, com a ajuda da comunidade, divulgamos as informações e conceitos corretos. O Linux só é seguro porque o usuario comum, que vai fazer besteira, não tem a senha de root.

Não podemos fazer sistemas operacionais à prova de gente sem noção ou que sejam capazes de oferecer tanta intuitividade sem sacrificar a segurança, por exemplo.

Puxa, não tem nada mais fácil que usar a linha de comando (ok, sou suspeito pra falar). As pessoas não usam [o shell] pois não tem como acessar o orkut, ver vídeo do youtube, etc, de um jeito bonitinho. Alem de tudo, tá em inglês, ECA. Hoje em dia existem shells para pessoas iniciantes que ajudam, colorem o texto e sugerem mudanças praticas, como o fish.

É assim que fazemos um sistema pra leigos -- temos que desafia-los a usar a criatividade que normalmente é usada pra criatividade do MAL e mostrar que um PC com linux não é um playstation. Quer usar um browser de verdade e usar o orkut e o youtube? PO! não tem nada mais facil que instalar um ubuntu da vida e clicar no icone do firefox!

Não vamos tomar atitudes de forma a não desafiar intelectualmente os usuários. Eles merecem todo o nosso respeito. Agora quem quer que o usuário não pense que faça uma camada de software que abstraia o Sistema Operacional. Existe mercado para ambas as coisas.

Entretanto acho mais humano que a gente exercite os cérebros atrofiados dos empurradores de mouse. Há 20 anos as pessoas usavam computadores com 32 kb de RAM e carregavam os jogos de uma fita K7 e ninguem morreu por isso -- pelo contrário desenvolveram skills hoje necessárias em muitos cargos importantes e empresas como algumas multinacionais procuram desesperadamente.


Torvalds - A Microsoft simplesmente não me interessa
2007-08-10T00:53:00.000-03:00

Será que Linus Torvalds e a comunidade do software livre podem vencer esta guerra contra as legiões de Bill Gates?

Linus Torvalds - Não vejo isso como uma “batalha”. Faço o que faço porque gosto e acho que vale à pena, e não estou nessa por causa de nenhuma cruzada anti-Microsoft. Usei alguns produtos da Microsoft ao longo dos anos, mas nunca nutri uma forte antipatia contra eles. A Microsoft simplesmente não me interessa. E o movimento de código aberto não é um movimento anti-Microsoft, apesar de haver certos grupos que talvez participem devido aos seus sentimentos anti-Microsoft.

O código aberto é um modelo sobre como fazer coisas, e eu acredito que este é um jeito muito melhor de fazer as coisas. O código livre vai tomar conta do mercado não por causa de nenhuma “batalha”, mas simplesmente porque jeitos melhores de fazer as coisas eventualmente tomam o lugar de métodos inferiores.

Por acaso a “ciência” é uma batalha contra a “ignorância”? Não, a ciência simplesmente é. E ela funciona tão bem que assume o lugar de velhas noções ignorantes. Não precisamos nos preocupar com gatos pretos cruzando a nossa frente, passar por baixo de escadas ou espelhos quebrados, pois hoje sabemos como o mundo funciona, e nos demos conta de que gatos pretos não são mais um sinal de perigo.

Fonte: idgnow

Sem mais palavras...


Google Wars
2007-08-07T18:43:00.000-03:00
Inutilidade Pública: veja o que/quem possui mais resultados no google?

./GoogleWars.sh  superman batman
batman          48500000
superman        33700000

./GoogleWars.sh  gremio inter
inter           213000000
gremio          5560000

./GoogleWars.sh  hp ibm
hp      379000000
ibm     147000000

./GoogleWars.sh  cobol java fortran perl ruby lisp haskell
java    272000000
perl    103000000
ruby    101000000
lisp    21400000
fortran 17400000
haskell 15400000
cobol   10900000

O script é simples, abusando um pouco do SED e do AWK, com um toque de SORT ;-)

#!/bin/bash
COR=`echo -ne '\e[31;1m'`
END=`echo -ne '\e[m'`
CORSED="1s/.*/${COR}&${END}/"
GOOGLE='http://www.google.com/search'

[[ $2 ]] || { echo "usage: $0 item item2 [ ... item n]" ; exit 0 ; }

SEDCMD='/did not match any documents/{s/.*/0/g;p;q}
        /Results/{s/.* about[ ]\+\([0-9,.]\+\).*/\1\n/;p;q}'
AWKCMD='{ result[$1]=$2 ; x = length($1) ; if(x > max) max=x }
        END{   for(i in result) printf "%-"max"s\t%s\n",i,result[i]}'

for i in "$@" ; do echo -ne "${i}\t" 
        lynx -dump "${GOOGLE}?q=${i}" | tr -d '\n.,' | sed -n "${SEDCMD}" 
done | awk -F '\t' "${AWKCMD}" | sort -nr -t $'\t' -k 2 | sed "${CORSED}"


Quem quiser melhora-lo, sinta-se à vontade :)

Edit: ja lancei uma versão .02 com umas correções cosméticas aqui -- não resisti...


Considerações de Segurança
2007-08-06T14:21:00.000-03:00
Me irrita profundamente usar um script que pressupõe certas definições no meu ambiente sem aviso prévio. O caso mais comum é, em algum *nix, acreditar que o diretório corrente faz parte do PATH -- contrariando uma regra básica de segurança, inclusive.

Não é dificil fazer ./programa (na verdade com o tempo isso vira padrão até). Fica uma dica importante: nunca façam suposições a respeito do ambiente, variaveis, estruturas de diretórios sem documentar ou fazer os testes necessários (pelo menos quando for fora de algum padrão).


Nightwish - Wishmaster Versão Alternativa
2007-08-03T20:23:00.000-03:00
Sensacional esta 'versão':



Hamster - Apprendice - HeartBurn - Seven Seagals - Mario - this Apple - in me - Jewish Master !

Se não conseguiu visualizar clique aqui.


Caçadores da Classe Perdida
2007-08-03T16:20:00.000-03:00
Eu já tinha feito algo parecido mas este post do Claudio Miranda reavivou a minha memória.

#!/bin/bash
[[ $2 ]] || { echo "Uso: ${0} diretorio classe" ; exit 1 ; }
find "${1}" -name \*.jar -print | xargs -n 1 unzip -l 2>&- | awk -v class="${2}" '
        BEGIN       { IGNORECASE=1                                     }
        /^Archive/  { file="\nArquivo:\n\t"$NF": \nClasses:\n\t"       }
        /class$/ && $NF ~ class { print file,$NF ; file="\t"; total++  }
        END         { print "\nTotal",total + 0,"classes encontradas!" }'


Informando como parâmetros um diretório de partida e um fragmento do nome da classe, o find localizará todos os arquivos com extensão jar e vai mandar pro nosso amigo xargs. Este envia um a um para o unzip que lista (-l) o conteúdo de cada arquivo. Eu poderia procurar a classe que eu quero com o grep, mas o awk foi a escolha para formatar melhor a saída de dados.

Perceba que a variavel IGNORECASE tem valor diferente de 0, assim eu posso procurar por um trecho do tipo xml ou XML. Eu preciso saber o nome do arquivo 'corrente' e isso é informado pela linha que começa com 'Archive'. Quando eu encontro uma linha que termina com 'class' e o ultimo campo ( $NF ) 'casa' com o fragmento de nome (alias pode ser uma expressão regular!) eu imprimo esta linha.

Eu fiz uma sacanagem pra saída de dados ficar 'bonitinha', que é imprimir o 'cabeçalho' apenas uma vez, depois eu troco por tab (\t) -- e no final eu mostro um sumário com o número de referências encontradas.

Este script pode ser modificado para outros propósitos. Note que eu procuro tanto no nome da classe quando no nome dos pacotes (diretórios), assim xml poderia casar com XMLHelper.class ou /java/xml/foobar.jar -- mas basta ser criativo para resolver isso!


Powders Graduation
2007-08-02T16:31:00.000-03:00
Os programas de tradução estão cada vez melhores.

Pós Graduação = Powders Graduation

Graduação em Pó? Pulverizada?

São 22 resultados no google até o momento!


Usando o curl com Endereços IPv6
2007-08-02T13:28:00.000-03:00
Hoje em dia usar endereçamento IPv6 parece um pouco exótico, porém aos poucos ele começa a aparecer em algumas redes internas e logo será a unica saída quando todos os 32 bits do IPv4 estiverem em uso, previsto para 2012.
 
Diga adeus ao "206.45.32.234" - longa vida ao "2001:bce4:5641:3412:341:45ae:fe32:65". Perceba como agora utilizamos a representação hexadecimal e cada quarteto é separado por um ':' -- o que torna mais fácil a sua memorização (e viva o DNS). Um bom artigo introdutório pode ser lido aqui.

Pois bem, imagine agora que precisamos acessar uma pagina em um servidor (por enquanto interno) através de um endereço IPv6. A url ficaria assim, por exemplo:

http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php


Como o caracter ':' é usado em uma url para separar o servidor da porta (é claro que isso é omitido na maioria dos casos, quando usamos a porta 80), e tiveram que proteger o ip entre [colchetes]. Um browser como o Firefox consegue entender esta url facilmente, entretanto não tive a mesma sorte ao usar os browsers modo texto mais comuns - lynx e o curl. 

Não subestime a importância destes browsers! Muitas vezes nos encontramos em um sistema com poucos recursos ou precisamos efetuar certas ações via algum script e eles caem como uma luva -- principalmente o curl, que simplesmente transfere informações de/para um servidor web, fazendo GET, POST, HEAD, upload de arquivos, etc. 

No man do curl descobri que o mesmo depende da libcurl ser capaz de resolver endereços ipv6 - inclusive posso forçar a usar apenas ipv6 com a opção -6.

Entretanto o curl tem outra interpretação dos colchetes em uma url -- elas são um recurso de sequência para multiplos downloads (da mesma forma como o bash faz, porém é interno ao curl), como nesse exemplo:

curl 'http://www.any.org/archive[1996-1999]/volume[1-4]part{a,b,c,index}.html'


Para desabilitar este "URL globbing parser" basta usar a opção -g, o que nos leva a solução completa:

curl -6g 'http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php'


Caso não queria desabilitar o globbing, basta 'escapar' os colchetes usando a contra-barra antes. O curl é um programa extremamente versátil, um verdadeiro canivete suíço na linha de comando, vale a pena estuda-lo em algum tempinho livre.


Barbosa
2007-07-26T14:09:00.000-03:00
Trinta e oito anos depois da Copa do Mundo de 1950, um homem volta no tempo a fim de impedir o gol que derrotou o Brasil, destruiu seus sonhos de infância e acabou com a carreira do goleiro Barbosa.

Premiadíssimo curta de Jorge Furtado e Ana Luiza Azevedo, de 1988, unindo ficção científica e futebol de uma forma incrivelmente brasileira. Com Antônio Fagundes e Zé Vitor Castiel.

Para saber mais: CASACINEPOA

Assista aqui. Vale a pena!


Resolvendo Problemas Comuns 7 - open failed: |
2007-07-26T14:03:00.000-03:00
Imagine um arquivo com algumas linhas duplicadas:
$ cat arquivo
permission denied
bad interpreter
missing separator
set correct localle
parameter list too long
unary operator expected
parameter list too long
bad interpreter


Obter as linhas distintas pode ser feito com a ajuda do sort + uniq

$ cat arquivo | sort | uniq
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


 - Puxa! Que ótima combinação! Vamos guarda-la?

Bom, podemos querer guardar este e outros comandos em uma variável de ambiente também, afinal, deve funcionar sem maiores problemas, certo?
$ CMD="sort | uniq"
$ cat arquivo | $CMD
sort: open failed: |: No such file or directory


 - OPA! Eu sabia, maldito shell, encrenca com tudo!
 
Tsc... isso acontece porque o pipe | não foi informado como um 'pipe' e sim como a string "|" -- e o sort não conseguiu abrir o arquivo "|".
Este tipo de problema pode ser resolvido pelo eval -- ele interpreta novamente as strings na linha de comando.
$ eval "cat arquivo | $CMD"
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


 - Ah, agora funciona. Mas esse eval ai ficou feio...

Então vamos criar um alias para o comando!
$ alias cmd="sort | uniq"
$ cat arquivo | cmd
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


Perceba que o comportamento do alias é diferente de uma variavel de ambiente. Devemos ficar atento à correta interpretação da nossa linha de comando pelo shell corrente, senão vamos ter resultados nem sempre amigáveis.

Ah, sim, o cat nesse exemplo é completamente supérfluo, poderia ser assim: 'sort arquivo | uniq' 

 - E o uniq precisa do sort ? 
 
Sim... sem o sort ele fatalmente vai se perder, e é muito mais facil eliminar linhas repetidas que estejam em sequencia do que aleatórias. É bom dar uma lida no man destes comandos pois possuem opções muito poderosas!


Resolvendo Problemas Comuns 6 - unary operator expected
2007-07-26T13:07:00.000-03:00
Uma desatenção, muito comum quando trabalhamos com variáveis de ambiente no shell é que, quando elas não foram setadas ainda, o shell expande elas para... nada.

$  [ $XALALA == "oi" ] && echo 'ok' || echo 'nok'
-bash: [: ==: unary operator expected
nok


Nesse caso o (resultado do) teste da variável até pode fazer sentido, porém troque o == por um != e veja o resultado. A solução é proteger a variável com aspas!

$  [ "$XALALA" != "oi" ] && echo 'ok' || echo 'nok'
ok


Simples e rápido!