Curso gratuito de Ruby para Twitter

Agora no Portal RubyLearning: curso gratuito utilização de Twitter com Ruby.

Tweet

Topicos:

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

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

Movendo uma imagem usando Haskell e wxHaskell

Há pouco mais de um ano, quando eu estava cursando a cadeira de Linguagens de Programação Funcionais, tive o prazer de começar a utilizar interfaces gráficas em Haskell, linguagem utilizada pela disciplina. Dentre os vários toolkits gráficos disponíveis, o que nos foi apresentado foi o wxHaskell, na verdade um binding para o kit gráfico multi-plataforma/linguagem wxWidgets.

Tivemos vários problemas com o desenvolvimento:

• o desenvolvimento gráfico para esse binding era exclusivamente textual, logo não há a possibilidade de modelar visualmente(pelo menos que nós conhecêssemos);
• nossos prazos eram curtos, dado que a parte gráfica só foi nos ensinada no final da disciplina;
• boa parte do que tentávamos fazer levava um bom tempo para ser estudado e descoberto como ser feito;
• nossa equipe tinha poucas possibilidades de reunião, se resumindo a através de chat, geralmente;

Mas isso não é o foco deste post. No final das contas, o projeto foi feito.

wxHaskell

Enquanto produzia, para prototipar o que eu poderia usar do toolkit, comecei a fazer brincadeiras. Uma delas seria fazer algo que poderia se tornar um jogo: movimentar uma imagem na tela. A imagem poderia ser um personagem, em um hipotético jogo. =)

Alguns passos fazem-se necessários. É necessário o GHC instalado, e o a biblioteca wxHaskell. Utilizei-nos no Windows, e tive inclusive que utilizar uma versão desatualizada do GHC para tornar possível a execução. Nunca mais o executei, e futuramente posso colocar uma descrição detalhada de como instalar tudo necessário. =)

Como foi feito? Explicando em alguns passos:
1) Importação dos módulos necessários:

import Graphics.UI.Wx
import Graphics.UI.Wxcore

2) Define-se um jogador, o qual encapsula a imagem a ser impressa e uma posição(um ponto na tela):

data Player = Player FilePath Point String

O tipo FilePath é um apelido para o tipo String, não se diferencia em nada de um pedaço de texto, representando um caminho nos arquivos para algo, que no nosso caso será a imagem. Point é um TAD que encapsula dois números – Integers, se não me engano – e faz parte da biblioteca do wx mesmo. A String final é apenas uma representação do nome do jogador. =)
3) Define-se a função principal, a que executará o programa através da interface gráfica. Aqui a chamaremos de gui:

gui = do

esta função é um Monad, ou seja, ela encapsula comportamento imperativo no paradigma funcional da linguagem. A partir da diretiva do o comportamento será similar a código imperativo, onde as chamadas a funções estarão separadas por quebras de linhas, de maneira ordenada. Claro, permanece a necessidade de organização de código através de indentação. Prosseguindo:

gui = do
	jog <- varCreate (Player "testFace.gif" (Point 0 0) "joao")
	j <- frameFixed [
		clientSize := Size 300 200,
		text := "teste jogo",
		picture :=	"face.ico",
		on paint := (\dc rect -> do
			x <- varGet jog
			printPlayer x dc
			return ()
			)
	]

Temos no código acima a criação de uma variável, jog, a qual representará um jogador(o tipo abstrato Player, mostrado acima). Passamos na criação a String “testFace.gif”, que é o nome do arquivo que coloquei na mesma pasta que o programa. O ponto passado como ponto inicial foi (Point 0 0), o ponto mínimo de exibição.

testeFace.gif!

Na linha seguinte, definimos j, o qual será um Frame de tamanho fixo, com o uso da função frameFixed, onde passamos a lista de argumentos. Widgets em wxHaskell seguem geralmente esta forma, uma função relacionada que recebe uma lista de argumentos, onde outros podem ser configurados posteriormente. No caso, definimos o tamanho utilizável da janela em clientSize(com o TAD Size, que funciona recebendo dimensões de largura e altura), o texto da barra da janela em text, o ícone da janela em picture, a função que será chamada no momento da “pintura” do widget na tela, em on paint. A função, que declaramos on the fly através de uma expressão lambda, recebe um contexto de dispositivo(dc – device context), que neste caso é a janela, e um retângulo(rect), que especifica as coordenadas da área de visualização. Passaremos o dc como segundo argumento para a função de impressão, printPlayer. O primeiro argumento que passamos é o Player da variável jog, através da constante x, inicializada em:

x <- varGet jog 

A função printPlayer pode ser descrita no código como:

printPlayer :: Player->DC a->IO ()
printPlayer (Player a b c) dc = do
	im <- bitmapCreateFromFile a
	drawBitmap dc im b True []

ou seja, recebe o Player e o Device Context, e utiliza a função de criação de bitmap a partir de um caminho, bitmapCreateFromFile, e a função de desenho de bitmaps, drawBitmap, ambas últimas da própria API de WxHaskell. Temos a criação do bitmap im, que é impresso no dispositivo dc, nas cordenadas indicadas pelo ponto b, com o modo de transparência especificado(True). A lista vazia que está como último argumento são as propriedades, as quais não cheguei a utilizar(e descobrir utilidade).
Continuando no código da função gui, após a criação do FrameFixed j, configuramos alguns eventos para ele. Acredito que seja um padrão de codificação configurar os eventos fora da lista principal de atributos. Escolhi só deixar o on paint por ter caráter intrínsico ao frame, diferente dos que criaremos agora:

	set j [
		on downKey := (do
			varUpdate jog desce
			repaint j
			return ();
			),
		on upKey := (do
			varUpdate jog sobe
			repaint j
			return ();
			),
		on rightKey := (do
			varUpdate jog direita
			repaint j
			return ();
			),
		on leftKey := (do
			varUpdate jog esquerda
			repaint j
			return ();
			)
		]

os eventos configurados acima servem para movimentar a imagem a partir das setas do teclado. WxHaskell já utiliza eventos para as 4 teclas direcionais, listadas acima(ex: on rightKey, onde rightKey é o evento de apertar a seta para a direita). O que acontece a cada evento: é chamada a função varUpdate, da própria API de WxHaskell, a qual é uma função polimórfica. Se não me engano, sua assinatura é a seguinte:

varUpdate::a->(a->a)->IO ()

ou seja, recebe um argumento do tipo a, e uma função que também recebe um argumento deste tipo e retorna outro do tipo a, e finalmente retorna um IO (). Após a chamada de varUpdate, temos a chamada da função repaint, tomando como argumento o frameFixed j. O que esta função faz é disparar o evento de pintura(paint) do argumento, já descrito acima.
Mas o que as funções passadas como argumento para varUpdate – esquerda, direita, sobe e desce – fazem? Vejamos uma delas:

sobe :: Player->Player
sobe (Player a (Point x y) c) = if y==0 then (Player a (Point x y) c)
				else Player a (Point x (y-k)) c

sobe recebe um argumento do tipo Player e retorna o mesmo tipo. A lógica desta função consiste em checar se a posição do jogador já atingiu o topo da janela(quando y é igual a 0), e caso contrário retornar um Player com o valor de y reduzido em k, onde k é uma constante de movimentação, indicando quantos pixels serão saltados. O espaço percorrido por unidade de tempo – ou seja, por disparamento do evento – definirá a velocidade do personagem, sendo seus valores diretamente proporcionais. No meu caso, utilizei:

k::Int --Constante de movimentação
k = 10

As outras funções seguem lógica idêntica, sendo somente necessário checar por colisão do Player com as bordas de j, por isso não as colocarei por extenso aqui. Portanto, a partir de cada evento configurado (o pressionar das setas direcionais) temos uma atualização configurada para a variável jog, e portanto a imagem se comportará da maneira apropriada. Poderíamos brincar um pouco com isso também, fazendo alterações de imagens a partir de determinadas situações, que poderiam ser cláusulas if-then-else nas funções de atualização. Basta usar a criatividade.
Após isso, basta compilar o código e voilá!, você tem uma imagem se movimentando pela sua tela. =)

Comentários de aperfeiçoamentos e hacks a partir disto são bem-vindos! Breve, quem sabe, coloco aqui algo com GTK2Haskell!

Coisas divertidas em Python (2) – tocando sons

Como prometido aqui, colocando algo que eu estava vendo há algumas semanas atrás, bem interessante e, por enquanto, fácil de mexer: Manipulação de sons com Pygame.

Pygame

Uma explicação antes: Pygame é uma biblioteca para produção de jogos em Python. Oferece suporte a sons, gráficos 2D e 3D, entre várias coisas necessárias à produção de jogos. Aqui eu estou mostrando só como utilizá-la para tocar e manipular sons.

Para começar, é necessário importar o módulo pygame e inicializá-lo.

import pygame
pygame.init()

Manipulação mais simples: usa-se a classe Sound.

from pygame.mixer import Sound
audio = pygame.mixer.Sound(caminhoArquivo)

onde caminhoArquivo é uma String contendo o caminho relativo até o arquivo de som, ou o caminho absoluto no sistema. Pygame por padrão suporta extensões .wav e .ogg, ao menos na versão testada(Linux). Chega a ser estupidamente fácil a maneira como você manda tocá-lo:

audio.play()

onde o método play também pode receber um argumento da quantidade de vezes que toca novamente, e outro do tempo destinado a tocar. No caso maior, a interface dele fica algo como play(numeroDeRepetições,duração). Pode-se fazer um som tocar uma quantidade infinita de vezes passando o argumento como -1.
Vários canais de som também estão disponíveis, e você pode tocar vários sons simultaneamente. Por exemplo:

musica = Sound(musica1)
som = Sound(som1)
v = True

musica.play(-1)
while(True):
    if v:
        som.play()
    v = not v

O exemplo é meio absurdo, já que eternamente ocorreria o laço e não haveria pausa alguma. Porém a idéia principal é que toda vez que v for verdadeiro, será tocado o som. Enquanto tudo acontece, a musica continuará tocando normalmente.

Manipulação aprimorada: usaremos agora o tipo sndarray.

import pygame.mixer.sndarray
from pygame.mixer.sndarray import *

arraySom = array(musica)

Agora você tem um array contendo todas as amostras de byte do som. Isso é um array BEM grande. Por exemplo, se o som tiver uma taxa de amostragem de 11000Hz, temos 11000 amostras por segundo. Logo, o tamanho do array é de 11000 * tamanho do som em segundos. Você pode testar isso manipulando este array, como no exemplo abaixo:

novoArray = arraySom[0:33000]

Considerando que temos um som com amostragem de 11000Hz, temos agora um novoArray com o equivalente a 3 segundos de amostragem(≈1/11000 segundo). Para tocar, podemos converter de volta para Sound.

novoSom = sndarray.make_sound(novoArray)
novoSom.play()

Pronto, agora você tocará aproximadamente 3 segundos do objeto musica original, do tipo Sound, uma representação do arquivo de som original passado como argumento.

Canais de reprodução
Há também maneiras para controlar os canais que são utilizados. O método play da classe Sound retorna um objeto de tipo Channel. Com ele, você pode controlar algumas coisas como volume de audio, inclusive para cada saída de som. Como funciona: a classe Channel possui um método setVolume, o qual recebe uma tupla numérica, onde os argumentos vão de 0 a 1(argumentos maiores que 1 funcionam como 1, até onde testei).

volume = 0.3, 0.7
canal = musica.play()
canal.setVolume(volume)

Você pode ouvir agora a saída da esquerda com som menor que a da direita, e nenhuma das duas com o volume máximo.
Canais de reprodução são alocados automaticamente pelo sistema, e possuem um numero limitado. Você pode aumentar a quantidade de canais, usando-se do método set…, e alocar explicitamente o canal que você deseja para o toque do som, utilizando-se do seguinte formato:

valor_desejado = 10
pygame.mixer.set_num_channels(valor_desejado) #você tem agora 10 canais disponíveis.

pygame.mixer.set_reserved(1) #você reservou um canal. Agora pygame não alocará automaticamente nada no canal 0.
canal = pygame.mixer.Channel(0) #atribuiu seu canal reservado à variável canal

canal.play(musica) #tocará o som musica no canal reservado.

Com tudo isso você pode editar seus sons, fazê-los tocar da maneira que deseja, simular sons vindos de diferentes posições(Stereo Panning, brincando com os volumes das caixas), ou seja, tem um arsenal pra manipulações sonoras bastante potente. Tudo graças a uma biblioteca de jogos. =)

Boa parte desse código foi testado em uma instalação do pygame, usando de Python versão 2.6. Talvez não haja disponível versão para a nova versão 3.0. Talvez haja algum erro, mas prometo revisar isso depois. =)

Novo livro sobre Haskell

Real World Haskell

Há um novo livro disponível sobre Haskell: a O’Reilly acabou de lançar, em novembro, o livro Real World Haskell. Para melhorar, o conteúdo está disponível livremente para leitura!

Até onde olhei (pouco mais do que o índice) parece um livro bom. Em geral acho os livros da O’Reilly muito bons, e tenho alguns deles. Este, como o título indica, tem um aspecto bastante prático, e é interessante como lida com vários pontos da linguagem comumente não vistos ao se explicar o paradigma: programação para banco de dados, redes, GUIs, paralelismo e concorrência(algo que aparentemente está em alta para programação funcional atualmente).

No mais, parece bem interessante para ser lido para iniciantes ou para quem deseje melhorar seus conhecimentos práticos sobre Haskell. Mais um livro para o recesso Dezembro – Janeiro!

Página do livro: http://book.realworldhaskell.org/
Encontrado na página inicial de Haskell.

Coisas divertidas(?) em Python

Python powered

Algumas coisas divertidas de se fazer em Python:

• Abrir uma página web em um browser
  Para se fazer isso, pode ser usado, diretamente da biblioteca padrão, o módulo webbrowser:

  import webbrowser
  
  webbrowser.open("http://frsoares.wordpress.com")
  

  O módulo suporta vários browsers no Unix e no Windows utiliza o padrão.

• Listar um diretório e mudar um diretório, entre outros
  O módulo os oferece dezenas de funções para manipular o sistema operacional, de maneira independente de sistema.

  import os
  
  os.listdir(".") #lista o diretorio atual
  
  os.chdir("..") #muda de diretório para o abaixo na árvore do sistema
  
  #entre outros
  

• Serializar objetos com o cPickle
  Qualquer coisa em Python pode ser transformada para texto ou mandada de volta usando o módulo pickle ou cPickle. Ambos são equivalentes.

  import cPickle
  
  dic = {'oi':12, 'tchau':13}
  arq = open('arquivo.txt','w')
  
  #insere-se itens
  cPickle.dump(dic,arq)
  cPickle.dump('algo',arq)
  arq.close()
  
  #recupera-se itens
  arq2 = open('arquivo.txt','r')
  print cPickle.load(arq2)
  print cPickle.load(arq2)
  arq2.close()

updates a serem adicionados (quando eu lembrar de algo)….