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.
Só pra colocar um pouco do que tenho feito ultimamente para projeto da faculdade: amostra de como inserir um evento a um botão em ActionScript 3.0 – assumindo “botao_mc” como o nome de uma instância de um botã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
Agora no Portal RubyLearning: curso gratuito utilização de Twitter com Ruby.
Tweet
Topicos:
Parece legal. Vou tentar fazer, mesmo sem saber quase nada de Ruby. =D
Chegando aquela época do ano novamente: muitas coisas por vir, muitas expectativas. E já estamos quase em abril, então…
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á!
Estava fazendo um script para a pesquisa esta semana. O propósito dele deveria ser rodar e escolher números aleatórios, para matarmos processos. Ao terminar o programa, que funcionava muito bem no Mac OS X, ficou parecendo o seguinte:
#!/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. =)
Enquanto estava estudando a linguagem de programação Lua, em um capítulo sobre elementos funcionais da linguagem, me deparei com uma explicação interessante para tail recursion. Nela, o autor do livro (Programming in Lua, 1ª Edição) falava como a linguagem implementa completamente tail recursion(que acho que fica bem traduzido como recursão de cauda). Até aí tudo legal, mas melhora.
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. =)
Este post é para resolver o problema de muitas pessoas: ter uma mala que possui uma combinação para abertura, e não lembrar mais qual é. Escrevo isto pois meu caso foi um pouco extremo.
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.
