Ada 2.0b: a Máquina Programadora

“The term computer programmer can refer to a specialist in one area of computer programming or to a generalist who writes code for many kinds of software. (…) Ada Lovelace is popularly credited as history’s first programmer. She was the first to express an algorithm intended for implementation on a computer, Charles Babbage‘s analytical engine, in October 1842.”

“Programmer” verbete na Wikipedia

Ada 2.0b é um programador, focado em performances de Live Coding, criado em 2010. Ele foi projetado para criar programas usando o Pure Data (uma linguagem de programação de sintaxe visual), baseada na sua própria (sub/o)bjetividade, através de uma performance de Live Coding  – uma improvisação artística que utiliza uma linguagem de programação como meio de expressão – audiovisual.

Sua “inspiração” é uma auto-análise da máquina, que observa a todo tempo seu status através da análise do que acontece no seu Kernel – o núcleo do sistema operacional da máquina – em tempo-real, no momento da performance, tomando isso como base para a criação da performance de Live Coding audiovisual, sem nenhuma intervenção humana.

Para quem não conhece, o termo Live Coding:

Live coding (sometimes referred to as as interactive programming, ‘on-the-fly programming’, ‘just in time programming’) is the process of writing software in realtime, as a form of improvised time-based art. Typically, the process of writing is made visible by projecting the computer screen in the audience space.

“Live Coding” verbete na Wikipedia

A performance criada segue a linha de uma performance de Live Coding audiovisual comum: existe um terminal de computador, usado para a programação, um projetor, para o retorno visual, e um sistema de som, para o feedback sonoro. A diferença reside no fato de que não existe um programador humano no terminal, apenas o Ada 2.0b.

Inicialmente, o software checa o status do Kernel (características como a lista de processos que estão na CPU e na memória, bem como seu percentual de utilização, além do conteúdo da memória RAM da máquina em tempo-real), e, baseado nisso, começa a criar um Patch no Pure Data. Essa ação afeta diretamente o Kernel da máquina, que por sua vez, reflete tais alterações mais uma vez no Patch, num laço sem fim… esta interação Kernel-Patch continua até o fim da performance.

Inspirado no Emotional Kernel Panic e no Marvim Gainsbug, este projeto foi desenvolvido no Pure Data e em Python, utilizando um módulo especial para Dynamic Patching do Pd já citado aqui mesmo, no blog, o Pyata.

um agradecimento especial a Ricardo Brazileiro e a Renato Fabbri pelas dicas do Emotional Kernel Panic: valeu mesmo, galera!

mais fotos podem ser encontradas no flickr:

http://www.flickr.com/photos/jeraman/sets/72157624399005058/

O código-fonte do projeto pode ser encontrado para download no github (projeto desenvolvido no Ubuntu 9.04, utilizando o Python 2.6.2 e o Pure Data 0.41-4):

https://github.com/downloads/jeraman/jeraman.lab/ada%20v.2.0b.zip/

maiores informações

[1] sobre o Pure Data
[2] sobre Python
[3] sobre o Pyata
[4] sobre o Emotional Kernel Panic
[5] sobre o Marvim Gainsbug

pyata – programando o pure data com python

dando continuidade a minha linha de pesquisa sobre Dynamic Patching, desenvolvi um nova ferramenta: o Pyata.

Pyatã (do Tupi, ou ainda Py.thon + Pure D.ata) é um simples módulo python opensource e multiplataforma que permite que o Pure Data (vulgo Pd) seja utilizado como uma API. em outras palavras, se trata de uma abstração do Pd, que permite ao Python utilizar praticamente todas as funcionalidades do Pd, incluindo criar, editar e remover patches, sem a necessidade de interação por parte do usuário com a interface do Pd.

o vídeo abaixo mostra algumas coisas que podem ser feitas com o projeto (a propósito, para uma melhor compreensão, recomendo assistir ao vídeo na página do Youtube, em HD):

a ferramenta em Python é  uma implementação em Python do protocolo FUDI, já citado aqui mesmo no blog, que permite o Dynamic Ptaching . ela também pode ser vista como uma evolução do PyPd (mais completa, enxuta e estável),  ferramenta que implementei durante meu trabalho final de conclusão de curso (por conta disso, o projeto  do Pypd será descontinuado).

dessa forma, o que o módulo faz é receber os comandos do Python e transformá-los numa mensagem FUDI equivalente. Essas mensagens são enviadas para o core do Pd, que as processa num Patch que roda virtualmente dentro da máquina, gerando resultados. Após isso, tais resultados são carregados no programa Python, mantendo a sincronia do programa com o Patch virtual.

com o Pyata é possível:

• criar, editar, remover, mover, clicar, (des)selecionar caixas (objeto, números, symbols, comentários e mensagens);
• pegar do pd o estado de qualquer caixa (números de inlets/outlets, id de cada caixa, além dos valores de números e symbols em tempo real);
• gerenciar conexões (conectar e disconectar);
• operações básicas (copiar, colar, duplicar, cortar e salvar);

maiores informações, incluindo o código fonte e tutoriais, podem ser encontrados no site do projeto:

http://code.google.com/p/pyata/

mais uma vez obrigado ao pessoal da lista do Artesanato de Volts pela ajuda, em específico a Vilson Vieira (e o seu topd)!
abraços!

o II LaboCA: FILE PRIX LUX em Recife

quase um mês depois da primeira experiência do LaboCA na Semana Chico Science Propagando, aconteceu no dia 20 de Maio no Instituto Cultural Banco Real, a segunda experiência do LaboCA no lançamento da votação popular do FILE PRIX LUX no Recife.

reduzida a um único dia (apenas 4h), a oficina foi bem diferente da anterior, sendo mais descentralizada. enquanto uma parte focava na produção coletiva motivado pelo intercâmbio de conhecimentos, outra focava, através de uma conversa informal de caráter didático, em fazer com que os mais leigos pudessem construir seu próprio instrumento audiovisial inspirado no Theremin, controlado por luz, usando pra isso o software livre Pure Data.

após a apresentação dos projetos pernambucanos indicados ao prêmio, ao mesmo tempo em que acontecia um coquetel, fizemos uma grande Jam dos Theremins criados durante a oficina (que durante toda a performance eram controlados pelo público), juntamente com outros Patches criados durante a oficina, a Afrobeat Machine de Jarbas Jácome, dois guitarristas (o próprio Jarbinhas e o grande Daniel Malcriado) e com um show a parte por conta de Salsaman, que usava o LiVES – software livre desenvolvido por ele mesmo – para criar imagens fantásticas na projeção! coisa finíssima!

um trecho dessa performance-salada-mista pode ser conferida no vídeo abaixo:

uma outra performance bem interessante que aconteceu durante o coquetel foi o Video Game Dubwise, na qual o áudio do emulador do videogame é alterado em tempo real, através do Pure Data, enquanto as pessoas estão jogando! o resultado pode ser conferido no vídeo abaixo:

bem… é isso! mais fotos podem ser encontradas no Flickr do LaboCA:

http://www.flickr.com/photos/olaboca/sets/72157623979999715/

simulando a Interface do Pd através de mensagens

dando prosseguimento aos estudos sobre Dynamic Patching, resolvi tentar simular todas as possibilidades da interface do Pure Data usando pra isso só troca de mensagens com seu core.

isso nos permitiria operar o Pd sem sua interface gráfica (no-gui mode), de maneira a simular a ação de um usuário, possibilitando, por exemplo, criar APIs para outras linguagens (C++, Python, etc) que permitam programar o Pd (a exemplo do PyPd), criar novas interfaces de interação, criar ferramentas para Live Coding (utilizando o Pd como máquina), criar projetos como o Reactable ou instalações como o The Champions, entre outras loucuras.

a especificação dessa relação interface/mensagens pode ser encontrada no seguinte endereço:

http://jeraman-lab.googlecode.com/files/dynamic%20pathing.zip

o código está dividido em 8 pastas distintas, cada uma abrangendo um aspecto diferente da interface, sendo essas:

• caixas – aborda todos os aspectos relativos a interação do usuário com os tipos básicos de caixas (objetos, números, symbols, mensagens e comentários), abrangendo ações como criar, editar, mover e deletar caixas;
• conexões – aborda os aspectos relativos a conexões entre caixas;
• gui – aborda todos os aspectos relativos a interação do usuário com os tas caixas de interface (bangs, toggles, sliders, etc), abrengendo ações como criar, interagir, alterar propriedades e etc;
• menus – entre as pastas 4 e 7 está descrita a troca de mensagens da interação do usuário com os menus da interface do Pd, sendo esses o File, Edit, Find e Media;
• subpatches – aborda como cria, interagir e remover subpatches dinamicamente, através de mensagens;

infelizmente o código não está tão bem organizado e parametrizado quando deveria, peço desculpas! no entanto, acredito que ele deva estar claro o suficiente pra entender a relação interface/mensagens…

qualquer sugestão, crítica, problema, dúvida, colaboração, será extremamente bem vinda!

muito obrigado a Jarbas Jácome e a Alexandre Porres (e seu Tutorial de Pure Data) pela ajuda! valeu galera!

e os estudos continuam!

LaboCA: a primeira experiência

a semana passada passou rápido: entre a segunda (22) e a sexta feira (26) rolou no Memorial Chico Science a primeira edição do LaboCA – o Laboratório de Computação e Artes. apesar dos imprevistos e da correria, a oficina foi muito legal, contando com a participação de pessoas de várias áreas diferentes (artistas plásticos, dançarinos, programadores, estudantes, VJ’s)…

pra quem não conhece, o LabOCA é um projeto de imersão e experimento em arte digital com o objetivo de ensinar e pesquisar sobre o uso da computação para fins artísticos. o projeto, concebido por mim, Jarbas Jácome e Ricardo Brazileiro, propicia o desenvolvimento de laboratórios nômades e tem como foco promover a tecnologia como linguagem criativa e como processo de desenvolvimento artístico.

durante os três primeiros dias, estudamos a lógica de programação, utilizando para isso o Processing, Arduíno e o Pure Data. a medida que os conceitos iam sendo explicados, os participantes iam experimentando in loco, colocando a mão na massa. tudo isso num clima informal e descontraído, no qual todos iam se ajudando e compartilhando seus conhecimentos específicos!

nos dois últimos dias, focamos em experimentar com as tecnologias aprendidas com o objetivo de produzir obras de caráter coletivo. nessa brincadeira, além de experimentações individuais, construímos alguns trabalhos bem interessantes! eis alguns vídeos:

além dos trabalhos e das novas amizades que fizemos, tivemos outras três surpresas interessantes: uma por conta do mestre Filipe Calegario, que apresentou o mágico Sketch-Your-World, outra com o Mineiro, que apresentou seu incrível Robo Livre (ambos construídos com Arduíno!), e a última com uma performance do dançarino Wolder Wallace, que gerou um stop motion muito legal (vídeo acima)! trabalhos simplesmente fuderosos!

bem… foi isso! já estamos mobilizando outras edições do evento… vamos esperar pra ver! praqueles que perderam esta edição, maiores informações podem ser encontradas no site:

olaboca.wordpress.com

ou ainda no flickr!

flickr.com/olaboca

abraços,