RodolfoCarvalho.net

Some Computer Science Terminology

2012-01-06T10:20:00.000-02:00

[Este post é em inglês. Se não entender, use um tradutor. Os links para a Wikipedia podem ser consultados em suas versões em português, portanto você ainda pode tirar algo proveito daqui.]

I wrote this as an email to someone special, but then I thought it could be shared here.

It is simply a few links and comments for topics we were talking about one night... you might get interested as well -- and feel free to join the conversation.

Hello dear reader!

Words in bold are terms that are interesting to be familiarized with, IMHO.

Context

http://en.wikipedia.org/wiki/Context_(computing)

(Additional term linked above: State http://en.wikipedia.org/wiki/State_(computer_science))

Environment

Note that in Scheme an environment is a first-class object, which means it can be assigned to a variable, it can be passed as argument, it can be used just like a number or string, etc etc.

Note also how Common Lisp and Scheme (and most other programming languages that I am familiar with and that I can think about now) differ in number of environments. CL is said to be a Lisp-2, while Scheme is Lisp-1. It means that Scheme has only one lexical environment containing all functions and variables, while CL has two distinct environments, one only for functions and another, independent one, for variables.

You can also think of the terms scope and namespace, which can appear to play a similar role in several languages.

http://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Environment-Operations.html

http://en.wikipedia.org/wiki/Scope_(programming)

http://en.wikipedia.org/wiki/Namespace_(programming)

Turing Machine

Have in mind how little you need to have a computing machine (and think of what does it mean to "compute," by the way). Have in mind that the Turing Machine is not practical as a real computer, but is of fundamental theoretical importance.

http://en.wikipedia.org/wiki/Turing_machine

http://en.wikipedia.org/wiki/Alan_Turing

(John) von Neumann

http://en.wikipedia.org/wiki/John_von_Neumann

http://en.wikipedia.org/wiki/Von_Neumann_architecture

Como continuar um upload / download usando scp e rsync

2011-12-06T23:41:00.001-02:00

Para minha referência futura e talvez ajudar mais alguém...

rsync -P --rsh=ssh nome-arquivo.tar.gz usuario@host:~/caminho/destinho/

Com este comando é possível continuar um upload ou download iniciado por scp, mas que por alguma razão foi interrompido.

O -P é equivalente a --partial (continuar transferências parciais) e --progress (exibe uma barra de progresso) e --rsh=ssh faz com que o rsync use o ssh (assim como o scp) para fazer a transferência de forma segura.

Eu sou um dos autores do Perl 5

2011-11-20T23:19:00.001-02:00

Depois de mais de 1 mês de espera pra ter meu patch no parser do Perl aceito, hoje eu entrei pra lista de autores! Fantástico!

Encontrei um bug com mais de 5 anos, que passou despercebido aos olhos de muitos programadores do core do Perl 5.
Acho que é uma virtude minha detectar erros em texto... eu poderia virar revisor de livro ou equivalente. Leio com atenção, presto atenção nos detalhes, detecto padrões e anomalias.

Quer contribuir você também para o Perl? Comece por aqui.

Perl no Dojo Rio

2011-11-04T20:45:00.003-02:00

Wordle usando como base o código-fonte dos nossos dojos em Perl:

Responsible Design

2011-10-25T17:39:00.001-02:00

Meus amigos deveriam ver isto:InfoQ: Responsive Design (Kent Beck)

(infelizmente, sem tempo para escrever a respeito...)

O que é Coding Dojo?

2011-10-04T23:00:00.000-03:00

O que é Coding Dojo?

Um Coding Dojo é um encontro no qual pessoas se juntam para trabalhar em um desafio de programação. O objetivo é a prática deliberada de programação como forma de melhorar habilidades pessoais e se divertir em grupo.

Premissa: o aprendizado é um processo contínuo e requer prática. Prática coletiva traz novos desafios e potencializa o aprendizado e a disseminação de conhecimento.

Características: o ambiente é colaborativo e divertido, adequado para testar novas ideias. Participantes com qualquer nível de conhecimento são bem-vindos.

Requisitos técnicos/físicos: sala com um computador e um projetor. Quadro branco ou flip-chart, post-its e comida são itens que ajudam ao longo do encontro.

O Coding Dojo é um espaço semanal na agenda para treinar boas práticas de programação, como Test-Driven Development (TDD), programação em par, código coletivo, passos de bebê, design incremental, entre outras práticas ligadas ao desenvolvimento Ágil de software.

A maioria das boas práticas do Dojo são derivadas da metodologia de desenvolvimento Ágil Extreme Programming. Mas o Dojo vai muito além quando consideramos os aspectos sociais, que envolvem convívio social, apresentação de ideias em voz alta para um público e trabalho em grupo para atingir um objetivo comum.

E o Coding Dojo Rio?

O Coding Dojo Rio iniciou seus encontros semanais em dezembro de 2008. Tudo começou em setembro daquele ano no encontro da comunidade brasileira de Python, o PyCon Brasil 2008, realizado no Rio de Janeiro.

Achei o conceito o Coding Dojo uma excelente maneira de promover boas práticas de programação na comunidade carioca. Juntei algumas pessoas, conseguimos um espaço físico e começamos.

Desde então mais de 500 desenvolvedores se cadastraram na lista de discussão associada ao evento, e, destes, boa parte participa de sessões que ocorrem em diversos locais no estado do Rio de Janeiro. Temos também pessoas de outros estados que participam do grupo, inclusive se engajando em algumas discussões. Começamos com um pequeno grupo, e hoje já atingimos boa parte do estado e até mesmo o país e o mundo.

Mas nada disso aconteceria se não fosse a sinergia da comunidade, dos que estão lá toda semana batalhando para se tornar um melhor desenvolvedor, colaborar com o conhecimento alheio, discutir e trocar informações.

Muitos eventos de tecnologia incluem um dojo em sua programação, assim como muitas pessoas, incluindo os cariocas do Dojo Rio, dão palestras introdutórias sobre o tema.

O Coding Dojo pode, a médio e longo prazo, ajudar a melhorar a qualidade do código que você escreve, consequentemente aumentando a qualidade do software produzido pelos indivíduos e empresas.

Alguns dos desafios a serem encarados:

programar na frente de todos
pensar num problema e exprimir seu entendimento através de casos de teste
descrever publicamente suas intenções ao escrever linhas de código
usar um framework de testes unitários
trabalhar em pares/equipe
resolver problemas de forma incremental

Online

Site/blog: http://dojorio.org
Grupo de discussões: http://groups.google.com/group/dojo-rio
Facebook: https://www.facebook.com/dojorio
Repositório de códigos: http://code.google.com/p/dojo-rio/

Repercussão

Listo aqui algumas coisas que me chamaram a atenção ao longo dos anos. Não conhecemos todos os efeitos decorrentes do Coding Dojo Rio.

1. Coding Dojo Piauí

Um dia estava navegando no Slideshare, quando no fim de uma apresentação cliquei nesta aqui:
http://www.slideshare.net/regispires/coding-dojo-1923746
É uma palestra introdutória sobre Coding Dojo feita no Piauí! Os slides citam meu nome, e eu nem sabia da existência deles. Muito legal ver a multiplicação dos coding dojos Brasil a fora. Não foi só em Piauí, já ouvimos histórias de outras cidades que se inspiraram na comunidade carioca para criar seus coding dojos.

2. Bangalore, Índia

O Henrique Bastos, grande impulsionador da comunidade de tecnologia do Rio de Janeiro, palestrante em vários cantos do Brasil e em eventos internacionais, sempre divulga o Coding Dojo Rio como uma das partes fortes da comunidade carioca.
Em 30 de setembro de 2010 ele falou na lista de emails do Dojo Rio:

“Hj acordei com a notícia simplesmente EMOCIONANTE: Estão começando um Dojo em Bangalore na India *diretamente* inspirado nas dinâmicas do Dojorio e no Small Acts Manifesto.”

Henrique Bastos

http://svaksha.com/post/2010/weekly-python-dojo-meetups-in-bangalore

3. Vídeo com famosos

Mais uma vez o Henrique Bastos por trás de um vídeo que reúne muita gente boa para falar do Coding Dojo.

Dojorio: muito além do código!
http://vimeo.com/20473572
Neste vídeo, grandes profissionais da área de tecnologia falam da importância do Coding Dojo em suas vidas e carreiras.
Você está esperando o que? Participe hoje!

4. Dojo com calouros na UFF

O pessoal de Niterói levou o dojo para os calouros, substituindo antigas formas de “trote” por um divertido contato inicial com o mundo da programação.

O Vinicius Teles, autor do primeiro livro em português sobre Extreme Programming, fez um apelo em seu blog que causou boa repercussão:
http://blog.improveit.com.br/articles/2010/05/28/apelo-parem-de-ensinar-comp-i-nas-faculdades

Ele conta um pouco da história do Coding Dojo em Niterói e discute a efetividade do Dojo como forma de transmissão de conhecimento.

Agradecimentos

Vale lembrar que o Coding Dojo Rio é uma comunidade e evento de muitas mãos. Para não cometer injustiças, prefiro não citar nomes e inevitavelmente esquecer de outros. Gostaria de agradecer a todos aqueles que contribuem, seja dedicando seu tempo, palestrando e divulgando o dojo, ou ainda o mais importante, participando semanalmente dos encontros, trocando experiências, praticando, ensinando. Vocês estão de parabéns!

Sobre o autor

Rodolfo Carvalho é graduando da Universidade Federal do Rio de Janeiro em Engenharia de Computação e Informação, iniciou e participa desde 2008 do Coding Dojo Rio, gosta de estudar e conversar sobre metodologias, algoritmos, paradigmas e linguagens de programação e línguas faladas. Estudou por um ano no Instituto Superior Técnico em Lisboa, Portugal. Atualmente desenvolve seu projeto de graduação com base no Dosvox, um software livre que permite que cegos utilizem soberanamente o computador.
Seus interesses incluem polonês, programação funcional (Lisp, Scheme, Racket), fotografia, inteligência artificial, aprendizado de máquina, neurociência, educação.

Somos nossos conectomas

2011-09-21T01:54:00.000-03:00

Resumo dos vídeos “Sebastian Seung, I am my connectome, TED Talk, 2010” e “Jeff Hawkins, MIT150 Symposium Brains, Minds and Machines, 2011”

Introdução

Um conectoma é um mapa detalhado das conexões neurais do cérebro. O termo é inspirado no termo “genoma”, e refere-se aos esforços científicos para capturar, mapear e entender a organização das relações neurais no cérebro.

O conectoma humano tem um milhão de vezes mais conexões que a quantidade de letras do seu genoma. Não se sabe ao certo quais informações podemos obter desses dados, mas especula-se que nossas memórias possam estar codificadas nas conexões de nossos neurônios. Outros aspectos como personalidade, intelecto, podem estar lá codificados.

Sebastian Seung fez uma apresentação de divulgação científica, explicando alguns conceitos, citando estudos passados e atuais, e tentando mostrar a importância e relevância do tema. No fim ele chega discutir a viabilidade de se estender a vida através da criogenia.

Seung reforça a ideia de auto-percepção do ser. Ele sustenta que “Eu sou mais que meus genes”, e que “Eu sou meu conectoma”. As interações neurais viriam a explicar o que os nossos genes não são capazes de explicar.

Um fato que achei particularmente interessante é que, similar ao estudo de genomas, existem muitos desafios científicos envolvidos. Encontrar conectomas implica resolver outros problemas, incluindo obtenção e processamento de imagens, como colorir um grafo gigante, escaneamento em três dimensões, habilidade de fazer zoom in/out em objetos 3d de alta resolução, processamento de enorme quantidade de dados, etc.

Pensando em redes complexas, considerar os genes isoladamente seria como olhar e entender cada nó da rede em sua individualidade. Mas já vimos que as redes codificam nas ligações entre os nós informações e características que não podem ser explicadas tomando como base as características individuais dos nós.

Por que estudar conectomas

Segundo evidências, a atividade neural codifica nossos pensamentos, sentimentos, percepções, experiências mentais. Existem evidências também de que a atividade neural faz com que as conexões entre neurônios mude. Estes dois fatos juntos levam a concluir que nossas experiências podem mudar o nosso conectoma. Por isso cada conectoma é único, mesmo o de gêmeos geneticamente idênticos.

Seung usa como metáfora um córrego para explicar a relação entre atividade neural e conectividade. O leito é como a rede de neurônios, que determina por onde a água, a atividade neural, passa. Mais que isso, assim como num córrego a água é capaz de mudar o curso e alterar o leito, a atividade neural pode remodelar a conexão cerebral, o conectoma.

Aplicação do estudo do cérebro

Jeff Hawkins tem uma abordagem mais pragmática em relação ao tema. Ele tem em mãos um grande motivador, que é aliar sucesso comercial à pesquisa.

Antes de prosseguir é bom contextualizar quem ele é. Hawkins formou-se engenheiro elétrico em 1979, e depois de uma década dedicada a outros trabalhos e estudos, fundou a empresa Palm, onde criou o Palm Pilot, e a Handspring, onde criou o portátil Treo. Seu interesse em computação móvel deu lugar a interesses antigos na área neurobiológica.

Em 2005, Hawkins escreveu o livro “On Intelligence” e fundou a Numenta, uma empresa voltada à criação de teoria do funcionamento do cérebro, e ao desenvolvimento de algoritmos computacionais que implementem os resultados teóricos.

Sua apresentação no simpósio é curta, mas serve como base para motivar sua área de pesquisa e produtos relacionados e contar sobre os resultados que já obteve. Em dez minutos ele levanta perguntas e dá respostas.

Já é hora de tentar novamente entender o cérebro e o funcionamento da mente? Sim.

Por que? Porque é a pesquisa mais importante para a humanidade, com implicações na sobrevivência de nossa espécie.

Por que agora? Porque já temos poder computacional, temos muitos dados neurocientíficos para serem tratados, não faz sentido ficar esperando. Nós não entendemos as coisas até construí-las.

Como acelerar o progresso? Neurocientistas devem estudar mais a teoria, devem basear sua pesquisa em frameworks teóricos para neurociência. Por outro lado, especialistas em aprendizado de máquina devem estudar mais biologia. Além disso, sucesso comercial.

Notamos um relacionamento com a fala de Seung quando Hawkins diz que “Somos espécies definidas pelo nosso cérebro, tudo que fizemos até hoje é produto dos nossos cérebros”.

A partir de novas descobertas da neurociência, ele mostra como o modelo que ele criou, o Numenta neuron model, é essencialmente mais detalhado que o modelo computacional simples de neurônio existente há algumas décadas. Seu modelo é particularmente apropriado para detectar padrões de representações esparsas distribuídas.

Um de seus objetivos com o sucesso comercial é em acelerar o progresso da pesquisa, pois, quando um produto chama a atenção, mais pessoas passam a estudar o tema.

Conclusão

Tanto Seung quanto Hawkins estão interessados no estudo das conexões neurais, e entendem que isto é um tema de grande relevância para o futuro da humanidade. Entretanto, os meios que eles empregam são diferentes.

O viés comercial de Hawkins potencialmente impõe um ritmo mais a acelerado às suas pesquisas, especialmente no quesito time to market. Ganhamos com isso em pelo menos dois aspectos.

O primeiro em relação aos clientes que contratam produtos (com tecnologia) da Numental, que podem experimentar tecnologia de ponta para seus usos. Por exemplo, existe a Vitamin D, uma empresa que utiliza da tecnologia Numental para detectar pessoas e objetos em movimento em vídeo, oferecendo um sistema profissional de monitoramento de ambientes.

O segundo diz respeito aos novos resultados teóricos que são publicados, e que motivam mais estudos.

A pesquisa de Seung, por sua vez, pode ficar por décadas nos laboratórios até que de fato venha a impactar o nosso cotidiano. Não que isto diminua a sua importância.

Enquanto Seung busca entender os conectomas para que possamos entender melhor o ser humano, Hawkins está mais interessado em como aplicar o conhecimento dos mecanismos cerebrais para a construção de máquinas inteligentes.

Perl, Ruby, Python & Racket: time matters

2011-09-15T23:33:00.000-03:00

Estava aqui pensando em duas coisas:

Qual o comportamento de diversas linguagens de programação quando fazemos um "import" ou "require", e o que acontece se um mesmo arquivo for requirido várias vezes na árvore de dependências.
Qual o tempo que leva para executar um script mínimo.

A motivação vem da diferença que dá usar #lang racket x #lang racket/base em Racket. Quando usamos a linguagem completa, temos todas as baterias em nossas mãos, e como penalização carregamos um monte de código pra memória sem que este seja efetivamente necessário. A segunda opção é mais leve, tem apenas definido elementos mais centrais da linguagem, ideal para usar quando estamos criando nossas bibliotecas.

Há uns anos atrás já havia feito experimentos similares (provavelmente não documentados) com Python. Agora fiz pequenos scripts em Python, Racket, Ruby e Perl para comparar. Atenção não leve em consideração os números deste post como "benchmarks" ou classificadores/qualificadores de uma ou outra linguagem.

O procedimento experimental

Para reproduzir este experimento, crie 4 diretórios:

mkdir t{python,ruby,racket,perl}

(Não entendeu a linha acima? Veja meu post sobre o uso de chaves no Bash)

Em cada um, crie 3 arquivos, "a", "b" e "c", com a extensão da respectiva linguagem.

O resultado final fica assim:

./tperl
├── a.pl
├── b.pl
└── c.pl
./tracket
├── a.rkt
├── b.rkt
└── c.rkt
./truby
├── a.rb
├── b.rb
└── c.rb
./tpython
├── a.py
├── b.py
└── c.py

Cada arquivo contém:

tpython/a.py
::::::::::::::
print "a"

tpython/b.py
::::::::::::::
import a
print "b"

tpython/c.py
::::::::::::::
import a, b
print "c"

Para as outras linguagens é similar, veja:

c.pl (Perl)

require "a.pl";
require "b.pl";
print "c\n";

c.rkt (Racket)

#lang racket/base
(require "a.rkt" "b.rkt")
(displayln "c")

c.rb (Ruby)

require 'a.rb'
require 'b.rb'
puts 'c'

Resultado 1

Todas as 4 linguagens parecem ser consistentes em:

executar todo o código do corpo de um arquivo importado (incluindo efeitos-colaterais)
não re-executar código já importado anteriormente (mesmo que por dependência indireta)

Ou seja, o resultado visual da execução de todos os exemplos é:

a
b
c

Resultado 2

Entretanto, o tempo de execução é bem diferente. Usando o time, os melhores resultados encontrados após muitas execuções num Core2Duo 2.2GHz com Ubuntu 10.10 64bits:

time perl c.pl

real 0m0.007s

user 0m0.000s

sys 0m0.000s

time ruby c.rb

real 0m0.010s

user 0m0.000s

sys 0m0.000s

time python c.py

real 0m0.015s

user 0m0.010s

sys 0m0.000s

time racket c.rkt

real 0m0.084s

user 0m0.060s

sys 0m0.020s

Se compilarmos o código Racket usando o "raco make", temos:

raco make c.rkt

time racket c.rkt

real 0m0.053s
user 0m0.030s
sys 0m0.020s

Conclusão

Racket e Python permitem fazer importação de vários módulos num único comando, enquanto que Ruby e Perl não. (Sim, existe o gem require_all pro Ruby, e certamente existe algo similar pro Perl no milagroso CPAN -- mas pelo que sei não existe solução "built-in" na linguagem)

Meus amigos Perl Monges devem ficar felizes porque Perl despontou como o mais rápido, né Breno, Diogo, Samir, Ronald, e cia?
Meus amigos adeptos do Ruby vão ficar felizes e dizer que Ruby é mais rápido do que Python :P
Meus amigos Pythonistas, pé no chão, vão concordar que Python é rápido o suficiente e é mais divertido que Ruby (e que a conclusão acima, dos rubistas, não pode ser considerada já que meus resultados não provam nada...)
Meus amigos que ainda estão conhecendo Racket podem fazer caretas, normal... não tô nem aí :)
Não me importo em "pagar o preço" para programar numa linguagem mais poderosa e bonita.

Obs: como as diferentes linguagens usam diferentes terminologias, perdoem o uso nem sempre preciso de "módulo", "arquivo", "importar", "requerer", etc. Espero não causar ambiguidade para o leitor.

Grep e Less com cores!

2011-09-15T00:29:00.000-03:00

Esta é uma nota mental.

egrep -r --include="*.rkt" "[a-z-]+#" . --color=always | less -R

Para usar o Grep com cores, geralmente temos um alias grep='grep --color=auto' no nosso ~/.bashrc.

Mas acontece que muitas das vezes o resultado é grande é fazemos um pipe pro less. Como triste consequência perdemos as cores...
Para forçar o grep (egrep, fgrep, ...) a exibir cores use o --color=always, assim ele manda o output pro less com cores.
A opção -R do less faz com que ele interprete os caracteres de escape de cores do terminal.

grep "alguma coisa" /caminho/da/busca --color=always | less -R

Nota: pode ser usado também com o more:

grep "alguma coisa" /caminho/da/busca --color=always | more

[Update]
Como meu amigo Breno Oliveira sugeriu, uma alternativa interessante ao grep é o ack.
http://betterthangrep.com/

Usando o ack o comando fica:

ack "regexp perl" [caminho] --color | less -R

Lista de números com o Bash

2011-09-05T19:10:00.001-03:00

Quer executar um comando várias vezes no Bash?

Use o for! E como gerar números sequenciais?

Voltamos ao brace expansion que citei noutro post. Você pode usar chaves para gerar strings arbitrárias, e também sequência de números.

Veja:
rodolfo@lisa:/tmp/bash-tricks$ echo {1..10}
1 2 3 4 5 6 7 8 9 10
rodolfo@lisa:/tmp/bash-tricks$ echo {5..0}
5 4 3 2 1 0
rodolfo@lisa:/tmp/bash-tricks$ echo {7..21..2}
7 9 11 13 15 17 19 21
rodolfo@lisa:/tmp/bash-tricks$ echo {30..-40..-5}
30 25 20 15 10 5 0 -5 -10 -15 -20 -25 -30 -35 -40

A sintaxe é {inicial..final..incremento}, e o incremento é opcional. Se inicial < final, o incremento é 1 por padrão, caso contrário é -1.

Com o for:

rodolfo@lisa:/tmp/bash-tricks$ for x in {1..3}; do echo "Hello $x"; done
Hello 1
Hello 2
Hello 3

Entrevista com r0ml na OSCON 2011

2011-09-01T00:44:00.000-03:00

O David Mertz gravou uma conversa com o Robert Lefkowitz, também conhecido como r0ml, e está no YouTube. Eles falam sobre os pensamentos de Lefkowitz sobre Computer Programming Literacy.

Pena que os vídeos estão muito editados/cortados, em algumas partes a conversa se torna pouco natural. Mas de qualquer forma é um papo bem bacana.

E os meus amigos Caike Souza e Henrique Bastos tiraram uma foto com o Robert na OSCON em minha homenagem! Muito obrigado!

Dark Networks

2011-08-31T22:25:00.000-03:00

Resumo do artigo “TheTopology of Dark Networks”

Jennifer Xu, Hsinchun Chen, The topology of Dark Networks. Communications of the ACM, Vol. 51, 2008.

Introdução

DarksNetworkssão as redes de organizações terroristas, tráfico de drogas,tráfico de armas, gangues, etc.

Umarede complexa de grande porte pode ser classificada em três tipos:aleatória, mundo pequeno, e livre de escala. A categorização éfeita com base na topologia da rede, e esta é estudada através deestatísticas como comprimento médio de caminhos, coeficiente declusterização médio, e distribuição de graus.

Oartigo faz referência aos trabalhos de Réka Albert e Albert-LászlóBarabási quando afirma que a maioria dos sistemas complexos não sãoaleatórios, e apresentam propriedades de redes de mundo pequeno elivres de escala. Em seguida, quatro “redes do mal” sãoestudadas a fim de discutir que propriedades elas apresentam,tentando justificar cada uma delas. São elas: GSJ (rede deterroristas, alguns da Al Qaeda), Meth World (traficantes demetanfetaminas), Gang Network (criminosos de gangues de Tucson, EUA),Dark Web (rede de sites de grupos terroristas).

Análise das redes

Infelizmenteos dados disponíveis para o estudo possuíam uma série delimitações, boa parte delas devido à dificuldade de se obter deforma completa, consistente e correta informação sobre nós eligações. Visto este problema, os autores fizeram simulaçõesalterando a rede para tirar conclusões sobre os efeitos que os dadosruins iniciais teriam nos resultados encontrados.

Todasas redes estudadas apresentam diversos componentes conexos, masapenas um único componente gigante. As análises topológicas feitasutilizaram os componentes gigantes das quatro redes.

Duasdas redes, GSJ e Dark Web, têm nós tão populares (grau alto) quepossuem ligações com mais de 10% da rede. Existe um conceito de“ordenamento” (assortativity) tal que nós tendem a terconexões com outros de popularidade similar. A tendência deconexões entre nós de popularidade diferente equivale a umcoeficiente de ordenamento negativo, ou desordenamento(disassortativity).

Asredes GSJ e Gang Network apresentaram coeficiente de ordenamentopositivo, o que quer dizer que membros populares tendem a se conectarcom outros igualmente populares. Meth World e Dark Web apresentamdesordenamento, explicado pelo fato de, segundo estudos de terceiros,organizações de tráfico de drogas serem comandadas por poucosindivíduos que se conectam a muitos revendedores de drogas, e porquesites populares geralmente são linkados por muitos sites poucopopulares.

Asredes apresentam propriedades de mundo pequeno, ou seja, criminosospodem se comunicar com qualquer outro membro da rede através depoucos mediadores. Caminhos curtos e links esparsos ajudam a reduziro risco de detecção e aumentam a eficiência da comunicação.

Quais os mecanismos explicam as propriedadesencontradas

Oartigo estuda também a possibilidade de se regerar as quatro redesutilizado-se de mecanismos conhecidos, para tentar entender quaisdestes tem papel importante na produção das propriedades observadasnas Dark Networks.

Assimulações realizadas foram baseadas em três mecanismosevolucionários: crescimento, ligação preferencial e novos linksentre nós já existentes. Os resultados mostraram que a distribuiçãode lei de potência e seu comportamento foram regeradossatisfatoriamente a partir desses mecanismos, entretanto, ocoeficiente de clusterização das redes simuladas ficou sempre muitoabaixo dos encontrados nas redes prospectadas.

Acredita-seque outros mecanismos tenham contribuição substancial para os altoscoeficientes de clusterização observados, tais como recrutamento.

Ataques

Xue Chen discutiram o efeito de ataques a hubs, nós com muitoslinks, e bridges, nós pelos quais passam muitos caminhos maiscurtos, usando duas estratégias distintas: remoção simultânea eremoção progressiva com atualização de estatísticas a cadaremoção.

Aconclusão foi de que ataques progressivos são mais devastadores queataques simultâneos, e que os primeiros são similares a “falhassucessivas” na Internet, em que uma falha inicial acarreta outras por causa do redirecionamento de grande volume de tráfego.

Algumasredes terroristas são mais sensíveis a ataques contra bridgesque hubs, e outras são igualmente sensíveis a ataques contrahubs ou bridges.

Questionamentos

Oque podemos fazer efetivamente se conhecermos bem a topologia de umarede? Podemos alterar o comportamento de nós? Criar ou removerlinks? Prever o surgimento de links?

Como terroristas podem se valer de conhecimento de técnicas de detecção de redes para se manterem ocultos?

Leia também:
Valdis Krebs, Uncloaking Terrorist Networks. First Monday, Volume 7 Number 4 - 1 April 2002.

Auto-completar Bash usando chaves { }

2011-08-31T00:04:00.001-03:00

Bem, se você usa o terminal mesmo que pouco deve saber que a tecla TAB é usada para auto-completar nomes de arquivos e alguns comandos.

Mas o que você não deve saber é do uso das chaves como forma de construir strings arbitrárias. E mais, se você é como o meu amigo Flávio Amieiro e já sabia disso, aposto que você não sabia que pode usar auto-completar e as chaves {} {} {} {}!!!!

Digamos que estou num diretório assim:

rodolfo@lisa:/tmp/bash-tricks$ ls
foo_ball.egg foobaz foo_spam2.egg foo_spam.egg hello.c
foo-bar foo_spam1.egg foo_spam3.egg foo.txt

Podemos auto-completar nomes com TAB. Por exemplo, digitar "h" seguido de TAB vai resultar em "hello.c".

Digamos que quero fazer um diff entre foo_spam2.egg e foo_spam3.egg. Uma forma de fazer isso seria digitar o comando completo:

diff foo_spam2.egg foo_spam3.egg

Depois de ler isto aqui, espero que sua forma de fazer seja assim:

diff foo_spam{2,3}.egg

O Bash expande automaticamente tudo que estiver dentro das chaves. Itens são separados por vírgula, sem espaços. Se quiser colocar um espaço ou vírgula na string gerada, escape com uma contra-barra \.

Exemplo:

rodolfo@lisa:/tmp/bash-tricks$ echo O Bash é {legal\,,muito\ poderoso,e\ divertido.}
O Bash é legal, muito poderoso e divertido.

Agora a cereja no topo do bolo! Como gerar uma string como a do exemplo acima a partir dos arquivos num diretório?

Digamos que queremos remover todos os arquivos que começam com "foo".
Começamos digitando:

rodolfo@lisa:/tmp/bash-tricks$ rm f

Agora tecle alt + { e você verá o Bash auto-completar usando a notação de {}:

rodolfo@lisa:/tmp/bash-tricks$ rm foo{-bar,.txt,_{ball.egg,spam{.egg,1.egg,2.egg,3.egg}},baz}

Fantástico não? Note que você pode apontar para outros diretórios, e fazer combinações arbitrariamente complexas.

Não sei em que parte da documentação isto está, descobri por acaso!

Quer aprender mais? man bash

Decaimento exponencial e lei de potência

2011-08-30T23:28:00.000-03:00

Numa aula de Redes Complexas estávamos observando numericamente o que quer dizer que uma função (no caso, uma função densidade de probabilidade) decai exponencialmente ou segundo uma lei de potência.

No caso exponencial temos:	E lei de potência:
P(x) ~ e^-x	P(x) ~ x^-γ

Fiz uns gráficos de algumas funções que ajudam a entender um pouco do que está acontecendo. Compare as funções azul e vermelha com a violeta. As duas primeiras são leis de potência com expoente 2,5 e 1,4, respectivamente, que poderiam representar a distribuição de graus de nós em redes livres de escala. A última é uma curva gaussiana, que poderia representar a distribuição de graus de nós em uma rede aleatória.

Num artigo de Barabási e Bonabeau, Scale-free networks, eles dizem que o γ das redes livres de escala está geralmente entre 2 e 3. Já Xu e Chen em The topology of Dark Networks encontram redes com γ entre 1 e 2.

Se olharmos para as funções 1, 2, 3 e 4, ~~notamos que a lei de potência com γ = 5.9 decai mais rápido que a exponencial 4, para as constantes envolvidas~~. Isto traz à tona o sentimento de que o efeito da cauda longa, ou cauda pesada, fica melhor caracterizado quando γ é pequeno.

Permalink para o gráfico

Update [31/08/2011]
Cometi um erro absurdo acima. A exponencial decai mais rápido. É claro! Se olharmos com um zoom de 10000x no eixo vertical, veremos que as curvas se cruzam e a exponencial se aproxima de zero muito mais rápido que a lei de potência.

Permalink para o gráfico

Apesar do deslize, o sentimento é o mesmo. Ter γ grande implica numa menor probabilidade de coisas "fora do normal" acontecerem, e o fato é que nas redes livres de escala as coisas acontecem.

Rede livre de escala

2011-08-16T17:59:00.006-03:00

O desafio

Imagine-se como o imperador de um planeta de outra galáxia.

Conseguiu visualizar? Agora, sendo um imperador de um lugar tecnologicamente avançado, você tem uma tarefa pela frente: implantar uma rede de rotas de voo de naves espaciais no espaço aéreo de seu planeta.

Aqui está uma representação das cidades do seu planeta que o Departamento de Defesa Aérea (DDA) disponibilizou:

Para simplificar, vamos assumir que todas as rotas serão bidirecionais, ou seja, se existe uma rota de A para B, então naves podem trafegar tanto de A para B quando de B para A.

Parece difícil? Não sabe por onde começar? Não se preocupe, você não está sozinho. Para te ajudar, apresento-lhe seu conselheiro:

Seu conselheiro é muito sábio, leia o que ele tem a dizer sobre como realizar a implantação das rotas:

“Caro imperador,

Precisamos interligar nossas 42 cidades da melhor forma possível. Uma cidade não pode ter muitas rotas, ou ela será sobrecarregada causando grande congestionamento. Para otimizar o tráfego aéreo, podemos colocar em torno de 5 rotas em cada cidade saindo para outras cidades próximas, assim será fácil ir de um ponto a outro e evitamos caos aéreo.”

Primeira solução

Se você seguir as orientações de seu conselheiro, você pode construir uma rede parecida com esta:

O que você construiu foi uma rede aleatória. Numa rede aleatória, a probabilidade de um nó (cidade) estar ligado a outros k nós (rotas aéreas) obedece a uma distribuição de Poisson.

Isto quer dizer que em geral as cidades terão de 4 a 6 conexões, e serão raros os casos que se afastam muito da média.

Novo modelo

Acontece que a solução proposta foge da realidade. Não pelo fato de estarmos tratando de extraterrestres, mas sim porque o mais comum de acontecer é que 1) não conhecemos a priori todas as cidades e 2) elas tem diferentes graus de importância.

Seu planeta começa com poucas cidades, e, ao longo do tempo, novas cidades surgem e com elas a necessidade de criar novas rotas aéreas. Estas novas rotas conectarão as novas cidades preferencialmente àquelas mais importantes do seu planeta.

Neste novo cenário, vamos fazer uma breve simulação do surgimento de novas cidades e rotas. Para economizar recursos, seu conselheiro diz-lhe para construir apenas 1 rota para cada nova cidade, e que esta rota conecte a nova cidade a uma cidade importante.

Tempo 0: mapa das 6 cidades inicialmente existentes no planeta, segundo o DDA. Os círculos na cor cinza representam cidades ainda inexistentes.

Tempo 1: primeira implantação de rede de rotas aéreas conectando todas as cidades entre si.

Tempo 2: surgem novas cidades, e seguindo a sugestão do conselheiro são criadas novas rotas, uma para cada nova cidade.

Tempo 3: o surgimento de mais cidades marca o aparecimento de hubs, cidades com um grande número de rotas.

Tempo 4: novas cidades conectam-se preferencialmente a cidades-hub.

Tempo 5: as cidades com grande número de rotas tendem a agregar cada vez mais novas rotas.

Tempo 6: todas as cidades estão conectadas, sendo possível ir de uma cidade para qualquer outra passando por poucas rotas.

Chegamos a uma rede diferente da rede aleatória. Note que esta nova rede tem 47 rotas, contra 104 da primeira. Apesar de possuir um número muito menor de rotas, as cidades estão altamente interligadas.

Para ir de qualquer cidade para qualquer outra, precisamos usar no máximo 3 rotas. Na rede aleatória era preciso até 7 rotas para ir de uma cidade a outra.

Parece que temos uma estrutura interessante em mãos. Temos uma rede livre de escala. Nestas redes a probabilidade de um nó (cidade) ter k ligações (rotas) decai quando k aumenta, segundo uma Lei de Potência.

P(k) ~ k^-γ

Fatos interessantes

Redes não servem apenas para modelar rotas aéreas alienígenas. Elas estão presentes no nosso cérebro, células, sociedade, cadeia alimentar, ecossistemas, Internet, transmissão de energia, linguagens, etc.
Apesar da importância das redes, pouco entendemos hoje de suas estruturas e propriedades.

Redes livres de escala são dominadas por um número relativamente pequeno de nós (os hubs) que estão conectados a muitos outros. Estas redes são resistentes a falhas acidentais / aleatórias, porém extremamente vulneráveis a ataques coordenados.

Caso caiam tempestades aleatórias no planeta, é pouco provável que uma das cidades atingidas seja um hub. Sendo assim, o estrago causado, o número de rotas interrompidas, é pequeno.

Por outro lado, se inimigos de outro planeta tiverem acesso aos servidores do DDA e descobrirem quais são as cidades-hub, bastaria um pequeno ataque que bloqueasse algumas destas cidades para criar um enorme prejuízo.

Slides

Este post é inspirado na leitura de um artigo de divulgação científica de Barabási e Bonabeau entitulado "Scale-free Networks", divulgado na revista Cientific American em maio de 2003.

Farei uma breve apresentação sobre o tema amanhã, em uma aula na UFRJ. Os slides sobre Redes Livres de Escala já estão disponíveis.

[Update 22/08/2011] A apresentação foi hoje. Fiz upload da apresentação atualizada. Confira aqui os slides sobre Redes Livres de Escala atualizados:

Redes livres de escala

View more presentations from rhcarvalho

Imagens

Alienígenas: halloweencostumes.net
Célula: unm.edu/~mpachman
Inception: sensesofcinema.com
Nave espacial: adultswimuk.wordpress.com
Poisson e Lei de Potência: wikipedia.org
Vacina: flickr.com/mccord
Redes: autoria própria

Racket com readline

2011-08-01T18:37:00.001-03:00

Para quem estava acostumado ao IPython, usar o interpretador do Racket no terminal pode ser um bocado decepcionante.

Isto porque por padrão o REPL é bem rudimentar, sem suporte a auto-completar, sem histórico, sem nada...

O que existe entretanto é um problema com licenças. O readline é distribuído em GPL, e o Racket em LGPL, e para não haver conflitos o suporte a readline vem desativado por padrão. Mas ele está lá.

A documentação em inglês dá os detalhes completos: Readline: Terminal Interaction.

Este módulo vai tornar sua experiência no REPL muito mais agradável, naqueles momentos em que você está no terminal e não quer abrir o DrRacket ou o Emacs.

Para usar basta iniciar o racket assim:

racket -il readline

E se você não quiser ter que fazer isto toda vez, basta instalar permanentemente o suporte ao readline chamando uma função :D

(install-readline!)

Pronto. Agora toda vez que executar racket você entratá num REPL com histórico (que lembra inclusive as sessões anteriores), auto-completar usando tab, seta pra cima e pra baixo pra navegar nos comandos, etc.

Para ficar melhor ainda, adicione uma linha no arquivo ~/.inputrc:

set blink-matching-paren on

Esta sugestão do Eli Barzilay faz com que seu terminal indique qual "(" está relacionado com qual ")" quando você digita, e funciona tanto dentro do racket quanto em qualquer outro canto, inclusive no IPython. Também funciona com [] e {}.

E não pára por aí... o REPL vai ficar melhor ainda com o XREPL que vem aí na próxima release.
Com ele será possível fazer coisas já corriqueiras no IPython, agora em Racket.

Happy hacking!

Estatísticas do Dojo Rio em 2011

2011-07-28T22:46:00.000-03:00

Resolvi fazer uns gráficos para mostrar as linguagens que usamos nos dojos, mais como curiosidade que outra coisa.

Para conseguir gerar os dados tive que renomear alguns diretórios de dojos antigos que estavam sem a descrição de problema e linguagem. Depois, atualizei meu script para gerar as estatísticas.

Os gráficos

Este ano:

Todos os dados disponíveis:

Portanto as linguagens mais utilizadas neste ano, assim como em todos os tempos, são Python, Ruby e Javascript.

Alguma sugestão de gráfico que você gostaria de ver?

Os dados brutos

Este ano:

-- python (7) --------------------
20110316: fizzbuzz
20110413: wordwrap
20110420: cheque por extenso
20110427: boliche
20110504: boliche
20110622: anagramas
20110720: contaletras

-- ruby (6) ----------------------
20110105: espiral
20110119: erdos
20110223: letras dos numeros
20110323: pedra papel tesoura
20110615: url
20110629: mijoes

-- javascript (5) ----------------
20110209: anagrama
20110216: telefone
20110302: intervalos
20110713: romanos
20110727: telefone

-- csharp (2) --------------------
20110112: telefone
20110608: wordwrap

-- racket (2) --------------------
20110518: raizes
20110601: caixa eletronico

-- boo (1) -----------------------
20110525: caixa eletronico

-- perl (1) ----------------------
20110511: fizzbuzz

-- smalltalk (1) -----------------
20110706: fizzbuzz

Todos os dados disponíveis, contabilizando os 113 dojos para os quais guardamos o código no repositório:

-- python (50) --------------------
20081203: amigo oculto
20081210: dama
20090114: areas sobrepostas
20090128: adicao reversa e saldo
20090211: bank ocr
20090218: minesweeper
20090304: bank ocr
20090311: romanos
20090401: totem
20090408: ocr
20090415: miner
20090422: miner
20090429: vai um
20090506: estacionamento
20090513: katapotter
20090520: diamond
20090610: agenda
20090617: wow
20090722: piratas
20090729: gerador de relatorios
20090812: game of life
20090923: expressao aritimetica
20091015: display de 7 seg
20091104: poker
20091118: mesa de jantar
20091202: vigenere cipher
20091209: musical score
20100106: sql
20100203: tennis
20100224: metadojo
20100324: jogo da velha
20100428: reversi
20100512: automato
20100623: roleta romana
20100804: ascii
20100825: datas
20100929: espiral
20101006: espiral
20101013: fizzbuzz
20101027: espiral
20101103: forca
20101117: forca
20101201: espiral
20110316: fizzbuzz
20110413: wordwrap
20110420: cheque por extenso
20110427: boliche
20110504: boliche
20110622: anagramas
20110720: contaletras

-- ruby (24) ----------------------
20090701: jogador
20090708: compilador
20090805: catraca
20090819: bowling
20090908: numeric maze
20090916: impedimeto
20091021: torre de hanoi
20091111: grid
20100113: gols
20100127: abastecimento dagua
20100303: detetive
20100414: HomeRange
20100526: saving time
20100609: cheque o xeque
20100616: jokenpo
20100630: validador
20100915: encaixotar
20101020: Espiral
20110105: espiral
20110119: erdos
20110223: letras dos numeros
20110323: pedra papel tesoura
20110615: url
20110629: mijoes

-- javascript (20) ----------------
20090527: atirei o pau no gato
20090603: poker
20090715: piratas
20090826: tenis
20091007: relacionamentos
20091124: saving time
20091223: mictorio
20100210: proxima vitima
20100505: romanos
20100519: pedra papel tesoura
20100602: caminho
20100707: reais por extenso
20100721: 3n+1
20100818: url rewrite
20101222: pedra papel tesoura
20110209: anagrama
20110216: telefone
20110302: intervalos
20110713: romanos
20110727: telefone

-- php (6) -----------------------
20090902: mao inglesa
20091230: kombat
20100714: espiral
20100728: palindromos
20100811: game of life
20100908: cheque o xeque

-- perl (4) ----------------------
20101124: inteiros para romanos
20101208: espiral
20101215: inteiros para romanos
20110511: fizzbuzz

-- csharp (2) --------------------
20110112: telefone
20110608: wordwrap

-- racket (2) --------------------
20110518: raizes
20110601: caixa eletronico

-- shell (2) ---------------------
20100901: fizzbuzz
20100922: url

-- boo (1) -----------------------
20110525: caixa eletronico

-- java (1) ----------------------
20090121: romanos

-- smalltalk (1) -----------------
20110706: fizzbuzz

Consistentemente aparecem as mesmas linguagens nas três primeiras posições: Python, Ruby e Javascript.

Escolhendo um Lisp: do Clojure ao Racket

2011-07-19T15:34:00.001-03:00

Graças a um email de um amigo, o Lucas Teixeira, finalmente escrevi algumas coisas que já vinha comentando com algumas pessoas, geralmente nos pós-dojos.

Era pra ser um email pro Lucas, mas acabei expressando coisas que poderiam ficar públicas.

Bem, ele começou dizendo no email:

Então... sempre quis aprender programação funcional. Já tentei Haskell, LISP, Scheme, mas nunca pegou de verdade.

Tô tentando aprender Clojure agora. Baixei o Clojure Box e uns tutoriais da Internet. Tô resolvendo uns problemas do Project Euler e o clojure-koans.

Tem alguma dica de material?

Que tipo de coisa você tá / tava fazendo com Clojure?

Cara, foi muito surpreendente seu email.

Vamos a um apanhado de impressões sobre algumas linguagens da família lisp, começando com Clojure, passando por Common Lisp, Scheme e chegando em Racket.

Clojure

Semana passada o Ronald Kaiser me chamou pra montar propostas pra mandarmos pra Clojure/conj.

Bem, pra falar de Clojure tenho que relembrar a época em que trabalhei na Intelie.

Lá na Intelie ajudei no desenvolvimento do Intelie Event Manager, "um sistema de monitoração em tempo real capaz de analisar milhares de eventos por segundo e identificar tendências e situações de risco para TI e o negócio". O IEM tinha na época parte do seu backend escrito em Clojure.

A experiência, no segundo semestre de 2010, foi muito divertida, e, falando especificamente do Clojure, de certa forma a questão do ambiente de desenvolvimento era uma coisa chata que não me dava muito gosto de começar coisas particulares usando a linguagem.

Tentei por um tempo montar um ambiente redondo com o Emacs, inclusive usando Clojure Box entre outras opções.

Lá na Intelie eu usava o IntelliJ IDEA com o plugin La Clojure, mas essa combinação consumia muitos recursos do sistema, e não funcionava tão bem quando Emacs com SLIME.

Mas, na boa, a curva do Emacs é bem inclinada, e mesmo gostando muito dele e sabendo usar o básico, eu queria algo mais simples, mais gedit-like, que eu pudesse levar pra todo lado, mostrar pra qualquer um, sem ter que carregar meu .emacs debaixo do braço e sem ter que assustar muito as pessoas, por exemplo no Dojo.

Particularmente gostei de usar a STM do Clojure, e sentia prazer em poder expressar de forma tão bonita certas coisas que implementamos. Também era conveniente ter a rica gama de estruturas de dados que a linguagem oferece, suportados por uma sintaxe simples e compatível com as s-expressions.
Como material, eu li o Practical Clojure, mas também tem o Clojure In Action, Programming Clojure e The Joy of Clojure.

Common Lisp

Depois da Intelie eu fiquei por um tempo namorando o Common Lisp, que foi o primeiro lisp com o qual tive contato. Li parcialmente o Land of Lisp, excelente livro, muito divertido e recomendado, entre outras fontes (On Lisp e Practical Common Lisp vem em mente). Mas de novo o Emacs de um lado, e a "velhice" da linguagem do outro lado, me fizeram continuar minha jornada, buscando novas opções.

O CL é legal por ser um padrão ANSI. Por esse mesma razão ele é uma "merda". Por que esse padrão é antigo e não evolui. Não tem nenhuma empresa ou indivíduo ou grupo por traz de novas revisões, atualizações, não tem nenhuma "implementação padrão".

Veja Python: a linguagem é mais que CPython, existe uma especificação, mas CPython é a referência, a implementação viva, que evolui, 2.x, 3.x, etc. E lá vão PyPy, IronPython, ActivePython, etc...

O CL tem várias implementações, algumas mantidas, outras abandonadas. Uma vez eu queria fazer um script que consumisse parâmetros da linha de comando. Pra minha surpresa, o tal padrão ANSI não fala nada a respeito, e ficava a cargo de cada implementação prover um jeito de fazer isso. E claro, cada uma escolheu um jeito mais esquisito e mais incompativel com as outras possível.

Scheme

Com Scheme eu também tive algum contato em Portugal, no IST. Pouco, mas suficiente para me deixar interessado. Vi código, mas não escrevi nada significativo.

Scheme também tem várias implementações e nenhuma "canônica". Mas tem um grande diferencial em relação ao CL, que a torna uma linguagem viva: um sistema de revisões. Antes era o R5RS, hoje é o R6RS e amanhã sairá o R7RS.

Ah, lembro bem quando o prof. António Leitão falou da pureza de conceitos, e do exemplo clássico do "define".
Como definir uma variável? Define. Como definir uma função? Define. Como definir qualquer coisa? Define. E ele comparou com Python, que tem um número "absurdo" de sintaxes para fazer "a mesma coisa", definir: =, def, class, etc.

Apesar de a linguagem vir de uma linhagem minimalista, acaba que é mais provavel ver coisas mudando pra melhor em Scheme do que em CL, e neste caso qualquer mudança é melhor do que ficar parado no tempo.

O R6RS por exemplo adicionou um monte de coisas no padrão da linguagem, e muitos puristas não gostaram da ideia.

Existem várias implementações aparentemente muito legais, como Chicken, Gambit, e outras.

Algumas compilam pra C, outras pra bytecode, outras só interpretam... tem de tudo.

E nessa de escolher um Scheme, o PLT Scheme era mais um implementação. Engraçado que já tinha me deparado com ela uma vez e simplesmente "ignorei" no momento e fui lá paquerar o Common Lisp.

Mas acabei voltando uma noite qualquer, e caindo no site do Racket e dando uma chance pra ele. Me encantei.

Racket

A equipe PLT tem o diferencial educacional. O Racket tem muitos diferenciais. Ele não é só um Scheme. Você pode programar em Scheme R5RS ou R6RS, mas a linguagem Racket é muito mais rica, é uma "linguagem para escrever linguagens", e o pacote vem com coisas muito interessantes.

Lembra do Python com baterias incluídas? Pois é, o Racket tem baterias incluídas, um conjuto de baterias diferente dos de Python. Algumas são tão legais, mais legais até que as que tem no Python...

Por exemplo, hoje pra mim a melhor ferramenta pra fazer apresentações de slides é o Slideshow do Racket.

Poder colocar imagens dentro dos arquivos, fantástico. Tudo programável...

Para aprender mais sobre Racket, existem livros, tutoriais, papers, lista de discussão, IRC, entre outros recursos.

Bem, listar com mais detalhe cada coisa que me faz gostar de Racket é para outros posts. Alguns eu já escrevi, veja:

Para todos os outros posts sobre Racket no meu blog:

http://blog.rodolfocarvalho.net/search/label/racket

Descrevendo objetos com Racket

2011-07-19T14:45:00.002-03:00

O Racket é muito esperto, e com o auxílio de um módulo disponível no PLaneT é possível fazer coisas bem divertidas, como fazer contas:

#lang racket
(require (planet williams/describe/describe))

(displayln
 (string-join
  (map (λ (t) ((if (exact-integer? t)
                   integer->string
                   (curry format "~a")) t))
       `(I will show you how Racket knows how to count.,"\n"
           Racket knows that 3 + 4 is ,(+ 3 4),"\n"
           Racket knows that 5 * 9 is ,(* 5 9),"\n"
           and that 5 / 4 is ,(/ 5 4),"\n"
           and 2 ^ 10 is ,(expt 2 10),"\n"
           and much more...))
  " "))

(define (! n)
    (if (= n 0)
        1
        (* n (! (sub1 n)))))
(describe (- (! 40) (! 41)))

Tão esperando que pra instalar o Racket e ver o output?
(Alias, que tal implementarmos um "describe" no dojo?)

Veja a documentação do describe pra ver o que mais ele pode fazer...

Brainfuck com Racket

2011-06-10T20:37:00.001-03:00

Esta é uma novidade fresquinha. O Danny Yoo está desenvolvendo uma versão de Brainfuck que roda na infraestrutura do Racket, para mostrar que é possível ter linguagens com sintaxe totalmente diferente de Lisp. Ele chamou a linguagem de Brainfudge, e o código está disponível no github.

Como podemos ver, o Racket é uma linguagem para escrever linguagens.

Para os curiosos de plantão, aqui vai um Hello World:

#lang planet dyoo/brainfudge

+++++ +++++             initialize counter (cell #0) to 10
[                       use loop to set the next four cells to 70/100/30/10
    > +++++ ++              add  7 to cell #1
    > +++++ +++++           add 10 to cell #2 
    > +++                   add  3 to cell #3
    > +                     add  1 to cell #4
    <<<< -                  decrement counter (cell #0)
]                   
> ++ .                  print 'H'
> + .                   print 'e'
+++++ ++ .              print 'l'
.                       print 'l'
+++ .                   print 'o'
> ++ .                  print ' '
<< +++++ +++++ +++++ .  print 'W'
> .                     print 'o'
+++ .                   print 'r'
----- - .               print 'l'
----- --- .             print 'd'
> + .                   print '!'
> .                     print '\n'

Como de costume, não é preciso instalar nada manualmente nem mesmo salvar o arquivo! Vejam:

Rodei também um exemplo da Wikipedia que transforma letras minúsculas em maiúsculas:

E funcionou muito bem, de novo sem salvar arquivo ou nenhum configuração ou etapa extra :D

E pra terminar, o mais engraçado! O 99 bottles of beer, versão de Michal Wojciech Tarnowski.

#lang planet dyoo/brainfudge

# 99 Bottles of Beer
# Brainfuck version
# by Michal Wojciech Tarnowski

                +>+++++++[>>>+++
                 +++++<<<<+++++
               +++>-]+++++++++>>>
                +>>++++++++++[>+
                 +++++++++<-]>[
                 >>+>+>+>+>+>+>
                 +>>+>+>>+>+>+>
                 +>>+>+>>+>+>+>
                 >+>+>+>+>>>>>+
                 >+>+>+>>+>+>+>
                 >+>+>+>+>>+>+>
                +>>+>+>+>+>>+>+>
                >+>+>+>+>+>+>>>>
                +>+>>+>+>+>+<<<<
                <<<<<<<<<<<<<<<<
               <<<<<<<<<<<<<<<<<<
               <<<<<<<<<<<<<<<<<<
               <<<<<<<<<<<<<<<<<<
               -]<++++[>++++++++<
               -]>[>+>>>>>>>>+>>>
               +>>>>>+>>>+>>>>+>>
              >>>+>+>>+>>>>>+>>>>+
              >>>>>+>>>>+>>>>>+>>>
              +>>>>>>>+>+>+>>>+>>>
              >>+<<<<<<<<<<<<<<<<<
              <<<<<<<<<<<<<<<<<<<<
             <<<<<<<<<<<<<<<<<<<<<<
            <<<<<<<<<<<<<<<<-]+++++[
           >>>++>+++>+++>++>>+++>>++>
          >>>>>+++>>++>++>>+++>+>>>+++
        +>->++>++>++>+++>++>>--->->+>>>+
       +>++>>>>++>++++>++>>->++>>>++>->++
     +>+++>>+>+++>>>+++>++>+++>++>>>++>>++>
    ++>>++>++>+++<<<<<<<<<<<<<<<<<<<<<<<<<<<
   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  <<<<-]>>-->+>+>+>-->+>>>+>++>>-->+>+>->>+>>>
  +>->+>>->++>-->-->++>->>>->++>++>+>>+>>+>>>+
 >->>>++>>>>++>++>>>>>+>>++>->+>++>>>>+++>>>+>>
 ->+>->+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[>>>>++
++++++++[->[-]+>[-]<<[<<<<<.>>>>.>>>>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>
>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>.>
>>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>>>>>>>>>>>>>
.>.>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<.>>>>-.>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>>.>..<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<-]>[<<<<<->[-]+>[-]<<[<.>>>>.>>>>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>>>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<.>>>>.>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>>>>>
>>>>>>>>.>.>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<-.>>>>+++++++++.>>>>.>.>.>.>.>.>.>.>
.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>.>..<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-]>[<<.>>>>.>>>
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>>>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<.>>>>.>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>
>>>>>>>>>>>>.>.>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<+++++++++.>>>>.>.>.>.>.>.>.>.>.>.>.>
.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>.>..<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<->]<<+>>>>>->]<<]<<<<
-]>>>>++++++++[->[-]+>[-]<<[<.>>>>.>.>.>.>.>.>.>
.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>>.<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>>>>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>>>>>>>>>>>>>>.>.>>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-.>>>>.>.>.>
.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>
.>>.>..<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-]>[<<.>>
>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>
.>.>.>.>.>.>>>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<.>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>>>>>>>>>
>>>>.>.>>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<-.>>>>.>.>.>.>.>.>.>>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>>.>..<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<->]<<]<.>>>>.>.>.>.>.>.>.>>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>>>.<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<.>>>>.>.>.>.>.>.>.>>.>.>.>.>.>.
>.>.>>>>>>>>>>>>>>.>.>>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.
>.>.>.>.>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<.>.>.>.>.>.>.
 >.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>>.>

No DrRacket:

Comunidade Racket em português

2011-06-03T17:36:00.000-03:00

O Racket tem uma comunidade bastante ativa e receptiva.

Para abrir espaço para aqueles a fim de aprender um pouco mais sobre Racket, mas que tem dificuldades de se comunicar em inglês, criei o grupo Racket Brasil.

Apesar do nome, fica o convite e apelo à participação dos nossos amigos portugueses e demais falantes da nossa língua.

É a oportunidade de nos conhecermos melhor e trocar informações.

Programando para Android com Racket

2011-05-29T22:31:00.007-03:00

Numa possível "série" de posts que acaba de começar agora, vou mostrar as várias possibilidades de uso de Racket, a linguagem para criar linguagens.

Uma das coisas fantásticas de Racket é a documentação. Esta pode ser consultada online ou offline quando você instala o ambiente na sua máquina (existem instaladores para Windows, Linux e Mac OS X).

A instalação é fácil veja meu post para mais detalhes. Para escrever nosso programa para Android ou browser vamos usar o Moby, um compilador da linguagem Advanced Student Language (uma das linguagens do Racket) para Javascript/mobile.

Não precisa se preocupar com a instalação do Moby. Ele está disponível no PLaneT, o sistema de distribuição de pacotes do Racket. Isto quer dizer que o DrRacket (uma IDE que vem incluída) vai instalar o Moby pra você no primeiro uso e deixar tudo prontinho...

Ok, então você instalou o Racket, abriu o DrRacket, e agora?
Como sempre, muito fácil.

Para começar, vamos verificar que seu ambiente está funcionando corretamente.
Cole o código abaixo na área de definições:

#lang planet dyoo/moby:3:10

"hello world"

true

(define (f x) (* x x))

(check-expect (f 42) 1764)

(check-expect (map f '(1 2 3 4 5))

(list 1 4 9 16 25))

Clique em "Run" (ou use o atalho CTRL+T) e veja o resultado:

Welcome to DrRacket, version 5.1.1 [3m].
Language: planet dyoo/moby:3:9; memory limit: 256 MB.
"hello world"
#t
Running tests...
Both tests passed!
>

A primeira vez pode ser um pouco mais lenta pois o DrRacket vai baixar e instalar o Moby. As outras execuções não precisam de Internet e serão rápidas.

Agora vamos criar dois arquivos:

counter.rkt

#lang planet dyoo/moby:3:10

(define initial-world 0)

(big-bang initial-world (on-tick add1))

run-counter.rkt

#lang racket

(require (planet dyoo/moby:3:10))

(run-in-browser "counter.rkt")

Agora basta executar o run-counter.rkt clicando no botão "Run".

Pronto, sua primeira aplicação está criada.
Veja como ficou:

Ela é bem simples, só um contador. Mas que funciona no browser e.... e no seu Android!! Se você não tiver um, funciona no do seu amigo...

Para instalar a aplicacão no Android precisamos gerar um pacote. Para isto criamos um outro arquivo, o "build-counter.rkt", com o seguinte conteúdo:

#lang racket
(require (planet dyoo/moby:3:10))
(create-android-phone-package "counter.rkt" "counter.apk")

Este programa vai transformar nosso "counter.rkt" em um pacote para Android "counter.apk".
Pronto!

Sim, pronto! Instale a aplicação no seu Android e divirta-se!

Como ficou no Android?
Como eu não tenho um telefone com Android, baixei a SDK com um emulador e criei um dispositivo virtual para testar.

Baixei o Android SDK pra Linux e extraí num diretório qualquer.
Basta executar o utilitário em tools/android para criar um AVD (dispositivo a ser emulado). Para criar um
AVD é preciso instalar alguma versão da API, na área "Avaiable Packages" eu escolhi "SDK Platform Android 3.1, API 12, revision 2".

Em resumo:

Inicie o dispositivo clicando em "Start".

Para desbloquer a tela use "Page Up" do seu teclado.

Para instalar o nosso aplicativo "counter" no Android, execute este comando num terminal:

rodolfo@lisa:~/Downloads/android-sdk-linux_x86/platform-tools$ ./adb install ~/projects/racket-for-smartphones/counter.apk
1348 KB/s (203114 bytes in 0.147s)
 pkg: /data/local/tmp/counter.apk
Success

Instalado! Clique no menu de aplicações, aquele ícone com vários quadradinhos entre o globo e o fone.

E lá está nossa aplicação counter!!! Clique no ícone para executar.

Minha conclusão é que este procedimento é mais fácil do que o Hello World em Java proposto pelo Android SDK... e já temos algo melhor que um Hello World.

Você tem um Android aí na sua mão? Quer testar? Baixe e instale o pacote counter.apk (200 kB) e me mande uma foto!

[editado 2011/05/30 12:11]
O meu amigo Juan Lopes testou num Android, vejam:

Se você acha que um contador não é tão legal, então pode tentar outros exemplos, e pode também criar sua própria aplicação. O Moby dá acesso a GPS, sensor de movimento, acelerômetro, Internet, e tudo que não tiver lá pode ser estendido.

Para mais informações, veja a documentação oficial do Moby e a página do projeto com slides, material em áudio e vídeo (em inglês).

Futuro
O Danny Yoo está trabalhando em um compilador de Racket para Javascript, o Whalesong, que deve ser integrado ao Moby, substituindo a camada atual de compilação. Feito isto, ele pretende focar novamente em melhorar o Moby.

Agradecimentos
Obrigado ao Danny por ter atualizado o Moby para funcionar corretamente com a versão mais recente do Racket (5.1.1), à equipe PLT por criar o Racket, e à comunidade pelo entusiasmo e prestatividade.

Como instalar o Racket

2011-05-29T22:20:00.002-03:00

Neste post explico como instalar o Racket, incluindo os programas e utilitários de linha de comando e a IDE DrRacket.

Para começar, acesse a página de download do Racket, escolha sua plataforma, e clique no botão de download.

Escolha da plataforma
O Racket fornece pacotes binários / instaladores para as seguintes plataformas: Windows x86, Macintosh OS X (Intel i386), Macintosh OS X (PPC), Macintosh Darwin (PPC), Linux i386 (Fedora 12), Linux i386 (Ubuntu jaunty) e Linux x86_64 (Fedora 14).

Usar os instaladores é a forma mais rápida de preparar o ambiente e começar a programar.

Para outras combinações de sistema operacional e arquitetura, existem opções de download do código-fonte para Windows, Macintosh, e Unix.

Se você usa algum Linux, recomendo instalar a partir do código-fonte para ter uma instalação otimizada para sua plataforma.

Se você usa alguma outra plataforma e tiver dificuldades, peça ajuda na lista de emails oficial ou no canal do IRC oficial (ambos em inglês), ou ainda na lista Lisp-br (em português).

Abaixo retrato mais detalhes da instalação em Windows e Linux.

Windows
Baixe o instalador binário, na opção "Windows x86", que vai servir se o seu sistema for tanto 32 quanto 64 bits. Se o seu sistema for de 64 bits, note que o Racket e DrRacket irão rodar no modo de compatibilidade, em 32 bits. Isto em geral não representa problema algum. Se você tiver alguma boa razão para rodar de fato em 64 bits, então instale a partir do código-fonte, e se tiver problemas procure um dos canais que citei acima.

Localize o arquivo baixado e execute o instalador.

A instalação é como a maioria das outras em Windows. Basta clicar "next" até terminar a instalação.

Para abrir o DrRacket e começar a programar localize-o no Menu Iniciar.

Pronto, você instalou o Racket e já pode se divertir pra valer!

Se não souber por onde começar, veja alguns exemplos de código Racket aqui.

Linux (Ubuntu)
Apesar de poder instalar usando o instalador automático, eu recomendo instalalar a partir do código-fonte. O instalador para o Ubuntu é compilado para a versão 9.04 Jaunty Jackalope. A atual é 11.04 Natty Narwhal.

Já usei com sucesso a versão compilada para Ubuntu com a versão 10.10 Maverick Meerkat, entretanto alguns módulos específicos podem não funcionar - em particular tive problemas em executar uma aplicação daquelas de exemplo na página inicial do Racket.

Baixe o arquivo racket-5.1.1-src-unix.tgz, e para compilar faça:

rodolfo@lisa:~/Downloads$ tar xaf racket-5.1.1-src-unix.tgz 
rodolfo@lisa:~/Downloads$ cd racket-5.1.1/src
rodolfo@lisa:~/Downloads/racket-5.1.1/src$ mkdir build
rodolfo@lisa:~/Downloads/racket-5.1.1/src$ cd build
rodolfo@lisa:~/Downloads/racket-5.1.1/src/build$ ../configure
...
rodolfo@lisa:~/Downloads/racket-5.1.1/src/build$ make
...
rodolfo@lisa:~/Downloads/racket-5.1.1/src/build$ make install
...
## Opcionalmente, mova o diretório para qualquer outro lugar
rodolfo@lisa:~/Downloads/racket-5.1.1/src/build$ cd ../../../
rodolfo@lisa:~/Downloads/racket-5.1.1/src/build$ sudo mv racket-5.1.1/ /opt/racket/

Adicione o Racket ao seu PATH, adicionando estas linhas ao seu arquivo ~/.bash_rc:

# Add Racket to PATH
PATH=$PATH:/opt/racket/bin

Pronto! Você deve querer criar alguns atalhos. Use o Alacarte, clicando com o botão direito no menu Aplicações > Editar Menu.

Adicione atalhos para /opt/racket/bin/drracket, /opt/racket/bin/plt-games e /opt/racket/bin/slideshow. Você pode usar ícones de /opt/racket/collects/icons.

Pronto, você instalou o Racket e já pode se divertir pra valer!

Se não souber por onde começar, veja alguns exemplos de código Racket aqui.

Sobre escolhas no projeto de linguagens de programação

2011-05-27T11:52:00.000-03:00

Este tópico muito me atrái, e por vezes levanto esta discussão nos nossos encontros semanais do Dojo Rio.

Ontem fiz um post tentando esclarer que num mar de similaridades sintáticas podem existir muitas diferenças semânticas. O caso prático foi uma comparação envolvendo Boo, Python e Ruby.

A discussão seguiu na lista do Dojo, e um outro aspecto que marca a diferença entre escolhas feitas no projeto da linguagem Python e escolhas feitas no projeto da linguagem Boo surgiu num comentário do Juan. Este post é uma reflexão sobre este aspecto.

O Juan disse:

De qualquer forma, a coisa que mais me faz gostar de boo é não escrever "__init__", e sim "constructor".

Taí, gosto é um negócio bem abstrato e indiscutível muitas das vezes.

Seguindo a linha de papos que temos às vezes sobre as escolhas feitas no projeto de linguagens e as consequências que estas escolhas acarretam, ser "__init__" ou "constructor" é mais uma questão de escolha, na qual cabe-nos apenas declarar nosso gosto se o tivermos, e observar consequências.

Talvez por estar acostumado com a filosofia Python, o Zen of Python se quiserem, eu gosto da consistência ortogonal do "__whatever__" como disse o Berrondo.
E falar sobre gosto pára por aqui.

Mas e as consequências das escolhas?

1) Uma delas já está embutida na fala do Berrondo, a questão da consistência.
Neste ponto, uma das algumas vantagens que observo é a facilidade de identificação visual do papel de um método em uma classe:

Se ao bater o olho, numa fração de segundos, em um bloco de código e ver "def __algumacoisa__(self, ...):", então trata-se de alguma coisa especial.

2) De certa forma também evita as colisões de nome (name clashes):

Convenhamos que é mais natural num código de "usuário" (da linguagem) escrevermos "def meumetodo(self, ...):" do que "def __meumetodo__(self, ...):". Ou seja, "__" foi escolhido de forma a ser um prefixo que em condições normais não seria utilizado (não é como "get" ou "set"). Como se não bastasse, além do prefixo também tem o sufixo "__".
Convenhamos ser mais provável inadvertidamente escrevermos "GetHashCode" do que "__hash__" em um método que não tem nada a ver com o papel destes métodos na linguagem.

Podemos argumentar a favor de Boo dizendo que a tipagem estática e o processo de compilação podem detetar inconsistências, mas na prática aparentemente nada impede que sobrescrevamos o método padrão "op_Add" por um nosso que não atenda as espeficicações originais — um erro de semântica quase nunca é detetado de forma automatizada.

Não tenho Boo aqui pra testar. Chutando pelo comportamento de Java, se existir um método herdado "op_Add" e um outro declarado e implementado na classe em questão, e os dois tiverem assinaturas diferentes, o método a ser usado é definido pelos tipos de argumentos recebidos na chamada.

Isto é:

public class Falante {  
  public String toString() {  
    return "Sou um objeto da classe Falante";
  }
  public String toString(String nome) {  
    return "Olá " + nome + ", tudo bem hoje?";
  }
}

...

Falante f = new Falante();
f.toString() /*  Sou um objeto da classe Falante  */ 
f.toString("Túlio") /*  Olá Túlio, tudo bem hoje?  */

3) A terceira consequência que me vem em mente é a questão da extensibilidade. O Berrondo citou que "__whatever__" remetem a protocolos em Python, coisa que se assemelha vagamente ao papel de interfaces em Java (cuidado, não é a mesma coisa!). A sintaxe da forma que é tem uma vantagem de extensibilidade:

Você pode criar seu próprio protocolo! E de fato eles existem. Para diversas coisas, como serialização de dados, mocks, e qualquer coisa que você puder imaginar. Uma biblioteca ou framework pode adicionar novos protocolos, os quais você usa para interagir com essa ou esse.
É um "duck typing" institucionalizado.

A escolha de Boo já não tem esta vantagem, e não sei qual seria o equivalente dos protocolos. Criam-se classes abstratas, interfaces, o que?! Não sei.

Ah, claro, é preciso deixar claro que não é o fato de você poder criar "seu próprio protocolo" que é excitante, mas sim que o seu protocolo é tão bom quanto os que já vem na linguagem, e inclusive tem a mesma aparência sintática (se você assim dedidir, afinal ao invés de chamar de __meumetodo__ poderia sem sombra de dúvida ter sido chamado de meumetodo).

A grande beleza está na manutenção da consistência ao se expandir a linguagem para atender à sua necessidade.

(Ah, e neste ponto Lisp, na minha opinião, domina. Fique ligado nos meus posts sobre Lisp/Scheme/Racket)

Listei 3 consequências, e aposto que existem outras... você é capaz de citar mais alguma?

Não tenho conhecimento de Boo além do que fizemos na última quarta no dojo, portanto podem haver deslizes - se detetar algum me avise :D

Mergulhando no Racket

2011-05-26T23:13:00.000-03:00

Se tudo der certo vou escrever ainda muitos posts sobre Racket aqui no blog.
Simplesmente porque se eu achava Python muito legal, hoje Racket parece ser o novo Python na minha vida.

Continuo achando Python muito legal, mas acho que o problema é que muitos outros também, e isto tem tornado Python "a linguagem da vez" em algumas situações (muitas vezes acompanhados de Django), com trágicas consequências.

Talvez seja exagero meu, mas meu ouvido já doeu bastante ao ouvir alguns escrevendo "php em Python", pessoas que não entendem nem de PHP, nem de Python, nem de Web e nem de programação em níveis mais básicos.

Não estou aqui para reclamar disto, mas sim para fazer uma breve introdução à mudança - ou ao acréscimo de mais uma linguagem legal ao repertório.

Ah, os posts começaram quando falei sobre minha Introdução ao Racket no Coding Dojo Rio.

E dentro de alguns minutos terá mais um...

Boo não é Python

2011-05-26T19:18:00.006-03:00

Ontem no Coding Dojo Rio no Centro do Rio de Janeiro tivemos uma nova linguagem para experimentar. Em linhas gerais o dojo foi sensacional, e não só os minutos que estávamos lá programando mas também as discussões que rolaram até tarde. Cheguei a casa já eram 2:40!

O problema que abordamos foi o do Caixa Eletrônico. Graças ao Juan Lopes nós usamos Boo e um super dojo timer novinho em folha. A idéia deste post é apenas discutir brevemente um aspecto da linguagem que me chamou a atenção.

Portanto, que fique claro que, apesar da maior parte da sintaxe ser parecida, as linguagens não são as mesmas, e algumas escolhas semânticas e gramaticais deixam isto claro. Também não se trata do que é melhor e o que é pior.

Ontem fiquei curioso pois numa parte obscura do nosso código tínhamos uma função mais ou menos assim:

def sacar(valor):
    return (valor,) if valor in (2, 5, 10, 20, 50, 100)
    
    raise EntradaInconsistente() if valor <= 0
    
    return (20, 20) if valor == 40
    
    return (2,) + sacar(valor - 2) if (valor - 2) in (2, 5, 10, 20, 50, 100)

Possívelmente não era exatamente isto, mas era algo muito parecido e equivalente. Tínhamos 4 linhas que eram raise ou return, seguido de um valor de retorno, seguido de um if e uma condição.

Não demorou para percebermos que a legibilidade estava ruim, pois para saber o que cada linha fazia era preciso ler a linha inteira. Se os if's estiverem em suas próprias linhas, fica mais fácil ler a condição e "ignorar" o bloco de código (mesmo que uma expressão curta...) que se segue.

    if valor in (2, 5, 10, 20, 50, 100):
        return (valor,)

Mas isto pode ser considerada apenas uma questão estilistica...

O ponto é que eu jurava que "return (20, 20) if valor == 40" não é uma linha válida de Python! Sim, de Python... mas estávamos programando em Boo.

Acabou que nós não testamos lá, e ficou o suspense. Em Ruby reza a lenda que isto funciona e é super normal, mas em Python... em Python a história é outra.
Eu fui testar agora no ipython:

In [1]: def foo(x, y):
   ...:     return "x par" if x%2==0
------------------------------------------------------------
   File "", line 2
     return "x par" if x%2==0
                             ^
SyntaxError: invalid syntax


In [3]: def foo(x, y):
    return "x par" if (x%2==0)
------------------------------------------------------------
   File "", line 2
     return "x par" if (x%2==0)
                               ^
SyntaxError: invalid syntax


In [5]: def foo(x, y):
    return "x par" if (x%2==0) else 0
   ...:

E foram confirmadas minhas expectativas de que isso não funciona em Python :D

Tanto return quanto raise são palavras-chave que formam gramaticalmente uma declaração (statement) em Python. E a declaração é "return truthy_value if condition else falsy_value", como pode ser visto na gramática.

A semântica quando se começa uma linha por return é que a função vai retornar o que quer que seja o valor avaliado para o que vem depois da palavra-chave (a não ser claro que antes disso ocorrer uma exceção seja lançada).

E é só isso...

Nota: não encontrei a gramática do Boo para linkar...
Nota mental: espero fazer mais desses posts ao invés de mandar emails longos :D

[update 26/05/2011 20:08]
O Juan acrescentou na lista do Dojo sobre a gramática de Ruby:

STMT : STMT if EXPR
STMT : EXPR
EXPR : ARG
ARG : PRIMARY
PRIMARY : return [`(' [CALL_ARGS] `)']

E então, comparando com Python (já que eu tinha só linkado antes):

return_stmt: 'return' [testlist]
testlist: test (',' test)* [',']
test: or_test ['if' or_test 'else' test] | lambdef

Agora só fica faltando formalizar a gramática do Boo. Fiz uma busca de novo no Google e no site oficial do Boo, mas não achei! Será que você tem mais sorte?

Introdução ao Racket no Coding Dojo Rio

2011-05-18T16:33:00.001-03:00

Hoje no Dojo Rio no Centro farei uma apresentação de introdução à linguagem Racket.

Fiz um post no blog do Dojo Rio e replico ele aqui:

O que é “Racket”?
É uma linguagem relativamente nova, antes chamada PLT Scheme, que mostra sua origem em Scheme, um dos dois mais conhecidos dialetos de Lisp (o outro sendo Common Lisp).

Racket pode ser considerado também como uma família de linguagens, já que existem diversas sublinguagens para fazer as mais diversas coisas, como escrever documentação, apresentação de slides, ensinar programação, programação em lógica, etc.

Por que esta apresentação?
Já faz um tempo que queria compartilhar meu entusiasmo com programação funcional e Lisp, e por vezes pensei em levar lá pro Dojo o Common Lisp. Entretanto, a forma mais legal de trabalhar com CL seria usando o editor Emacs e o SLIME.

Acontece que configurar tudo isso e esperar que as pessoas consigam usar numa boa é complicado — principalmente esta segunda parte. Já basta a resistência com a sintaxe diferente e com ideias e formas de programar diferentes, ainda ter que lidar com um ambiente “hostil” certamente traria desânimo, revolta e incompreensão.

Se você já está habituado a usar o Emacs, programar em qualquer dialeto de Lisp certamente vai ser “mamão-com-açúcar”!

Por que Racket?
Então, por que Racket? O Racket além de funcionar bem em Linux, Mac OS e Windows, vem com um ambiente de desenvolvimento, oDrRacket, que torna a experiência de programar divertida e produtiva (ymmv). E mais, a documentação é muito boa, e a comunidade muito receptiva (você sempre pode tirar dúvidas via IRC ou lista de emails).

Screenshot do DrRacket

Racket não é só uma linguagem educacional! Também é possível fazer aplicações reais, em diversas áreas, e elas existem. Abaixo uma lista de alguns usos de Lisp/Scheme/Racket:

Sources for “real-world” web applications running on plt-web-server — Reginaldo J. S. Filho (brasileiro!)
Companies using Lisp or Scheme for industrial applications
Little Wing Pinball
State-Based Scripting in Uncharted 2 – GDC09 presentation from Naughty Dog (bonus: Scheme!) (no Reddit)
Quantz (game)
HOP (GoogleTechTalk “HOP: A Language for Programming the Web 2.0″)
Yahoo Store (early version) done by Paul Graham;
Reddit (written in PLT Scheme and then rewritten in Python);
Y Combinator (Arc over PLT Scheme);
Reverso (aplicação para iPhone em Scheme feita por um brasileiro!)
Continue Conference Management
Commercial Users of Functional Programming
Kahu
Examples of Scheme (or Lisp) in real-world
…

Dica: como terminar uma sessão de SSH congelada

2011-05-03T01:03:00.000-03:00

Algumas vezes por algum problema na rede ou qualquer outra coisa ficamos com o nosso terminal bloqueado por conta de uma conexão SSH morta.
O que podemos fazer é matar o processo com um "kill" ou simplesmente fechar a janela do console (exemplo: gnome-terminal).

Mas existe uma forma melhor de terminar esta sessão mal-sucedida. Basta digitar ENTER, seguido de ~..
Pode parecer bizarro à primeira vista, mas funciona. Você vai encerrar o SSH e voltar para o seu bash.

Lisp e o futuro da Web

2011-04-21T13:57:00.000-03:00

Ultimamente tenho "namorado" desenvolvimento web com Common Lisp. Já usei Clojure lá na Intelie e foi uma experiência excelente.

Eis que estava assistindo a uma Google Tech Talk com Peter Seibel, o autor do Practical Common Lisp (video linkado no Lisp-br), quando me deparei com uma outra Tech Talk sobre HOP, a linguagem de programação da Web 2.0, da "Web difusa".

O Google antecipa, o futuro é Lisp-based :D
Será?

http://hop.inria.fr/

Nota: o botão de "back" do browser não funciona no site do HOP... :|

[]'s

Rodolfo Carvalho

Small Acts Manifesto

2011-04-19T14:43:00.002-03:00

Vou fazer um pequeno ato agora. Espero ajudar a divulgar o Small Acts Manifesto.

Participe e divulgue você também:

Via: http://wigflip.com/automotivator/

Como desligar o monitor do seu notebook com Ubuntu

2011-03-19T16:57:00.000-03:00

Se você quer desligar o monitor sem ter que suspender ou desligar ou fechar a tampa do seu notebook, aqui está a solução:

$ sleep 1 && xset dpms force off

O monitor será desligado. Para religar, basta mover o mouse ou apertar qualquer tecla.

Funcionou pra mim, espero que seja útil pra você também!

Tor Project e Sistemas de Anonimato

2010-12-11T18:10:00.000-02:00

Fiz um trabalho sobre o Tor Project e Sistemas de Anonimato para o curso de Redes na UFRJ.
Apresentei o trabalho no dia 1 de dezembro, com uma boa sessão hands on.
Depois da solicitação de um amigo, me dei o "trabalho" de colocar aqui no meu site.

Eu deveria compartilhar mais conteúdo que eu produzi nestes anos de universidade...

Reciclagem de monitor CRT

2010-12-02T02:06:00.000-02:00

Visto nesta quarta no Grêmio da COPPE, restaurante na UFRJ.

E tinham mais 2 ou 3 desses.... O que será que vão fazer com monitores LCD?
E o que será que fizeram com os tubos de raios catódicos? Será um novo mega acelerador de partículas?

Paralelismo em Clojure: Threadpool produtor - consumidor

2010-11-27T16:59:00.001-02:00

Ontem fiz uma pequena implementação rascunho de uma fila consumida por threads de processamento em Clojure.
Eu havia feito algo similar em Python para encontrar nomes de usuário disponíveis no Twitter.
Tive dificuldade em encontrar uma forma canônica de fazer isso, sem querer me meter muito no mundo Java.

Por fim deixo o código aqui como lembrança do meu feito.

(def *mul* 1)

(defn slow-task [v] (Thread/sleep (* @#'*mul* v)) v)

(def history (ref []))

(defn init-items [stream]
   (let [items-stream (ref stream)]
   (fn get-item []
   (dosync
   (let [f (first @items-stream)]
   (alter history conj [(count @items-stream) f])
   (alter items-stream rest)
   f)))))

(defn worker []
   (doall
   (for [x (repeatedly get-item) :while x]
   (try
   (slow-task x)
   (catch Exception _ :put-item-back-to-queue)))))

(defn process-all [n-workers]
   (doall
   (for [x (range n-workers)]
   (future (worker)))))

(defn main [n-tasks n-workers time-mult]
   ; set multiplier for sleep
   (def *mul* time-mult)

   ; clear history
   (dosync (alter history empty))

   ; set number of tasks to process
   (def get-item (init-items (take n-tasks (cycle [1 7 2 3]))))
   (sort-by (fn [[k v]] k) (doall (into [] (map (fn [T] [(reduce + T) T]) (time (doall (map deref (process-all n-workers)))))))))

(main 100 20 100)

;------ alternativa ainda não explorada --------
(def producer (seque 1 (cycle (range 10))))

(doseq [o (take 10 producer)]
  (println "consumer:" o)
  (Thread/sleep 1000))

O código acima foi fruto de uma experimentação no REPL. Acabei usando a ideia depois num de nossos projetos na Intelie.
Agradeço ao pessoal que postou nesta thread do grupo de usuários de Clojure e este post no guj.

Linguagens usadas no DojoRio

2010-11-26T16:24:00.000-02:00

Fiz uma pequena lista das linguagens que usamos em cada dojo de 2010.

-- javascript (8) ------------------------------------------------------------
20100210: proxima vitima
20100505: romanos
20100519: pedra papel tesoura
20100602: caminho
20100707: reais por extenso
20100721: 3n+1
20100804: ascii
20100818: url rewrite

-- perl (1) ------------------------------------------------------------------
20101124: inteiros para romanos

-- php (4) -------------------------------------------------------------------
20100714: espiral
20100728: palindromos
20100811: game of life
20100908: cheque o xeque

-- python (14) ----------------------------------------------------------------
20100106: sql
20100203: tennis
20100224: metadojo
20100324: jogo da velha
20100428: reversi
20100512: automato
20100623: roleta romana
20100825: datas
20100929: espiral
20101006: espiral
20101013: fizzbuzz
20101027: espiral
20101103: forca
20101117: forca

-- ruby (10) ------------------------------------------------------------------
20100113: gols
20100127: abastecimento dagua
20100303: detetive
20100414: HomeRange
20100526: saving time
20100609: cheque o xeque
20100616: jokenpo
20100630: validador
20100915: encaixotar
20101020: Espiral

-- shell (2) -----------------------------------------------------------------
20100901: fizzbuzz
20100922: url

O script usado está em http://code.google.com/p/dojo-rio/source/browse/trunk/stats.py

E aí, o que acham?

Estou no rumo certo do TDD e Baby Steps?

2010-11-26T16:10:00.002-02:00

Costumamos falar destes termos toda semana no DojoRio, mas imagino que nem todos de fato compreendem os termos para além das traduções pro português e mais alguma idéia superficial ou distorcida do que seja.

Isto não é um ataque, e sim um convite a reflexão para que cada um faça um "self-check"...

E aí, será que posso melhorar a qualidade do meu código? Será que faço TDD de verdade, ou só estou enrolando ou me enganando? Esses tais passos de bebê são úteis pra mim? Estou fazendo a coisa certa?

Graças ao link que o Berrondo mandou pra lista de emails recentemente (numa retrospectiva do que rolou na última quarta), vi que o Aniche fez boas considerações sobre este ponto:

http://www.aniche.com.br/2010/11/cuidado-com-seus-baby-steps/

Na quarta, depois do nosso randori normal de toda quarta, tivemos um kata do Juan Bernabó mostrando como ele ataca o problema de transformar números arábicos em romanos sem pensar! Isso mesmo, sem pensar. Sem parar de fazer o simples processo de escrever testes, identificar padrões e refatorar.

Confira o resultado do kata:
http://code.google.com/p/dojo-rio/source/browse/#svn/trunk/2010/20101124 - inteiros para romanos - perl

Vendo netbook HP Mini 210-1000EW

2010-11-25T13:42:00.005-02:00

Clique aqui para dar sua oferta netbook.rodolfocarvalho.net!

Pessoal,

No meado de dezembro viajo para a Europa para tirar umas longas férias. Vou visitar minha namorada (que conheci no intercâmbio que fiz em Lisboa no último ano), e aproveitar para visitar o máximo de cidades que for possível. Será Strasbourg, Frankfurt, Cracóvia, Dortmund, Bratislavia, Olomouc, etc.

Vou precisar investir uma grana nessa empreitada. Com isso, meu netbook HP Mini 210-1000EW terá pouca utilidade (largar ele aqui em casa na poeira?!). Não tenho uma lojinha que nem o Vinícius, mas também quero passar pra frente esse netbook que tem menos de 3 meses de muito pouco uso.

Ele é um pouco melhor do que os modelos HP Mini encontrados aqui no Brasil. Tem HD de 250 GB, 1 GB DDR2 (facilmente pode virar 2GB), bastante compacto com tela de 10.1" e resolução 1024x600, bluetooth, wifi, leitor de cartões 5x1, câmera, e o melhor é a bateria de 6 células que dura de verdade entre 5 e 6 horas.
O teclado é US (não tem ç), e é com as teclas espaçadas como nos Macs. Tem também um leitor de SIM card que permite usar para conectar à Internet com 3G.

Além de ser pequeno e fácil de carregar, sua autonomia permite até que você saia de casa e não leve o carregador! Mas se quiser levar, ele também é bem pequeno e leve.

Este netbook tem um mini sistema operacional chamado HP Quick Web que boota em poucos segundos e permite ouvir músicas, ver fotos, navegar na internet, ler email, tudo sem esperar o boot do Windows ou outro sistema operacional.

Veja as fotos do HP Mini que pode ser seu

HP Mini 210-1000EW

Dê sua oferta em netbook.rodolfocarvalho.net.
Para qualquer dúvida, envie um email para netbook-arroba-rodolfocarvalho.net

Leituras

2010-11-21T03:06:00.000-02:00

Estou lendo:

Practical Clojure (parei um pouco além da metade)
On the cruelty of really teaching computing science (há um bom tempo pra começar, mas agora com PDF no celular fica mais fácil...)
Crush it (obrigado @Israel!)
On Lisp
Land of Lisp (excelente)
Structure and Interpretation of Computer Programs (leitura obrigatória... estou començando agora, depois de muito tempo que ficou na fila... mais uma vez, leitura no celular!)
The Moon Is a Harsh Mistress (ainda pra começar... desisti de ouvir o audiobook)

Tem mais coisa que vai surgindo... mas esta foi a listinha que enviei num email outro dia :D

Criando uma conta no Twitter

2010-11-21T02:32:00.000-02:00

Tem sido difícil tirar um tempinho para blogar. Estes dias estou lendo um livro que o Israel me emprestou, e finalmente de alguma forma me convenci a criar uma conta no Twitter. Não para ficar perdendo meu tempo falando onde estou, ou que a pizza chegou atrasada, ou que isso ou aquilo. O interesse é apenas "educacional", já que a plataforma é de fato interessante.

É claro, entrar no jogo nesta altura do campeonato não é nada fácil... Opções como "rhcarvalho" ou "rodolfocarvalho" já foram tomadas meses ou anos atrás. E já que iria ficar com um nome de usuário pouco significativo, resolvi que este nome deveria ser curto.

Foi fácil perceber que todos os nomes com apenas 1 caracter já existiam. Com exceção do "i", mas mesmo assim não consegui criar um conta com o nome de usuário "i".

Ontem acabei desistindo de criar a tal conta. E hoje, sábado, escrevi um pequeno script em python para verificar todos os nomes possíveis com 2 ou 3 letras que ainda estivessem disponíveis.

Descobri que nada seria possível com 2 letras, e existiam 3112 opções com 3 letras. Destas, 1 era composta apenas por dígitos, e 5 eram compostas apenas por letras.
As contas compostas apenas por letras eram: ['xjv', 'txp', 'dzz', 'qfw', 'hqc']
Destas, nenhuma me interessa...

Mas o número... o número com 3 dígitos é a minha nova conta no Twitter! @201

201 é um número bacana!

Quanto ao script, usei meu conhecimento adquirido com web crawling multithread para viabilizar um "ataque de força bruta" a API do Twitter usada na verificação de disponibilidades de nomes.

Basicamente fiz um GET para cada permutação possível com letras, números e o "_" e verifiquei a resposta da requisição (em json).

Tudo usando as baterias inclusas do Python....

O código não está nem um pouco polido, mas pode ser útil como referência para outras aplicações.
Se tiver interessado em ver a última versão do código, entre em contato.

Aprendizado de máquina

2010-10-17T03:59:00.000-02:00

Curso da Faculdade de Engenharia de Standford sobre Aprendizado de Máquina:

http://see.stanford.edu/see/lecturelist.aspx?coll=348ca38a-3a6d-4052-937d-cb017338d7b1

É possível aprender com os dados?

2010-10-17T03:00:00.000-02:00

Tudo começou com a leitura de um post num blog, sobre Online Learning [1], sugestão de um amigo do estágio.
Nos comentários tinha um link para um site com vídeo aulas [2].
Chegando lá, já no primeiro link no topo da página [3] me interessei e comecei a assistir uma aula de uma hora sobre aprendizado semi-supervisionado.

Existem métodos de inferir/formular modelos a partir de um conjunto de dados no qual temos como entrada pares de entrada+saída. São os chamados métodos supervisionados.
Por exemplo, podemos ter como entrada 1000 emails e saber se cada um deles é um spam ou não.

Seria interessante agora inferir coisas a partir dos dados não classificados, classificação não-supervisionada.
Este é o caso quando queremos por exemplo encontrar grupos através de uma função de similaridade.

O aprendizado semi-supervisionado é quando temos alguns dados classificados, e outros não classificados. Ou seja, temos 1000 emails que sabemos distinguir entre spam e não-spam, mais digamos 9000 emails que não sabemos a classificação.

Esses 9000 emails podem ajudar substancialmente a desenvolver um modelo que dado um novo email ele seja classificado corretamente como spam ou não-spam.
Na aula são mostradas duas categorias de problemas, e que tipo de conjunto de dados funcionam bem usando as técnicas apresentadas.

Expectation Maximization (EM) [4]
Co-training [5]

Essas técnicas me deram uma idéia de como posso classificar tweets como positivos ou negativos a respeito de algum candidato nas eleições 2010 [6], bastando ter algumas amostras de mensagens classificadas positivamente e outras classificadas negativamente.

Fica a sugestão a todos para visitar o videolectures.net e passar algumas horas assistindo a aulas muito interessantes.

[1] http://mark.reid.name/sap/online-learning-in-clojure.html
[2] http://videolectures.net
[3] http://videolectures.net/mlas06_mitchell_sla/
[4] http://en.wikipedia.org/wiki/Expectation-maximization_algorithm
[5] http://en.wikipedia.org/wiki/Co-training
[6] http://www.eleitorando.com.br

Dicionários recursivos

2010-10-08T13:45:00.002-03:00

Só por curiosidade, alguém além de mim já fez isso aqui?

Digite no seu interpretador de Python:

d = dict()

d['d'] = d

d['d']

d['d']['d']

d = dict()

e = dict()

d['e'] = e

e['d'] = d

d['e']['e']

d['e']['d']

É bem interessante ver:

In [17]: d['e']['d']

Out[17]: {'e': {'d': <Recursion on dict with id=4321969824>}

De volta ao Brasil, e de volta a ativa...

2010-09-21T11:57:00.000-03:00

Depois de 11 meses em Portugal e 1,5 no Brasil como guia turístico, estou de volta.
Ontem comecei a trabalhar na Intelie, que certamente será fonte de grande aprendizado e diversão.

Na universidade (UFRJ) estou fazendo disciplinas interessantes, e pretendo fazer alguns posts sobre elas.

Também estou de volta ao DojoRio, evento que dei início e participei sempre até minha ida para o exterior.
E o dojo me trouxe muita satisfação. Ele cresceu para além de minhas expectativas, vários amigos estão fazendo palestras sobre o mesmo, e outras pessoas tem nos seguido e iniciado outros dojos pelo Brasil (e também pelo Rio, onde tivemos uma grande multiplicação).

Amanhã estarei lá na Lapa para mais um! O endereço é Rua Teotônio Regadas 26 sala 603 - Lapa, ao lado da Sala Cecília Meireles, próximo ao Metrô.

Utilização do disco usando du e awk

2010-06-28T14:22:00.002-03:00

Hoje escrevi algumas linhas no shell para me ajudar a identificar onde estavam as coisas mais pesadas na hierarquia...

Fica aqui como possível referência futura:

Listar/calcular tamanho para 2 níveis de diretórios

du -k -d2 . | awk '{printf "%-40s %4.1f MB\n", $2, $1/1024}' | sort

Ver os 15 maiores diretórios

du -k * | sort -nr | head -n 15

Ver apenas diretórios com mais de 1 MB

du -k -d3 main | awk '{ if ($1 >= 1024) printf "%-40s %4.1f MB\n", $2, $1/1024}' | sort

Explicações básicas:
du: mostra o espaço em disco ocupado por um arquivo/diretório.
-k mostrar valores em KB
-d N processar árvore de diretório N níveis

awk: permite fazer a magia negra. Para cada linha do input, imprimimos o nome do diretório (em $2) com uma largura de 40 caractéres (completados com espaços em branco) e o tamanho (em $1) dividido por 1024 (conversão para MB).

Novo layout

2010-06-26T20:58:00.000-03:00

Sei que o blog anda abandonado... os tempos aqui em Lisboa não são convidativos a bloggar muito :D
Infelizmente meu tempo aqui está chegando ao fim. Já não tenho mais aulas.

Hoje resolvi fazer uma limpeza no visual do blog. Espero ter mais alguma novidade em breve.
O antes e o depois:

Optei por usar um modelo com menos cores, alarguei o espaço para as postagens, rearrumei os widgets, renomeei títulos que sugeriam o nome antigo do blog, "LifeAtMyMind". E então, estou no caminho certo?
Gostei de ver "novidades" (que possivelmente já são bem antigas) no Blogger, como possibilidade de criar páginas fixas e mostrar só o início da postagem com um link "ler mais". Também usei o novo editor de modelo e gostei, apesar de visualmente ele ser totalmente diferente da interface padrão do Blogger.

Como encontrar arquivos usando o GNU find e ignorando alguns diretórios

2010-04-19T11:35:00.000-03:00

Esta dica foi tirada de um comentário anônimo em http://www.linux.com/archive/feed/49304.

Fica aqui para referência futura...

Algumas vezes queremos usar o GNU find para procurar por arquivos recursivamente. O problema é quando queremos excluir alguns diretórios da busca. O jeito é usar mais de uma condição. Por exemplo:

find / -path '/proc' -prune -o -path '/dev' -prune -o -name foo.txt

Este comando procura por arquivos chamados "foo.txt" na raiz de sistema, ignorando tudo em /proc e /dev. O '-o' é um "ou" e o '-prune' faz com que o find ignore o caminho encontrado.

Original em inglês:
Sometimes you may want to exclude parts of the directory tree. It took me a while to figure out how to do this because it isn't very intuitive.
If you wanted to search for foo.txt but don't want to descend into /proc or /dev you can do this
find / -path '/proc' -prune -o -path '/dev' -prune -o -name foo.txt

The '-o' means 'or', so there in this case there are three conditions, separated by 'or', which will cause find to take action. The first two is when the path is '/proc' or '/dev' the action find will take is to prune them from the search path. The third condition is when the name is foo.txt. In this case find will print, since no other action is specified.

Sons, muitos sons! Com Python :D

2010-01-21T19:22:00.000-02:00

Pois é, tive um dia de domingo agradável, programando!
A turma do Dojo Rio está tocando o projeto opensource Dojotools para reunir ferramentas para facilitar nossas vidas durante as sessões de coding dojo.
~~Para dar minha pequena contribuição~~ para minha diversão, e prejuízo de meus ouvidos, passei a tarde arrumando o sound_alarm. Este script surgiu de diversas brincadeiras que já havia feito para reproduzir som com Python no Windows e no Ubuntu.
Juntei coisas que eu já tinha, refatorei, produzi algumas "melodias" para perturbar quem se aproxima de mim, e taquei no github.

Ontem testei o script no Mac e não funciona. Pelo menos aqui no Macbook Pro não tem /dev/audio, e não descobri como tocar sons em diferentes frequências como consigo no Linux e Windows.

Eis que se alguém tiver uma solução pro Mac OSX ela é apreciada :D

Novas línguas do semestre

2009-12-10T15:53:00.000-02:00

Neste segundo semestre de 2009 inicei meu contato com diversas novas línguas e linguagens.
Para começar, estou agora morando em Portugal, o que me deixa em contato com um português um bocado diferente do que estava acostumado no Brasil.

Depois, por ter contato com amigos de diversas partes do globo, o inglês é certamente a língua que mais tenho utilizado no dia-a-dia. Para completar, tem o Polonês e o Turco, que podem parecer exóticos mas tem feito parte do meu cotidiano no momento.

Mas, o que tenho feito de novo aqui em Lisboa? Só vida boa? Não, não.
Os trabalhos da faculdade me fizeram desviar da jornada estritamente pythônica para olhar outras linguagens.

No Brasil meus amigos continuam arrasando com as super comunidades, mega encontros, e muita agitação todos os dias da semana. Aqui, encarei um projeto de Inteligência Artificial usando LISP.
O objetivo era resolver automaticamente instâncias do jogo Hidato.

Inicialmente o contato com LISP não foi muito amigável, porém com o tempo fui pegando o gosto e vi muito espaço para aprendizado com esta linguagem. Implementei meu projeto para o ambiente CLISP, e fiquei muito satisfeito pela boa velocidade com que resolvia grandes instâncias do jogo.

Os pontos que me deixaram curiosos no LISP e que ainda não tive a oportunidade de brincar foi o processamento de texto, acesso a dados via Internet, e outros detalhes que não me vêm à cabeça neste momento...

O lado negro foi ter que cursar Programação com Objectos usando Java, linguagem extremamente burocrática, e que nenhum conhecimento interessante me traz. É impressionante a distância entre uma idéia pra solucionar um problema e uma solução implementada em Java. Talvez os mais experientes hackers da terra do cafezinho vão discordar desse meu desabafo sem código, mas aqui o objetivo é só relatar meu descontentamento mesmo :P

Por fim, Matlab. É um ambiente proprietário, de sintaxe muitas vezes esquisita, e que estou utilizando nas aulas de Processamento de Imagens. Não vi ainda vantagens em relação a usar Python + Numpy + Matplotlib... ainda assim, é uma linguagem interpretada e lá temos console e um manual muito bem elaborado.

Acho que as linguagens compiladas tem um ponto a menos nas minhas avaliações por conta da velocidade do "escrever código". Legibilidade e fluxo de desenvolvimento acabam valendo mais que tempo de execução.