Todos devem saber que o Twitter é um serviço de sistema de mensagem muito bacana, apesar de como lucrar com ele não ser assim tão óbvio, que limita mensagens a 140 caracteres e que é para a tecnologia o que os diamantes são em comparação ao carvão. O apelo do Twitter é que as mensagens são curtas e as pessoas realmente prestam atenção a elas. Duas sugestões gerais para começar:

• Não poste mensagens de 139 caracteres toda vez.
• Não envie 20 mensagens por dia.

Isso é importuno e o caminho certo para ser abandonado por seus seguidores.

O Twitter pode ser útil em uma configuração de negócios. Como qualquer serviço de sistema de mensagem (e-mail), ele pode ser usado para muitas finalidades. O uso do Twitter em negócios, no entanto, geralmente se concentra em mensagens do tipo "olá, sou eu", em vez do tipo "informações úteis".

Este artigo explora postagens do Twitter automatizadas e busca aquilo que faz sentido para um negócio, em vez de uma postagem de seres humanos para negócios. Este último não é assim tão interessante, tecnicamente (embora pudesse ser fascinante conectar uma I.A. que se passasse por humano e respondesse às postagens do Twitter).

Você já deve saber como instalar um módulo CPAN (especificamente, o Net::Twitter), mas este artigo é destinado para programadores Perl iniciantes.

Por fim, não uso o nome "tweets" para me referir às postagens do Twitter, exceto quando obrigado a fazer isso pela linguagem API. Desculpe se você gosta da palavra "tweets", mas acho que este artigo ficará mais claro se a evitarmos.

Chega de preâmbulos. Vamos começar a construir um aplicativo.

Qual é o objetivo?

Que tipo de informação será transmitida? Vamos imaginar uma empresa que usa Perl e não quer usar o Twitter porque ouviram falar dele nos noticiários; eles consideraram outras opções, levaram o Twitter a sério e analisaram cuidadosamente o que postar.

O nome da empresa é The Cultured Perl, Ltd. e eles criaram uma nova conta no Twitter em http://twitter.com/cultured_perl.

Imagine a euforia. O departamento jurídico autorizou e o Marketing está em burburinho. Você, como desenvolvedor líder, quer que as coisas sejam feitas, então decide testar apenas duas coisas no Twitter para ver como funciona, sem sequer se preocupar com todas as Grandes Questões.

Primeiro, você buscará no Twitter referências a "perl" e verá se as pessoas estão conversando alguma coisa interessante em relação ao Perl que poderia dar idéias de produtos para a empresa.

Segundo, você configurará postagens automatizadas para anúncios de contratação (você considerou brevemente postar anúncios de demissão, mas decidiu não fazer isso por ser muito deselegante).

Buscando palavras-chave no Twitter

O Twitter, como serviço, é fácil de usar. A empresa que administra o Twitter tem que se preocupar com todos os detalhes—utilização do servidor, notas da rede, discos rígidos inativos, e assim por diante. Você simplesmente abre uma conexão TCP/IP, faz uma pergunta e obtém uma resposta. Essa é uma marca dos serviços baseados na Web que é bacana para os usuários, mas é bom ter em mente que uma busca de palavra-chave pode ser cara para o servidor, se você fizer isso repetidamente (especialmente se as palavras-chave variarem). Tente não sobrecarregar os servidores do Twitter com consultas automatizadas mais do que o absolutamente necessário.

O script twitter_do.pl fará uma busca no Twitter e uma postagem (twitter_do.pl é discutido na próxima seção e está disponível para Download a partir deste link). Observe que não é preciso uma senha para fazer a busca, mas é preciso postar.

O script twitter_do.pl usa Getopt::Long para obter argumentos da linha de comando, conforme resumido na função usage(). O script inclui uma tela de ajuda para que o usuário não tenha problemas em configurar as opções por si mesmo.

Observe também como ele usa uma opção --verbose, como cada opção possui um atalho e como a impressão detalhada de um resultado de busca mostra cadeias como (UNDEFINED), em vez de apenas omiti-las. Essas são pequenas coisas que tornam um usuário feliz mais cedo ou mais tarde.

Listagem 1. twitter_do.pl: Boa ajuda de uso

sub usage
{
 return <<EOHIPPUS

 $0 [OPTIONS] SEARCH1 [SEARCH2 ...]

Note that you can search without a valid login.

Options:
 --help or -h                    : this help
 --verbose or -v                 : print more verbose output
 --rpp=100 or -r 100             : 100 results per page
 --maxresults=100 or -n 100      : return at most 100 search matches
 --popularity or -y              : analyze user popularity for search results
 --post=NEWS or -o NEWS          : post on Twitter
 --username=NAME or -u NAME      : specify the Twitter username
 --passwordfile=FILE or -pf FILE : specify a file that contains
                                   the Twitter password
 --password=PASS or -p PASS      : specify the Twitter password
EOHIPPUS
}

Os resultados de busca do Twitter retornam em uma referência hash com uma contagem de página e outros campos, além dos próprios resultados de busca. Vamos pegar apenas os resultados, adicioná-los à lista completa de resultados e depois fazer uma outra busca (exibindo a próxima página de resultados), até que obtenhamos resultados suficientes (de acordo com a opção --maxresults) ou nenhum resultado. Os resultados já estão classificados por data, então os deixamos de lado.

Infelizmente, não podemos simplesmente contar o número de resultados, temos que passar por cada página, ocasionando inúmeros acessos do Twitter não desejados do termo buscado. É possível ajustar isso com a opção --rpp. Do mesmo modo, se obtivermos mais resultados que --maxresults:

Listagem 2. Buscando no Twitter por palavra-chave

sub do_search
{
 my $term = shift @_;

 my $page = 1;
 my @results;

 while (scalar @results < $opts{maxresults})
 {
  my $rset = $handle->search({query=>$term, page => $page, rpp => $opts{rpp} });
  print "Searching for $term (page $page)\n" if $opts{verbose};
  if (ref $rset eq 'HASH' && exists $rset->{results})
  {
   # break out if no results came back
   last unless @{$rset->{results}};
   push @results, @{$rset->{results}};
   printf "Now we have %d entries\n", scalar @results if $opts{verbose};
  }

  # go to the next page
  $page++;
 }

 print_post($_) foreach @results;
}

Listagem 3. Imprimindo correspondências de busca

sub print_post
{
 my $t = shift @_;

 printf("%s (on %s)\n\t%s\n", $t->{from_user}, $t->{created_at}, $t->{text});

 if ($opts{verbose})
 {
  foreach my $key (sort keys %$t)
  {
   my $v = $t->{$key};
   $v = '(UNDEFINED)' unless defined $v;
   print "...$key=$v\n";
  }
 }
}

Não há nada de interessante sobre a função print_post, então respire profundamente e relaxe. Torne-se um com o Universo. Ahhh! Agora vá beber alguma coisa forte, porque é hora de falar sobre postagem.

Postando no Twitter

Usaremos uma opção da linha de comando do arquivo de senha no script. É possível colocar a senha em um arquivo e especificá-lo com a opção -pf ou especificar a senha diretamente com -p. Em termos de segurança a primeira opção é melhor, mas a última é mais prática.

Listagem 4. Postando no Twitter: As opções de senha

if (exists $opts{passwordfile} && !exists $opts{password} )
{
 open PF, "<", $opts{passwordfile}
  or die "Couldn't open $opts{passwordfile}: $!";
 $opts{password} = <PF>;
 close PF;
 chomp $opts{password};
}

# require the password AND at least one search term OR a post
die usage()
 unless (defined $opts{password} && exists $opts{post}) || scalar @ARGV;

Inconvenientemente, senhas com espaços não funcionam. Fique com caracteres que são seguros em URLs (letras, números, traço, sublinhado: [A-Za-z0-9_-]).

Depois de postar, verificamos se a última postagem possui o mesmo texto que pretendíamos postar. Fácil, não é?

Listagem 5. Postando no Twitter: A verificação do texto

sub do_post
{
 my $post = shift @_;

 $post = '(UNDEFINED)' unless defined $post;
 my $ret = $handle->update({status => $post});
 warn "Could not post the update" unless defined $ret;
 if ($ret->{text} eq $post)
 {
  print "Successfully posted [$post].\n";
 }
 else
 {
  warn "Posted string [$ret->{text}] is different from given [$post]";
 }
}

Vincular o comando de postagem ao banco de dados de trabalhos da empresa é fácil: faça uma consulta SQL rápida (algo como SELECT desc,salary FROM jobs WHERE created > yesterday AND salary NOT NULL AND desc LIKE '%perl%' (desconsidere a pseudo-SQL) e os resultados podem ser alimentados diretamente no twitter_do.pl.

Analisando os resultados de busca do Twitter

A The Cultured Perl, Ltd. tem grande sucesso com sua nova estratégia centrada no Twitter. Eles contratam três pessoas e possuem 1.800 seguidores em dias—bom trabalho!

Mas mesmo assim, você sente esse desejo irritante de fazer mais. Você decide analisar os resultados de busca para avaliar a popularidade do Perl. Os critérios serão encontrar as primeiras 1.000 combinações de busca, encontrar os usuários que as postaram e medir a popularidade entre esses usuários. A popularidade será a metade do número de amigos mais o dobro do número de seguidores (embora a fórmula possa certamente ser ajustada, dependendo do objetivo) O peso desproporcional é devido ao fato de que é muito mais fácil seguir os outros do que ser seguido no Twitter.

Para fazer isso, use Net::Twitter::friends_ids() e Net::Twitter::followers_ids(). O gancho para medir a popularidade será na função um pouco chata print_post(), para tornar tudo um pouco mais interessante. A nova versão terá um hash de escopo definido, o que significa que somente a função pode acessar o hash diretamente e é contínua em toda chamada, então será um bom cache). Esse cache permitirá que a popularidade seja armazenada, para que esses métodos caros não tenham que ser chamados repetidamente.

A Listagem 6 mostra a nova versão do print_post(). As opções globais também tiveram que ser ajustadas para permitir uma alternância --popularity e o texto de uso foi ajustado.

Listagem 6. Análise fácil da popularidade do Twitter por termo de busca

{
 # this hash is scoped to the print_post function only
 my %popularity;

 sub print_post
 {
  my $t = shift @_;

  printf("%s (on %s)\n\t%s\n", $t->{from_user}, $t->{created_at}, $t->{text});

  if ($opts{verbose})
  {
   foreach my $key (sort keys %$t)
   {
    my $v = $t->{$key};
    $v = '(UNDEFINED)' unless defined $v;
    print "...$key=$v\n";
   }
  }

  if (exists $opts{popularity})
  {
   my $user = $t->{from_user};
   unless (exists $popularity{$user})
   {
    $popularity{$user} = scalar @{$handle->friends_ids($user)}/2 +
    		         2* scalar @{$handle->followers_ids($user)};
   }

   print "\n\tPOPULARITY for $user = $popularity{$user}\n";

   my $sum = 0;
   $sum += $_ foreach values %popularity;

   printf "\tAVERAGE POPULARITY = %.2f\n", $sum / scalar keys %popularity;
  }
 }
}

A média é calculada e impressa todas as vezes para simplificar, mas realmente não é difícil movê-la do loop. Execute com ./twitter_do.pl -n 10 -y perl e aumente para 1.000 quando tiver certeza de que é necessário.

Conclusão

Foram examinadas a postagem e a busca com o Twitter. Um exemplo completo de funcionamento de cada função foi demonstrado, agregado a um script único para simplificar a manipulação das opções e outros wrappers.

Finalmente, vimos como a conectividade do Twitter de um único usuário pode ser quantificada usando seus números de amigos e seguidores.

Há muitas maneiras possíveis de se usar o Twitter. Espero que este artigo tenha lhe dados algumas ideias e sugestões práticas, ilustradas pelo trabalho no código Perl. Verifique a documentação Net::Twitter e o wiki da API do Twitter para saber o que mais é possível fazer com esse serviço.

Sample script - twitter_do.zip - 2KB - Download

Fonte/Autor: Teodor Zlatanov - IBM