Uma das funcionalidades mais desejadas para o Zapt.In é uma integração maior com o Twitter. Claro que isto pode significar muitas coisas, mas para nós, estamos pensando em três categorias de integrações: a) integração com clientes do Twitter para que pessoas usando aplicativos como Twitterrifc, Tweetie, Echofon e outros possam utilizar o Zapt.In diretamente destes aplicativos; b) integração do site do Zapt.In com o Twitter para que seja mais simples compartilhar links do Zapt.In através do Twitter (como faz o Bit.Ly); e c) integração com o Twitter para monitorar quais os links mais tuitados e re-tuitados pelos usuários (como faz o Migre.Me).

Estou correndo para garantir que estas três categorias de integrações aconteçam, mas infelizmente, não tenho como fazê-las ao mesmo tempo e, no caso da integração com aplicativos, não tenho poder para fazê-la sozinho (preciso da colaboração dos seus respectivos desenvolvedores).

Mas o legal é que a integração do site do Zapt.In com o Twitter já foi concluída e está disponível para você. Ela utiliza a tecnologia OAuth (veja também a FAQ do Twitter sobre OAuth) e permite que você associe sua conta do Twitter a sua conta do Zapt.In, sem ter que fornecer seu login e senha do Twitter. OAuth é uma das maneiras mais seguras de integração de serviços na rede.

Bom, mas chega de “bla-bla-bla” e vamos ao que interessa: integrar sua conta do Zapt.In com o seu Twitter:

1. Encurte um LINK através do Zapt.In

Basta digitar uma URL ou usar nosso Bookmarklet.

2. Clique no botão “Compartilhar”

Para compartilhar um link pelo Twitter, basta clicar no botão “Compartilhar” de qualquer link que você vir no Zapt.in.

Se você ainda não tiver associado sua conta do Zapt.In à sua conta do Twitter, você verá a seguinte mensagem:

Clicando no link indicado, você será redirecionado para uma página do Twitter, onde poderá autorizar o Zapt.In a usá-lo em seu nome, de maneira segura.

3. Autorizando o Zapt.In a se conectar ao seu Twitter

Ao clicar no link, você será redirecionado para uma página do Twitter, onde você será questionado se deseja autorizar a associação da sua conta ao Zapt.In ou não. Clique no botão “Allow” (Permitir).

Verifique se a conta que você está associando ao Zapt.In é realmente a conta que você deseja autorizar. Se não for, clique na opção “Sign out” (Sair) e siga as instruções.

4. Pronto, agora é só compartilhar seus links

Quando você autorizar o Zapt.In a utilizar sua conta do Twitter, você será redirecionado de volta ao Zapt.In e estará pronto para compartilhar seus links diretamente, a partir do site do Zapt.In.

Quando sua conta estiver autorizada, ao clicar no botão “Compartilhar“, surgirá um pequeno formulário para escrever sua mensagem (tweet) e enviá-la através do Twitter.

Para sua comodidade, o link curto já estará dentro do campo da mensagem, mas você poderá customizá-la como quiser. Observe que existe um contador de quantos caracteres  ainda restam (lembrando que o máximo permitido pelo Twitter são 140 caracteres).

Com sua mensagem devidamente preparada, basta clicar no botão “Enviar Tweet“, que o tweet será enviado em seu nome. Veja um exemplo de como ficará a mensagem enviada através do Zapt.In:

É isto, boas tuitadas!!!

Olá, no último post falei de um novo projeto que coloquei no ar, o Zapt.In, um encurtador de URLs brazuca (sim, mais um, hehe). E nos últimos dias liberei algumas novas funcionalidades no Zapt.In. A mais interessante delas é a versão inicial da API de Desenvolvimento do Zapt.In. Mas o tema deste post não é a API, mas sim como colocar o Zapt.In para funcionar no Tweetie, um dos melhores clientes do Twitter para iPhone.

Bom, mas chega de bla bla bla e vamos ao que interessa…

1. Conseguindo sua Chave da API do Zapt.In

Para utilizar a API do Zapt.In, você precisa pegar sua chave da API. Para isto faça seu login no Zapt.In e clique na opção “Perfil” do menu de usuário. Na página com informações de seu perfil você verá sua Chave da API.

2. Agora abra o Tweetie em seu iPhone

Teta, basta clicar no ícone do Tweetie em seu springboard:

3. Configure o Tweetie para usar o Zapt.In

Na tela inicial do Tweetie (para escolhar qual conta você vai usar), clique no botão “Settings” (configurações):

Depois clique na opção “URL Shortening” (encurtamento de URLs):

Depois escolha a opção “Custom” (Customizado) para configurar o Zapt.In:

Agora é colocar a URL da API do Zapt.In no campo de customização. A URL deve ficar da seguinte forma:

http://zapt.in/api/links/shorten?version=1.0&login=SEU_LOGIN&key=SUA_CHAVE&longUrl=%@

Não se esqueça de substituir os valores SEU_LOGIN e SUA_CHAVE pelos valores de sua conta no Zapt.In!!

Depois de colocar a URL clique no botão “save” (salvar) e você estará pronto para usar o Tweetie com o Zapt.In.

3. Agora é só usar…

Digite sua mensagem com uma URL longa que você deseja encurtar. Depois clique no botãozinho que fica no campo da mensagem com a contagem de caracteres:

Agora é só clicar no botão “Shrink URLs” (Comprimir URLs) e as URLs longas de sua mensagem serão magicamente encurtadas pelo Zapt.In:

Eeeeba… agora só faltam dois zilhões de outras aplicações suportarem o Zapt.in!!! ;-)

Quase todo mundo já deve ter esbarrado (e se perguntado sobre o que são) umas URLs estranhas com domínios mais estranhos ainda, como por exemplo: bit.ly/7XC3Lo, migre.me/ck3k, tinyurl.com/yge8jzg, j.mp/7XC3Lo e zapt.in/k. A maior parte do mistério é esclarecida quando clicamos num link destes e somos redirecionados para um outro site. Tratam-se de URLs encurtadas através de algum serviço de encurtamento de URLs (Wikipedia: URL shortening).

Bom, mas pra que precisamos disto. Afinal os browsers evoluíram para aceitar URLs de tamanhos gigantescos (não existe um consenso quanto ao tamanho máximo de uma URL, mas elas podem passar dos milhares de caracteres na maioria dos browsers e web servers). Na realidade existem várias utilidades para estes encurtadores de URL como facilitar a digitação e a verbalização de URLs (é melhor usar/ditar/digitar uma dezena de caracteres do que milhares de caracteres), permitir que URLs grandes fossem compartilhadas em mensagens SMS (imagine passar a URL toda deste post numa mensagem de texto) ou até mesmo fazer o tracking de clicks/visualizações de um determinado link. Mas a coisa decolou mesmo foi com a popularização do Twitter, que permite apenas mensagem com no máximo 140 caracteres. Ou seja, qualquer caractere é valioso ao se compartilhar um link em um tweet. Fica claro que na hora de compartilhar aquele link do torrent do Ubuntu 9.10 no Twitter é melhor usar a URL encurtada http://zapt.in/m com apenas 16 caracteres do que a original http://releases.ubuntu.com/9.10/ubuntu-9.10-alternate-i386.iso.torrent com 70 (e olha que esta é relativamente curta).

Mas como funcionam os encurtadores (ou compressores) de URLs?

Bom, na prática (pelo que vi até o momento), nenhum “encurtador” de URL faz realmente a compressão da URL. Entendendo como compressão de dados a utilização de algoritmos como o Lempel-Ziv (LZW – utilizado no winzip, gzip, etc) ou o Run Length Encoding (RLE – utilizado em máquinas de fax).

O que eles fazem, em geral, é construir uma função bijetora que leva cada URL longa para uma URL ou chave menor (e vice-versa), tentando minimizar ao máximo o espaço necessário para esta nova URL ou chave. Existem variações quanto aos modelos de funções de mapeamento utilizadas (algumas não sendo de fato bijetoras) e também em como as URLs menores ou chaves são geradas.

Para a geração das chaves, muitas vezes se utiliza um hash único calculado aleatoriamente (para evitar que se possa prever as sequências) ou mesmo uma chave calculada através da transformação de um número sequêncial (cada URL encurtada incrementa a sequência) utilizando uma base de representação maior do que a decimal. A idéia é utilizar menos posições (caracteres) para representar o mesmo número (índice). Por exemplo:

Número 70015 (setenta mil e quinze) representado em diferentes bases numéricas:

• Base 2 (binária) : 10001000101111111 : 17 caracteres
• Base 8 (octal) : 210577 : 6 caracteres
• Base 10 (decimal) : 70000 : 5 caracteres
• Base 16 (hexa-decimal) : 1117f : 5 caracteres
• Base 32 : 24bv : 4 caracteres
• Base 62 : IDH : 3 caracteres

Observe que para representar o mesmo número, podemos entre 17 e 3 caracteres (somente com os exemplos de representações utilizados no exemplo).

Me parece que o Migre.Me utiliza Base 62 e um índice sequencial de URLs, já o Bit.Ly parece usar Base 62, mas com algum esquema de sequenciamento estranho (talvez ele use algum particionamento do espaço a partir da URL original).

Bom, depois de mapear a URL original para uma encurtada, e armazenar isto num banco de dados, o que o “encurtador de URLs” faz é redirecionar um visitante que segue a URL encurtada para a URL original. De preferência os serviços utilizam o redirecionamento do tipo permanente (HTTP 301 – Permanent Redirect), já que este tipo de redirecionamento preserva as características da página destino para fins de web crawling, SEO, rankings, etc. Digamos que ele é o tipo de redirecionamento mais amigável com os motores de busca.

O interessante é que entre receber a requisição na URL encurtada e redirecionar o visitante para a URL original, o encurtador pode capturar vários tipos de estatísticas para aquele link. Ele pode contar quantas vezes o link foi clicado, qual o tipo de browser que foi utilizado, etc. Isto torna os serviços ainda mais úteis, podendo ser utilizados para medir taxas de conversão de clicks, eficiência de campanhas online, concursos e outros.

Joia, mas agora vamos falar do Zapt.In…

Bom, a idéia do Zapt.In nasceu há alguns meses quando este tipo de serviço começou a explodir pela rede: o Brasil ainda não tinha um encurtador de URL decentes – Leia-se: o Jonny Ken ainda não havia criado o Migre.Me ;-), eu trocava várias ideias sobre as possibilidades de um serviço destes associado ao BlogBlogs e o LiveStream com Manoel Netto e eu acabei me esbarrado em alguns domínios interessantes (bem curtos) como foi o caso do ZAPT.IN. Acontece que o tempo passou, muita coisa aconteceu e nunca rolou de fazermos o tal encurtado.

Mas como para tudo chega a sua hora, neste feriado (última semana) aconteceu o alinhamento planetário perfeito: a Isabella passou a semana em Uberaba, as coisas estavam mais tranquilas no trabalho e, no final de semana prolongado, minha mãe e irmã vieram para Sampa e passaram grande parte dos dias caminhando pelos shoppings e ruas do centro (com a Isa que já havia retornado), deixando o viciado em codar (eu mesmo) livre para criar, hehe. Amo muito tudo isto!!!

Bom, ai foi a hora de arregaçar as mangas, abrir o TextMate e começar a codar. Com algumas boas horas de coding e pesquisa consegui colocar a primeira versão (bem tabajara, mas lembrando que ‘shipping is a feature‘) para rodar na plataforma de Cloud Computing da Heroku. Na realidade passei mais tempo estudando algumas coisas (algoritmos, Heroku, Git, etc) do que codando, mas na hora de mandar brasa no “POG” e escrever o Zapt.In a coisa andou bem rapidamente.

É isto, agora o Zapt.In está no ar em versão nem-alpha-ainda. Claro, cheio de bugs, sem logo, sem layout, com poucas funcionalidades e sem a menor preocupação, ainda, com escalabilidade. Mas um dia ele chegará lá, para isto preciso da ajuda de vocês (para usarem, testarem e enviarem suas ideias).

Tá, mas por que fazer MAIS UM encurtador de URLs?

Esta é uma boa pergunta. O Brasil já tem o Migre.Me e existe mais de uma centena de serviços parecidos por ai. Então por que?

Ué, porque é divertido! ;-) Porque serviços como o BlogBlogs e vários outros nasceram assim. Porque não?

É isto, depois escreverei alguns posts sobre os desafios, os perrengues e as aventuras de colocar mais uma aplicação no ar. HeyHo!!!!

Há duas semanas me deu uma vontade de voltar a brincar com hardware. Sei lá, um pouco de nostalgia dos meus tempos de criança em Araguari, desmontando tudo o que passava pela minha frente, e também dos laboratórios de eletrônica da UNICAMP. O que sei é que passei horas namorando os sites sobre o Arduino, uma plataforma de prototipagem eletrônica open-source, e resolvi brincar com ele também.

Fiz uma compra básica de várias bugingangas na SparkFun Electronics: dois Arduinos (sim, tenho certeza que queimarei coisas no meio do caminho), breadboards, leds, resistores, fonte de alimentação, cabos, fios, matrizes de leds, shield ethernet e alguns sensores. Tudo necessário para várias horas de diversão e vários projetos interessantes. Na realidade, tudo isto foi meu presente de aniversário antecipado (special thanks para a Dona Isabella).

Em três dias tudo já estava em minha casa. Apesar de ter sido apenas minha primeira experiência com a SparkFun, posso dizer que o serviço foi nota 10, tudo foi enviado com muita rapidez, muito bem embalado e sem nenhum problema no pedido (e olha que eram várias peças diferentes). Um aviso importante é verificar bem os impostos que você deverá pagar, pois trata-se de mercadoria importada (cuidado para não ter surpresas).

Bom, com todo o material em mãos, era hora de fazer o Hello World do Arduino. Chega a ser frustrante de tão simples. Instale o Arduino IDE em seu computador, conectando-o através de um cabo USB e carregue seu primeiro sketch (sketches são os programas do Arduino). O site oficial do Arduino é a melhor fonte de referências para você começar a experimentar com o Arduino (comece aqui). Se você quiser nem precisa usar componentes externos para o Hello World (Led Blinking). No pino 13 do Arduino já existe um LED na placa e você pode controlá-lo com o sketch.

Mas fazer um LED piscar é muito pouco para o Arduino e, por isto, resolvi fazer um projeto um pouco mais complexo. No novo projeto resolvi controlar um LED RGB e usar um display LCD para apresentar os valores de cada componente de cor (Red, Green e Blue) que o LED RGB estivesse apresentando.

Bom, basicamente conectei o display LCD seguindo as instruções do exemplo do site do Arduino (Liquid Crystal Library – Hello World), mas usando os pinos 12 e 13, ao invés dos pinos 11 e 12. Fiz isto para liberar o pino 11, que é um dos pinos PWM, que usaria para controlar um dos componentes de cor do LED RGB.

Depois conectei cada um dos componentes de cor do LED RGB aos pinos 9, 10 e 11 do Arduino (todos eles são saídas PWM). Ahh, e também coloquei resistores de 220ohms entre cada um dos componentes de cor do led e os pinos do Arduino, de acordo com o que vi no exemplo de entrada e saída analógica (Analog I/O – Fading).

Com o circuido devidamente montado, era hora de montar o programa – sketch – para que o Arduino fizesse o que eu queria. Fiz um programa bem simples, basicamente um loop que faria o LED RGB variar de cor correndo todo o espectro de cores. Para isto, usei uma função que gerava os valores RGB para uma determinada cor, a partir dos valores HSB (Hue, Saturation & Brightness). Encontrei esta função – HSBtoRGB – no fórum do site do Arduino. A cada iteração do loop, onde o valor de Hue varia entre 0 e 255, programei o Arduino para imprimir no display LCD duas linhas de informações: na primeira o valor do Hue, e na segunda os valores de RGB equivalentes.

O resultado foi o seguinte:

O código do Sketch está aqui:

/*
	Led RGB e Display LCD : HSB loop
 
	Makes an RGB led to loop on all colors and displays
	the RGB values into an LCD display. The color loop
	is achieved varying the Hue value from 0 to 255 and
	converting the HSB value into RGB values.
 
	The circuit:
		* LCD RS pin to digital pin 13
		* LCD Enable pin to digital pin 12
		* LCD D4 pin to digital pin 5
		* LCD D5 pin to digital pin 4
		* LCD D6 pin to digital pin 3
		* LCD D7 pin to digital pin 2
		* 10K resistor:
		* ends to +5V and ground
		* wiper to LCD VO pin (pin 3)
 
		* RGB Led Red pin to PWM pin 9
		* RGB Led Green pin to PWM pin 10
		* RGB Led Blue pin to PWM pin 11
		* RGB Led GND pin to GND
		* 220 resistors:
		* on each led's color pin
 
	Based on the Arduino Liquid Crystal tutorial and
	the HSBtoRGB function from Paul V. (Arduino Forum).
		* http://www.arduino.cc/en/Tutorial/LiquidCrystal
		* http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1235225449/13#13
 
	By Manoel Lemos
	http://manoellemos.com/category/arduino
*/
 
// include the library code:
#include 
 
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 5, 4, 3, 2);
 
int rPin = 9;    // Led Red pin connected to PWM pin 9
int gPin = 10;   // Led Green pin connected to PWM pin 10
int bPin = 11;   // Led Blue pin connected to PWM pin 11
unsigned int r, g, b; // RGB values from the HSBtoRGB function
char rS[5], gS[5], bS[5], hS[5]; // RGB & Hue values as strings
int hue; // Hue value
 
void setup() {
	// set up the Arduino pins as PWM
	pinMode(gPin, OUTPUT);
	pinMode(bPin, OUTPUT);
 
	// set up the LCD's number of rows and columns:
	lcd.begin(16, 2);
}
 
void loop() {
	for(int hue = 0; hue <= 255; hue = hue + 4){
 
		// calculate the RGB values for the current Hue value
		HSBToRGB( hue, 255, 255, &r, &g, &b ); 
 
		// set the RGB Led to the calculated RGB values
		analogWrite(rPin, r);
		analogWrite(gPin, g);
		analogWrite(bPin, b);
 
		// convert the RGB and Hue values to strings
		itoa(hue,hS,10);
		itoa((int) r, rS, 10);
		itoa((int) g, gS, 10);
		itoa((int) b, bS, 10);
 
		// print the data on the display
		lcd.setCursor(0,0);
		lcd.print("Hue: ");
		lcd.print(hS);
		lcd.print("               ");
		lcd.setCursor(0,1);
		lcd.print("RGB: ");
		lcd.print(rS);
		lcd.print(",");
		lcd.print(gS);
		lcd.print(",");
		lcd.print(bS);
		lcd.print("          ");
 
		// wait
		delay(50);
	}
}
 
void HSBToRGB( unsigned int inHue, unsigned int inSaturation, unsigned int inBrightness, unsigned int *oR, unsigned int *oG, unsigned int *oB )
{
	if( inSaturation == 0 )
	{
		// achromatic (grey)
		*oR = *oG = *oB = inBrightness;
	}
	else
	{
		unsigned int scaledHue = (inHue * 6);
		unsigned int sector = scaledHue >> 8; // sector 0 to 5 around the color wheel
		unsigned int offsetInSector = scaledHue - (sector << 8);	// position within the sector
		unsigned int p = (inBrightness * ( 255 - inSaturation )) >> 8;
		unsigned int q = (inBrightness * ( 255 - ((inSaturation * offsetInSector) >> 8) )) >> 8;
		unsigned int t = (inBrightness * ( 255 - ((inSaturation * ( 255 - offsetInSector )) >> 8) )) >> 8;
 
		switch( sector ) {
			case 0:
				*oR = inBrightness;
				*oG = t;
				*oB = p;
			break;
			case 1:
				*oR = q;
				*oG = inBrightness;
				*oB = p;
			break;
			case 2:
				*oR = p;
				*oG = inBrightness;
				*oB = t;
			break;
			case 3:
				*oR = p;
				*oG = q;
				*oB = inBrightness;
			break;
			case 4:
				*oR = t;
				*oG = p;
				*oB = inBrightness;
			break;
			default:		// case 5:
				*oR = inBrightness;
				*oG = p;
				*oB = q;
			break;
		}
	}
}

Pois é, eu tento, tento, mas não consigo me organizar e engajar para escrever algo decente aqui no blog. O pior é que tenho vontade de compartilhar um montão de experiências legais que tenho vivido nos últimos anos, mas quando tento encarar o Mars Edit para escrever algo, logo me deparo com novas idéias em minha cabeça e em minutos estou codando programando mais um pouco ou viajando em algum tipo de informação pela rede. Acaba que a nova idéia ou assunto de pesquisa fica tão excitante que o que eu antes cogitava escrever torna-se sem graça e enfadonho.

A coisa é até irônica. Às vezes me chamam para participar de algum evento como um “blogueiro de sucesso”. Um dia ao lado do Edney, outro ao lado da MariMoon e outro do Juliano Spyer. Chega a ser constrangedor, pois tenho que me apresentar já me desculpando por ser um “blogueiro mequetrefe”.

Mas no último feriado acho que a ironia chegou a seu limite máximo. Meu cunhado, um professor de direito, advogado, promotor, escritor, super inteligente, que se considera um “muggle” da Internet e que há até pouco tempo atrás (meses) tinha um desktop bem surrado em casa conectado à rede através de um modem de linha discada que não passava dos 33.6Kbps, me pediu para ajudá-lo a criar um blog. O Machado viu o BlogBlogs nascer, me escutou explicar o que eram os blogs e a blogosfera várias vezes e sempre achou tudo muito interessante, mas nunca me passou pela cabeça que ele iria, algum dia, criar um blog. Bom, mas ele insistiu, estava lá em casa com um notebook novinho, modem 3G e todo animado para começar o seu blog. Baixei o WordPress MU, instalei num de meus servidores, criei o blog e expliquei como se faz para criar um post e para aprovar comentários. É um blog engraçado, com template padrão do WordPress, sem links nos posts, mas já deu para ver que temos um novo blogueiro no pedaço. Se passaram apenas alguns dias e já temos no Blog do Machado mais posts que fui capaz de escrever em um ano ou mais.

Com isto concluo que não nasci para blogar, mas talvez para codar um pouco e ajudar outras pessoas mais talentosas a compartilharem suas idéias com o mundo através da Internet. Continuarei tentando, só que agora sem peso na consciência. HeyHo!!!

Teste da nova iPhone app do Wordpress. Close de um poste de iluminação do jardim de minha casa em Araguari.

“Para entender a Internet – Noções, práticas e desafios da comunicação em rede” é o resultado de um trabalho colaborativo organizado pelo Juliano Spyer (autor do livro Conectado) e com a participação de um incrível trupe de colaboradores. O livro foi lançado via Twitter no dia 17 de Março às 18 horas. O blog oficial conta com todos os capítulos na íntegra e também com os links para fazer o download do livro completo em PDF. Nele você encontra feras como Ronaldo Lemos, meu primo falando de Creative Commons, Luli Radfahrer animalizando sobre mobile, Cris Dias conceitualizando Whuffie e capital social e o próprio Juliano Spyer que escreveu sobre Web 2.0.

Tive a honra e a oportunidade de ser um dos colaboradores convidados pelo Juliano Spyer para fazer parte desta turma. Recebei uma mensagem pelo Twitter dizendo que ele queria falar comigo durante o Campus Party. Conversamos ali mesmo e fui convidado a escrever o capítulo sobre a conceito das “Metodologias Ágeis“, assunto que muito me interessa e que faz parte de meu dia-a-dia na WebCo e na Abril Digital. O legal de um livro todo construído através da Internet é a possibilidade de contar com a colaboração dos leitores sobre o conteúdo do mesmo. Logo que o blog oficial foi ao ar alguns leitores perceberam um erro num dos parágrafos finais de meu texto. Eles enviaram comentários através do próprio blog e já estamos coletando várias correções para soltar uma versão atualizada do PDF. Bingo!!! Ganhou a colaboração, a interação e a Internet. Ganhamos todos!!!

É isto, baixe o livro, interfira e ajude a torná-lo ainda melhor.

HeyHo!!!

Nesta semana liberamos a implementação da API do Twitter que desenvolvemos e utilizamos no mais novo projeto da Webco, a Tuitersfera. Liberamos a API no GitHub com o nome de Tuiter (isto mesmo, Tuiter com TU, bem abrasileirado). Neste post farei um pequeno tutorial de introducão ao uso da Gem Tuiter para integrar sua aplicação com o Twitter.

Instalando a gema Tuiter

Se você ainda não adicionou o GitHub às suas fontes de gemas, execute o comando abaixo. Se já fez isto, pule este passo e vá direto para o comando seguinte para a instalação da gema.

1

% gem sources -a http://gems.github.com

Instalando a gema em seu computador:

1

% sudo gem install webco-tuiter

Testando a instalação

Para testar a instalação, basta você abrir o interpretador Ruby e executar os comandos abaixo. Utilize seu usuário do Twitter e sua senha na chamada que instancia a classe cliente da API. Se tudo der certo, o código deve apresentar a sua descrição (de seu perfil) no Twitter.

1
2
3
4
5
6
7
8

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
voce = cli.get_user("seu_login")
 
puts voce.description

Todos os métodos de manipulação da API estão na classe Client.

Atualizando seu status no Twitter

Para atualizar seu status no Twitter basta usar o método update() da classe Client. Veja:

1
2
3
4
5
6

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
cli.update("Olá mundo, estou no Twitter!!!")

Consultando seus @replies

Utilize o método get_replies() da classe Client. Este método trará os 20 últimos updates recebidos pelo usuário que você usou para inicializar a classe Client. Você pode pegar mais replies paginando os resultados, para isto basta passar o parâmetro page na chamada do método. O código abaixo mostrará seus 40 últimos replies:

1
2
3
4
5
6
7
8
9
10
11
12

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
replies = []
replies |= cli.get_replies
replies |= cli.get_replies(:page => 2)
 
replies.each do |reply|
  puts "From #{reply.user.screen_name} @ #{reply.created_at.to_s} : #{reply.text}"
end

Enviando uma mensagem direta (direct)

Utilize o método direct_new() da classe Client. Os parâmetros são o id ou o login do usuário para quem você deseja enviar a mensagem e a mensagem a ser enviada. Veja:

1
2
3
4
5
6

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
cli.direct_new("crisdias","olá cris, quanto vale um whuffie?")

Consultando dados de um usuário

Para isto você deve usar o método get_user da classe Client. O resultado é um objeto da classe ExtendedUser e ela contém métodos para consultar cada atributo de um usuário. Veja:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
edney = cli.get_user("interney")
 
puts edney.name  # Nome do usuário
puts edney.screen_name  # Login do usuário
puts edney.description  # Descrição do perfil do usuário
puts edney.url  # URL do perfil do usuário
puts edney.followers_count  # Quantidade de seguidores do usuário
puts edney.friends_count  # Quantidade de amigos (pessoas que ele segue) do usuário
puts edney.location  # Localização do perfil do usuário

Dicas finais

Existe um limite de utilização da API do Twitter para cada usuário. Este limite, normalmente, é de 100 requisições por hora. Então, cuidado para não estourar o limite, isto fará com que você não consiga interagir com o Twitter até acabar aquela hora. Este limite é chamado de Rate Limit e também pode ser consultado pela nossa implementação da API. Para isto utilize o método rate_limit da classe Client. O resultado é uma estrutura que traz dados sobre como anda seu limites de uso da API. Veja:

1
2
3
4
5
6
7
8

require 'rubygems'
require 'tuiter'
 
cli = Tuiter::Client.new(:username=>"seu_login", :password => "sua_senha")
 
cli.rate_limit
 
=> #<Tuiter::RateLimit:0x1802e3c @reset_window=2706.502303, @reset_time=Tue Mar 17 21:15:48 -0300 2009, @hourly_limit=100, @reset_time_in_seconds=Tue Mar 17 21:15:48 -0300 2009, @remaining_hits=84>

Observe que, no exemplo, ainda temos 84 requisições restantes (remaining_hits) até estourar o limite de uso da API na hora corrente. E ainda, a hora corrente acaba às 21:15 (reset_time) e ai teremos mais 100 requisições de limite.

A outra dica é consultar a documentação oficial da API do Twitter para entender melhor como ela funciona.

Colabore com nossa API

O projeto está hospedado no GitHub e qualquer um pode colaborar. Para entender melhor como isto pode acontecer, entre em contato com os desenvolvedores que estão cuidando dela (Luiz Rocha, Luis Cipriani e o Lucas Húngaro) através do email tuitersfera (arroba) webcointernet.com. Se você encontrar algum bug, tiver alguma sugestão ou desenvolver qualquer coisa legal com a API, também não deixe de avisar.

Boa Sorte e boas Tuitadas!!!

O Tuitersfera é um pequeno projeto que desenvolvi e lancei no começo de Fevereiro. Foram apenas alguns dias de trabalho com Ruby e Rails para montar um pequeno sistema interativo que integrava o Twitter com o Google Maps e que tinha o objetivo de mapear o uso do Twitter no Brasil.

A idéia era bem simples, bastava que os usuários do Twitter passassem a seguir o usuário @tuitersfera e, a partir dai, interagissem com ele através do website (http://tuitersfera.com.br) ou de mensagens diretas (directs) com comandos bem simples. Através destes comandos seria possível dizer para o Tuitersfera onde você vive, trabalha e também por onde você anda.

Em apenas 48 horas o Tuitersfera ultrapassou a marca de mais de 1000 usuários (seguidores). Infelizmente não tive tempo para continuar o desenvolvimento do projeto e ele acabou ficando meio largado. Mas isto já foi resolvido, três Jedis da WebCo (Luiz Rocha, Luis Cipriani e o Lucas Húngaro) adotaram o projeto e estarão trazendo várias novidades. O Tuitersfera deve se transformar numa plataforma interativa que oferecerá alguns serviços baseado no Twitter e também em outros serviços como o Google Maps. Claro, continuaremos com o propósito inicial de mapear o uso do Twitter do Brasil e também criar um ranking local dos tuiteiros de plantão.

Um sub-produto do projeto foi a implementação em Ruby de uma biblioteca que consome a API do Twitter. Fiz isto porque achei as outras implementações complicadas de usar ou incompletas. Eu e os novo pais adotivos do Tuitersfera resolvemos transformar esta biblioteca em uma gema (Ruby Gem) e liberá-la como um projeto Open Source. Em breve disponibilizaremos tudo no GitHub (isto deve acontecer nas próximas semanas).

Enquanto as novidades não chegam, você pode seguir o @tuitersfera e começar a interagir com ele. Para dizer onde você vive, basta enviar uma mensagem direta com o seguinte formato: moro em onde_você_vive

Você pode enviar seu endereço com a resolução que desejar, pode ser seu endereço completo, ou apenas a cidade onde você mora. O Tuitersfera se vira para entender o endereço. Veja alguns exemplos abaixo:

• moro em Avenida Paulista, 3333, São Paulo, SP, Brasil
• moro em Alamenda Santos, São Paulo, SP, Brasil
• moro em São Paulo, SP, Brasil

Bom, por enquanto é isto. Se você tiver dúvidas ou sugestões para o Tuitersfera, entre em contato com os pais adotivos do projeto.

E boas tuitadas!!!

Galeteiro, saleiro e pimenteiro do Nonno Ruggedo no Shopping Cidade Jardim.