Bem, atualmente, no meu Macbook, estou utilizando o Mac OS X 10.5 (codinome: Leopard). Esta versão já veio com uma instância do Java 1.5 (Tiger), utilizada por default em qualquer comando que se digitasse “java” ou “javac” na linha de comando, ou mesmo de qualquer outra forma padrão de inicialização de aplicativo Java. Até aí tudo bem, mesmo eu já havendo instalado atualizações que me permitiriam compatibilidade com Java 1.6, nunca precisei realmente da versão mais recente. Até hoje.

Acontece que, da noite para o dia (literalmente, de madrugada), um projeto que eu estava estudando passou a requisitar Java 6 para executar. Tudo graças a uma nova versão. Após muito quebrar a cabeça para descobrir o que estava acontecendo de errado (tirando o fato de eu insistir em usar a nova versão), descobri esse problema da JRE, e após algum tempo a mais, a solução.

Não se preocupe com alterações em links de diretórios através de linha de comando, nem com remoção de arquivos e renomeação de arquivos novos (sério, essa última então, caso feita sem cautela, pode dar muita dor de cabeça). Tudo que você precisa é digitar na linha de comando:

$ open "/Applications/Utilities/Java Preferences.app"

ou navegar pelo Finder entrando na pasta “Applications”, depois em “Utilities”, e abrindo o aplicativo “Java Preferences”. E voilá! Esta figura abaixo aparece, e você pode selecionar a ordem de preferência de escolha que deseje tanto para aplicações locais, quanto para os navegadores.

Visão do Java Preferences (clique para tamanho natural)

Só posso agradecer ao local com a idéia mais próxima do que eu precisava, este aqui: http://blog.diogosantos.com/2009/09/java-5-no-macos-x-snow-leopard/

Um procedimento fácil, para quem tem uma máquina Linux por perto, é usar isto na linha de comando (dentro da pasta do pen-drive):

sudo rm -r autorun.inf RECYCLER/

su
rm -r autorun.inf RECYCLER/

Como adendo, nunca consegui fazer isso corretamente no Mac, mesmo seu modo superusuário dá problemas de permissão. Nesse ponto minha VM Linux entra em ação, e problema resolvido.

Interrogação piscante!

Ligando o macbook esta semana, fui confrontado primeiro com uma tela preta. Desliguei-o e liguei-o novamente. E lá me veio uma interrogação misteriosa piscando na tela, e nada do sistema carregar.

Conferindo o manual do Mac, descobri se tratar de um caso onde o sistema não foi encontrado. Segui os passos sugeridos pra resolver o problema:

1. reiniciar o computador pressionando a tecla “Option”;
2. inserir o CD de instalação do Mac OS X, reiniciá-lo com a tecla ‘C’ pressionada, e, com o CD em execução, ir no menu Utilities -> Disk Utilities (se não me engano), onde eu veria se poderia restaurar a partição (a qual não foi encontrada); e finalmente
3. tentar reinstalar o Mac OS X, o qual não reconheceu nenhum HD para fazer instalação.

Ótimo, constatei que meu HD devia ter quebrado.

Comprei um HD SATA novo no outro dia, com mais espaço mas com o mesmo número de RPMs, da Samsung. Instalei-o na própria loja, e logo levei mais uns 2 dias para instalar tudo que precisava e voltar à pesquisa. E o PC da casa quebra 1 dia depois.

Lições aprendidas:

1. não dormir com o notebook funcionando em um lugar sem ventilação (vide: tapete);
2. HDs são realmente fáceis de se trocar no Macbook (ver este link da Apple); e
3. o que é aquela interrogaçãozinha piscante.

Mais sorte da próxima vez!

Instalando Quake

Agora, voltarei a jogar. =)

Incompatibilidade de plugin

Instalando o plugin

Plugin instalado

Prossigo com o processo de instalação, ele demora um pouquinho baixando atualizações (ok, minha banda de conexão não é muito larga), mas finalmente consigo começar o jogo. Como estou jogando na VM, com recursos escassos para vídeo e conexão lenta, o jogo ficou bastante lento, porém mesmo assim dá pra sentir que o jogo está bom e é empolgante ter essa portabilidade para GNU/Linux através do Firefox. Resta agora conseguir isso para o Mac OS. =)

Carregando jogo

Tela de boas vindas

Começando a jogar

Jogando em tela inteira

Eclipse IDE

Durante um dia normal de pesquisa, em uma reunião onde tentávamos entender o código de um projeto open source, o Eclipse Ganymede que ele utilizava no Linux estava com um problema para executar o Debug. Toda vez que tentava executá-lo, aparecia um dialog informando:

“Cannot connect to VM”.

Estranhamos. Olhando nas configurações de JRE utilizadas, estava tudo ok, e o problema apresentava-se somente no Debug, e não na compilação/execução de programas. Apresentava também, na área “Problems”, um problema com um getthisbyname(). Estranhei. Não estaria resolvendo o nome de que, se ao testarmos só estava tentando rodar um “Hello World”? A única máquina que estaria tentando alcançar seria ela mesma: localhost. Resolvemos olhar o arquivo /etc/hosts (que guarda algumas pré-configurações de hosts em UNIX):

#127.0.0.1   localhost
127.0.0.1   xxx-notebook
#outras configurações de hosts

Para os desavisados, em arquivos de configuração UNIX é comumente utilizado o # como símbolo para comentário de linha. Logo, aparentemente devido ao fato de estar comentado, o Eclipse (ou a função getthisbyname() de Java) não conseguia resolver o nome localhost para 127.0.0.1. Removido o comentário, o Debug do Ganymede passou a funcionar perfeitamente.

Interessante, não?

Visão de módulos usando o círculo-cruz

A idéia do post veio lendo o “Utilizando UML e padrões” do Larman. A primeira vez que eu vi isso, fiquei uns 20 minutos sem entender o que era, e olhe que a explicação estava não muito distante no texto do livro. É apenas uma forma mais incomum de se mostrar isso, embora bastante limpa, mas infelizmente não está presente em várias ferramentas CASE. Só cuidado para outros não ficarem sem entender os diagramas!

VirtualBox

Instalando windows

Começando os adicionais

Warning nos adicionais

Muito bem. Em seguida, comecei a instalação de um jogo no windows, o qual requeria aceleração gráfica e bom desempenho. Depois de umas tentativas de instalação (umas 2 delas com a instalação interrompida por uma falha na USB, pois eu estava instalando em um HD externo), consegui instalar, mas um erro me impedia de jogar, apesar de eu ter habilitado aceleração 3D. Infelizmente, percebi que não conseguiria jogar na máquina virtual, precisaria bi-particionar (o que pode vir em outro post).

Mas a experiência me permitiu perceber umas coisas: a tal integração dos S.O.’s hospedeiros e convidados, até a versão 2.2.2, não funciona tãããão bem. É possível acessar dispositivos? É – consegui acessar USB por ele, pelo menos, mas não tentei fazer funcionar a câmera ainda. Mas para dispositivos como placa aceleradora 3D, que precisa de um tempo minimizado de latência de processamento, o VirtualBox ainda não faz o serviço. Um ponto negativo para instalação de adicionais para distros GNU/Linux é a necessidade de atualização de componentes do sistema (se não me engano alguns módulos do kernel) e de fazer o download, para distribuições que não vem já com isso, de ferramentas de build. Para mim não foi incômodo pois já iria instalá-las, mas um usuário um pouco mais leigo pode reclamar e preferir não usar. Outra coisa, em instalações de Ubuntu e Windows com a integração, nenhuma conseguia desligar corretamente. Aparentemente a integração não funciona tão bem com o S.O. convidado, levando a toda tentativa de desligamento abortar o sistema, e não desligá-lo. Não encontrei problemas religando-os até agora, mas creio que possam haver aplicações que venham a ser prejudicadas. Todas as observações foram feitas em uma instalação do VirtualBox com o OS X como S.O. hospedeiro.

SBRC 2009

O Workshop e o Simpósio Brasileiro de Redes de Computadores e Sistemas Distribuídos, onde ele é alocado, foram muito bons. Encontrei poucas pessoas que eu já conhecesse, e conheci muita gente legal da área. Impossível sair de um evento desses sem idéias de muita coisa pra fazer no futuro. =)

Links do WCGA, do SBRC, e de minha apresentação.

botao_mc.addEventListener(MouseEvent.CLICK,fnOI);
function fnOI(event:MouseEvent):void{
       trace("oi");
}

Adiciona-se um evento ao botão, e, ao ser clicado, será chamada a função cadastrada (fnOI) – seguindo o padrão de projeto Publisher-subscriber, se não me engano. Clicando na instância, será impresso na saída a palavra “oi”. Boa parte da interface de flash funciona com isso agora – você adiciona um evento, e as funções cadastradas serão chamadas no momento certo, para qualquer objeto possível.

Mais em breve! =p

It's alive!

Logo, logo: posts sobre cifras de Feistel, Actionscript, e experiências com VirtualBox.

=p

Tweet

Topicos:

• What’s Twitter?
• Some Twitter concepts
• A brief look at REST
• Twitter API
• What’s cURL?
• Downloading and Installing cURL
• Using cURL
• cURL and the Twitter API
• Parsing Twitter XML
• What’s Hpricot?
• Net::HTTP
• Examples and Exercises
• Using Ruby for Twitter
• Examples and Exercises

Parece legal. Vou tentar fazer, mesmo sem saber quase nada de Ruby. =D

Outra expectativa: joguinho interessante da produtora de games “The Behemoth”. Nunca joguei nada deles, mas se o trailer abaixo for fiel ao gameplay, parece bom.

Isso sem contar a expectativa final: provas e projetos. O bom e velho stress entre provas, projetos, trabalhos, monitoria, e IC. Sem isso, não tinha graça. =)

Quem viver, verá!

#!/bin/sh

contador=0
MAXIMO=15

while [ $contador -lt $MAXIMO ]
do
  echo $[ $[ $RANDOM % 30 ] + 10 ]
  contador=$[ $contador + 1 ]
done

Lindo. Imprimia uma lista de números aleatórios entre 10 e 39. Tudo o que eu queria.

O problema veio na hora de passar este pequeno script para o Ubuntu e rodar os testes necessários. Ao invés de funcionar perfeitamente, ele declarava erros incompreensíveis para mim. Informava que havia variáveis não encontradas, operações não entendidas, etc. Este é o momento em que você para e pensa: “WTF”?

Rodei novamente no Mac. Lindo. Digitei linha por linha no próprio shell do Ubuntu. Funcionou! Mas ao tentar copiar o resultado deste esforço para um documento .sh, ele se tornava em vão. Veio a dúvida: será que este shell do linux do laboratório está quebrado?

Fui verificar onde estava localizado. Após executar um file /bin/sh no Ubuntu, tive como resposta algo esclarecedor: Symbolic link to `dash‘. Lembrei de imediato que o Ubuntu não usa o Bash por questões de desempenho, e este Dash – Debian Almquist Shell possui diversas incompatibilidades com o Bash, já que utiliza um conjunto de funcionalidades mais restrito e original ao padrão POSIX.

Resultado: para corrigir o problema, alterei a linha de shebang para #!/bin/bash. Quanto às incompatibilidades, corrigirei-as depois. =)

Bem, pra demonstrar que implementa e também explicar o conceito, o autor se utiliza de um jogo-exemplo: um labirinto. O jogo constrói o labirinto através de funções que chamam umas às outras, porém utilizando-se de recursão de cauda para manter sempre o uso de memória como se só houvesse uma função. Explicação e o exemplo utilizado podem ser encontrados aqui.

Explicando melhor recursão de cauda: o princípio é que não precisamos que uma função fique esperando o retorno de um resultado de outra para terminar sua execução, como acontece normalmente. Se você faz uma função em C, ou um método em Java, que termina com um comando return outraFuncao;, a função original ficaria esperando o termino da chamada para poder terminar sua execução. Só que outraFuncao pode fazer chamadas a outras funções, e essas a mais outras, e assim por diante. Tal carga será deixada para a memória, que acabará por estourar(um stack overflow, ou estouro de pilha). Mas perceba que, no caso de uma instrução final de uma função, não há motivo para a espera de retorno da chamada. Pode-se simplesmente indicar que o retorno será o da função agora chamada, e limpar a memória utilizada pela execução da original. É isto que linguagens funcionais como Haskell e Scheme e linguagens com fortes influências, como Lua, implementam.

A novidade que gostaria de compartilhar aqui é uma implementação do mesmo código feito em Lua, para Haskell. O código pode dar origem a um jogo bastante complexo e infinitamente escalável, já que ao chamar uma nova função (entrar em um novo quarto) nenhuma informação é mantida da que chama, e sua execução é encerrada por completo. Código em Haskell abaixo:

import IO

main = do
         room1

room1 = do
          putStrLn "You're in room #1"
          text <- getLine
          if text=="south" then
            room3 -- movendo-se pro quarto 3
            else
              if text=="east" then
                room2 --movendo-se pro quarto 2
                else
                  putStrLn "Invalid move" >>
                  room1 --permanece no mesmo quarto

room2 = do
          putStrLn "You're in room #2"
          text <- getLine
          if text=="south" then
            room4
            else
              if text=="west" then
                room1
                else
                  putStrLn "Invalid move" >>
                  room2 

room3 = do
          putStrLn "You're in room #3"
          text <- getLine
          if text=="north" then
            room1
            else
              if text=="east" then
                room4
                else
                  putStrLn "Invalid move" >>
                  room3 

room4 = do
          putStrLn "You're in room #4! You won!"

O código é simples, elegante, e correto. É este mesmo comportamento que torna a recursão um ponto tão forte em Haskell: iteração não é necessária à linguagem pois recursividade não apresenta peso adicional algum ao código. Isto nos permite escrever funções recursivas muito mais poderosas do que podemos encontrar em uma linguagem como C ou Java, onde a pilha de execução não suporta tantas chamadas quanto uma tarefa mais complexa possa precisar (ex.: inserção em uma árvore AVL com 100 mil nós). Isso nos permite executar códigos como o clássico exemplo do fatorial:

fact x = if x < 0 then error"Fatoriais sao de numeros positivos!"
                       else fact2 x 1 where
                              fact2 0 acumulador = acumulador
                              fact2 x acumulador = fact2 (x-1) (acumulador*x)

Pode-se rodar este exemplo e calcular o fatorial de 100 mil, o que não é possível com recursão em C. Apesar do peso do alto nível de abstração, vemos aí parte do poder do paradigma funcional e da linguagem Haskell!

PS: Erro corrigido no quanto à recursividade do fatorial. Ah, e o exemplo do fatorial pode não dar Stack Overflow, mas dependendo da entrada você pode atingir picos de uso de CPU. =)

Trava!

Bem, métodos conhecidos na internet não funcionavam. Ou estavam errados, ou a trava estava quebrada, ou eu estava com realmente muita má sorte. Foi quando, ao procurar outro objeto mais importante, decidi apelar para força bruta com uma pitada de intelecto, o que poderia chamar de “Método do nó górdio”, para quem sacar referências históricas. Seguem as fotos sequenciais abaixo.

Prova Formal

Cuidado!!! =)

Será que, como um senador que enquanto governou Pernambuco ajudou bastante à criação do Porto digital, Jarbas está ligado também a metodologias de desenvolvimento?

…

Eu sei, a piada foi sem graça. =)

UNIX

Notícia descoberta no Br-Linux, graças à contribuição do blog deste link.

PS: Espero que o WordPress use o Unix Time para medir o tempo e publique na data correta. =)