O Twitter é um bate-papo onde todos falam ao mesmo tempo. Uma conversação caótica, global, uma demonstração de que o ser humano produz tanto lixo virtual quanto real.

Os computadores são máquinas como outras quaisquer. Cada ciclo dessa máquina consome árvores, assim como cada revolução do motor de um carro consome combustível.

O motor de um automóvel expulsa inúmeros dejetos como efeito colateral da combustão. Da mesma forma, o processo de computação tem seus custos ao meio ambiente.

Não sou expert em meio ambiente, nem pretendo entrar nesse mérito. Como mero cidadão do mundo, tenho alguma consciência do custo e do benefício daquilo que faço em relação ao meio ambiente. Digamos que fecho a torneira quando não estou utilizando.

Derrame no Mar da WWW
A produção em massa de lixo cibernético é um problema que cresce exponencialmente, e cujo perigo para o meio ambiente cresce a cada dia. Este problema foi catalisado através de ferramentas da extirpe do Twitter que incentivam a produção de ruído virtual sem fim. Telefones, palmtops, tablets, notebooks e desktops, todos trabalhando em conjunto na maior produção de lixo cibernético já vista pela humanidade. Há apenas alguns anos, as pessoas necessitavam de algum conhecimento técnico para lançar conteúdo ao ciberespaço. Os blogs iniciaram a mudança, que culminou na criação do chamado “microblog” – o Twitter.

Com o Twitter, qualquer um lança um foguete(ou balão incendiário?) pro espaço contendo aquilo que estiver pensando na hora. Há alguns anos apenas cápsulas de conhecimento eram lançadas ao espaço, e grandes eventos marcavam a próxima decolagem da NASA. Hoje, qualquer coisa pode voar. E 99% das quais são inutilidades: retweets de retweets de follow friday e #prontofalei.

Observe um tópico nos trends do dia, e veja a velocidade com que os tweets desaparecem. Alguma pessoa, em algum lugar do mundo, produziu um barulho de menos de 140 caracteres; alguns poucos caracteres que transitaram por milhares de quilômetros de fibra ótica, chegando finalmente ao triturador central do Twitter para rápida digestão. Depois de digerido, transforma-se em mais uma garrafa plástica flutuando no mar de lixo virtual.

Ser humano algum é capaz de absorver sequer 0.001% da informação produzida em uma tela padrão do Twitter. O oposto é verdadeiro também. Quem possui 300 mil seguidores está espalhando seus problemas, complexos, preconceitos, opiniões, verdades e mentiras em ritmo de comício. São platéias permanentes no mundo virtual.

Tenho a visão de imbecís enfileirados no escuro. Apenas uma luz branca clareando seus rostos, revelando olhos atentos ao que um ídolo qualquer lhes transmite em tempo real. Pessoas que não tem um livro sequer em casa ouvem com toda atenção tudo que outro sujeito tem a dizer no Twitter.

Morríamos de medo da lavagem cerebral dos Nazistas, e quem diria! As pessoas se sujeitam naturalmente a tudo isso, sem precisar de ditadura, violência e abusos de autoridade. As massas se auto-imbecilizam com tanta facilidade, á se os fascistas soubessem disso há 70 anos!

Todos perdidos, no mesmo barco
Ninguém sabe como lidar com a avalanche de dados que o Twitter iniciou.

O Google tenta demonstrar calma, mas está visivelmente perdido com o Twitter. Cito o Google porque são a maior empresa de processamento de dados no mundo atual, mas a verdade é que o mundo todo busca uma forma de digerir todo esse barulho. E até o momento não há nada de útil proveniente desse esforço. O Twitter continua sendo apenas barulho.

A idéia do Google e da CIA é prever o futuro usando o ruído social produzido na WWW. Outros buscam prever o mercado de ações e direções futuras do mercado no ritmo da inutilidade na mídia social. No entanto, pesquisadores das diversas gigantes de TI parecem chegar ao mesmo lugar: todo mundo falando ao mesmo tempo não é produção em massa de informação, é apenas ruído branco.

Posso estar redondamente enganado, mas, na minha opinião, o Twitter é um derrame de detritos virtuais muito pior que o da British Petroleum no Golfo do México. Espero que essa realidade mude em breve.

(Agora deixem-me ir, que preciso lançar este post no Twitter e dar uma olhada nos twits oficiais do Google em busca de novidades de programação.)

Uma das bibliotecas C mais úteis já produzidas é a GLib. Trata-se de um aglomerado de utilidades para linguagem C que inclui utilidades para strings, gerenciamento de memória, utilitários para arrays, listas, enfim, pense em algo e a GLib tem.

Compilei a GLib no Mac, porém ela exigia uma versão diferente da libiconv. Baixo e compilo a libiconv, volto pra GLib e tudo funciona sem problemas.

Muitas luas depois, preciso do VirtualBox para rodar o Windows, pois há um certo banco aqui no Brasil cujo home-banking não funciona no Mac. Então descubro que o VirtualBox não funciona mais…. A interface gráfica não dá dicas de por que o ícone aparece e some rapidamente. Parece um crash durante a inicialização, e nessa hora o terminal é nosso amigo.

Através do terminal, vou até /Applications/VirtualBox.app/Contents/MacOS e rodo o aplicativo ./VirtualBox. Para minha surpresa, o VirtualBox reclama que não encontrou o símbolo _iconv na bibliotea /usr/lib/libiconv.2.dylib

Recompilo o libiconv para outra arquitetura, usando um configure diferente. Usei ./configure –prefix=/usr CFLAGS=’-arch i386′ (cuidado, não compile usando esta opção). Tentei também outras arquiteturas, como x86_64. A experiência com arch i386 foi um desastre completo, tudo parou de funcionar. Não tinha mais acesso ao terminal, pois nenhum shell funciona sem o libiconv incluindo /bin/ksh, /bin/zsh e /bin/csh – todos que acompanham o Mac OS X.

Pior, o make não funciona sem o libiconv….ou seja, não tinha como recompilar a fonte da libiconv novamente para x86_64 – A solução era baixar uma versão binária do libiconv…mas onde? Busquei por toda parte, mas a única que encontrei era para Power PC, não ia resolver. O site DarwinPorts tem links para download que não funcionam, não conseguí testar.

DVD do Mac OS X ao Resgate
O jeito foi usar o DVD de instalação do Mac OS X. Já que não tenho shell, preciso fazer tudo pelo Finder. Primeiro é preciso expor os arquivos ocultos. Depois, é só navegar até usr/lib no DVD e copiar libiconv.2.dylib para /usr/lib – e pronto! Esquecí a GLib por agora, o importante é ter o resto do sistema funcionando.

Quem chega ao Mac OS X passando por outros UNIX, Linux por exemplo, logo percebe que a Apple aparou todas as arestas de usabilidade deste tradicional sistema operacional. Uma das adequações para usabilidade do Mac é ocultar tudo aquilo que 99% dos usuários jamais utilizarão.

Enquadram-se nessa lista os arquivos de sistema, e diretórios tradicionais do UNIX : /usr /lib /bin e por aí vai. Nenhum desses arquivos estão visíveis no Finder, é preciso ativar essa função, então lá vai a dica de como fazer.

Abra um terminal, copie e cole o comando:


defaults write com.apple.Finder AppleShowAllFiles YES


Tecle ENTER.

Agora será necessário reinicar o Finder para a nova configuração ter efeito. Só que o Finder é o shell do sistema, então não dá para usar command + Q e reiniciar.

Reiniciando o Finder
Pressione e segure a tecla OPTION, clique e segure o botão do mouse clicado no ícone do Finder: aparecerá um menu contextual. Clique em “Relaunch”, ou “Reiniciar”. Isto não reiniciará sua máquina, apenas o Finder lerá novamente suas configurações e reiniciará, é quase transparente para o usuário.

E pronto! Visite algumas pastas no Finder, tudo estará à mostra.

O Google Wave vai deixar de ser desenvolvido ainda este ano. O sistema que deveria significar “o fim do email será incorporado a outros produtos da empresa.

Não sei, ao certo, o que dizer sobre o Wave. Nunca o utilizei e, desde o início, quando surgiu a opção, desabilitei o compartilhamento de dados entre Gmail e este sistema.

Nunca me cadastrei no Wave, me cadastraram sem me perguntar. Para muitos usuários, essa inclusão automática causou rejeição ao sistema. Para outros, o propósito do sistema não ficou claro o suficiente. O que foi o Wave, exatamente? Uma tentativa de eliminar o email, Yahoo! Messenger, MSN Messenger, e Twitter de uma vez só?

Foi uma tentativa ousada, mas talvez não tenha chegado na hora certa. O Google tem projetos excelentes em andamento, será apenas questão de tempo vermos onde vão incluir o código e as lições aprendidas com o Wave.

Leia mais…

Governos de ambos os países reclamam do tráfego criptografado entre aparelhos Blackberry. Segundo eles isso geraria um “problema de segurança” por ser mais trabalhoso monitorar as mensagens trocadas.

A má notícia para as vendas da empresa na região é boa propaganda da segurança do Blackberry.

Leia mais…

Surgiu hoje no Reddit a notícia de que basta acessar uma certa página utilizando o Mobile Safari para efetuar o jailbreak no seu iPhone. A matéria chamou a atenção de alguns comentaristas que, imediatamente, detectaram o potencial desta descoberta para vandalismo em larga escala.

Para quem não sabe, o jailbreak é um processo pelo qual o iPhone é desbloqueado para rodar aplicativos provenientes de outras fontes distintas do App Store da Apple. Não é a mesma coisa que desbloquear o aparelho para uso em outras operadoras telefônicas, é um desbloqueio de software para aplicativos, porém as implicações são semelhantes: não deixá-lo preso à Apple na hora de instalar aplicativos no iPhone.

O processo de jailbreak se dá através da alteração do firmware do telefone. Ou seja, o chip que contém o primeiro programa que o telefone roda ao ser ligado, que por sua vez carrega o resto do sistema para uso normal. No seu computador pessoal, o firmware é quase equivalente ao BIOS, porém tem função expandida no telefone, por carregar todo o sistema operacional e não só o código de bootstrap.

Quem tiver coragem, acesse o jailbreak aqui, no entanto esteje avisado: trata-se de um enorme furo de segurança em seu iPhone, e o código contido nesse jailbreak, caso funcione, pode realizar qualquer operação no seu telefone, inclusive acionar a câmera, o GPS, o microfone, efetuar chamadas, enviar SMS e por aí vai.

A função strtok acompanha todos os compiladores ANSI C, e serve para dividir uma string em diversas cadeias menores. Um exemplo seria separar os campos de um registro no formato “campo a:campo b:campo c”, uma linha de dados tendo colunas divididas pelo caractere “:”.

Existem diversos motivos para evitar esta função a qualquer custo. Tive problemas recentes com o strtok(), e decidí compartilhar aí pelo menos 3 razões para evitar strtok(). São os chamados “efeitos colaterais” de funções “legadas” da biblioteca C.

Lá vão, 3 motivos para você evitar strtok():

1) A função não é reentrante. Você a chama a primeira vez utilizando a cadeia de caracteres que deseja dividir, e as chamadas seguintes passando um ponteiro nulo. Se alguma outra parte de seu programa utilizar a função strtok, a sequência inicial será comprometida.

2) strtok() alter a cadeia de caracteres que está sendo dividida – sem te avisar. Este motivo justifica não utilizar strtok() em hipótese alguma.

3) A string de origem, sendo dividida, não pode ser constante, deve ser um bloco de memória alocado e que comporte as alterações que a função efetua na cadeia original.

Os dois seguintes trechos ilustram na prática estes 3 defeitos. Aliás, talvez este seja um post inútil, visto que você não deve usar strtok(). No entanto é um exemplo de função padrão mal implementada, presente em 100% das bibliotecas C do mundo, o que provavelmente representa praticamente 100% de todos os computadores em funcionamento no mundo hoje*.

Este programa gera um Bus Error ou Segmentation Fault, dependendo de sua implementação:

/*
 ============================================================================
 Name        : strtok.c
 Copyleft  : ZeFonseca.com
 Description : Demonstra efeitos colaterais de strtok()
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {

	char *tok = NULL;

        // temp é uma cadeia estatica, e o espaço alocado em memória tem
        // apenas os caracteres necessários para
        // armazenar todos os caracteres, mais um caractere nulo não visível na mesma
	char *temp = "name:address:telephone:email";
       // somamos um para acomodar o caractere nulo ao final da cadeia
	int dll = strlen(temp) + 1; 

	tok = (char*)calloc(dll, 1);

	if ( tok == NULL ) {
		fprintf(stderr, "Unable to allocate %u bytes for token.\n", dll);
		return EXIT_FAILURE;
	}

       // primeira chamada de strtok() gera Bus Error, o programa não passará daqui
	tok = strtok(temp, ":");
        // a linha acima ilustra os problemas descritos nos itens 2 e 3 acima
	printf("%s\n", tok);
	fflush(stdout);

	while ( (tok = strtok(NULL, ":")) !=  NULL ) {
                // strtok é chamada com um ponteiro nulo a partir da 2a chamada
                // assim vemos que, caso qualquer outra função
                // chame strtok() em outra thread
                // a proxima iteracao deste loop retornara um valor sem sentido
                // aqui ilustramos o ponto 1 dos problemas de strtok()
		printf("%s\n", tok);
		fflush(stdout);
	}

	return EXIT_SUCCESS;
}

Ao tentar manipular a string temp, strtok gera um Bus Error ou Segmentation Fault. O motivo da falha pode não ser óbvia de inicio: strtok() está tentando manipular a cadeia original, e não uma cópia dela! strtok() insere caracteres nulos nos locais onde encontra a divisão da cadeia procurada. A cadeia original não é uma área dinamicamente alocada, e sim uma área estática de memória. Quando strtok() tenta alterá-la, o sistema operacional encerra o processo.

A seguinte versão corrige este problema, alocando um espaço muito maior que o necessário e trabalhando com uma cópia da cadeia original. Como podemos perceber, este programa está longe de ser eficiente, terminamos com 3 cópias da mesma informação ao final do processo: a string original, uma cópia para trabalho, e as substrings contendo os trechos buscados, caso existam(somadas formam a cadeia original).

/*
 ============================================================================
 Name        : strtok2.c
 Copyleft  : ZeFonseca.com
 Description : Desvia de efeitos colaterais de strtok() criando um frankenstein
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STR_BUFF_SIZE 1024

int main(void) {
        // copiaremos a string para ca e dividiremos esta copia atraves de strtok()
	char *dataline  = NULL;
        // guardaremos a versao original para comparar posteriormente
	char *dataline2 = NULL;
	char *tok = NULL; // armazenara cada token obtido
	char *temp = "name:address:telephone:email"; // cadeia original para testes
        // comprimento da string + 1 para acomodar o byte nulo \0
	int dll = strlen(temp) + 1; 

	dataline = (char *)calloc(STR_BUFF_SIZE, 1);
	memcpy(dataline, temp, dll);

	dataline2 = (char *)malloc(STR_BUFF_SIZE);
	tok = (char*)calloc(STR_BUFF_SIZE, 1);

	if ( tok == NULL ) {
		fprintf(stderr, "Unable to allocate %u bytes for token.\n", dll);
		return EXIT_FAILURE;
	}

	memset(dataline2,0,dll);
	memcpy(dataline2, dataline, dll);

	printf("string 1 before: %s\n", dataline);
	printf("string 2 before: %s\n", dataline2);
        // strtok() nao causa Bus Error, pois dataline
        // tem espaço suficiente para acomodar
        // os efeitos colaterais de strtok()
	tok = strtok(dataline, ":"); 

	printf("%s\n", tok);
	fflush(stdout);

	while ( (tok = strtok(NULL, ":")) !=  NULL ) {
		printf("%s\n", tok);
		fflush(stdout);
	}

        // como strtok insere nulos na string,
        // este printf mostrara apenas o primeiro campo
	printf("string 1 after: %s\n", dataline);
        // a string original sera totalmente impressa
	printf("string 2 after: %s\n", dataline2); 

	return EXIT_SUCCESS;
}

Qual a alternativa? Diversos frameworks e bibliotecas fornecem alternativas seguras à strtok(). Procure evitar implementações da Microsoft(strtok_s) e outras variações como strtok_r. Em vez disso, use uma biblioteca bem implementada e bem testada como a glib.

* Praticamente todos os sistemas operacionais de ampla utilização são escritos em C e vão ligados à biblioteca padrão.

Segundo o presidente da Amazon.com, os livros digitais passarão os livros impressos em vendas até o final de 2011.

A afirmação afirmação foi feita em recente entrevista concedida à USA Today.

Bezos comenta, ainda, sobre inclusão de multimidia em livros digitais, fala do novo Kindle, recentemente lançado. Segundo ela, telas coloridas cansam para a leitura, e são difíceis de serem lidas ao ar livre, devido a reflexos. Afirma, também, que o consumo excessivo de baterias é um problema nas telas de cristal líquido.

Artigo traduzido via Google

Artigo original

Caso você administre um servidor Apache com dezenas ou centenas de Virtual Hosts, possivelmente já terá se deparado com picos de visitação que, normalmente, testam os limites do servidor. Caso possua apenas um site hospedado por servidor, esqueça o resto deste artigo. No entanto, na grande maioria dos ambientes de hospedagem, um servidor dedicado terá inúmeros hosts virtuais configurados, e é praticamente impossível saber, desconhecendo a origem do pico de visitação, qual é o responsável pela sobrecarga.

Para resolver este problema criei o seguinte script Perl que, combinado ao tcpdump, analisa o tráfego de rede atual, extraindo os cabeçalhos “Host:” e contando quantas vezes cada Host surge no tráfego capturado. Um handler do sinal SIGALRM imprime ao STDOUT as estatísticas atuais a cada 5 segundos, em ordem decrescente de demanda.

Assim, é possível ver, em tempo real, qual Virtual Host está gerando a maior demanda no servidor naquele instante.

Copie o seguinte script e salve como tcpd_host_filter.pl

#!/usr/bin/perl

# http://zefonseca.com/blogs/ze/

use strict;
use warnings;

our %hosts = ();
our $match_count = 0;

$SIG{ALRM} = \&dump_stats;

alarm(5);

while (<>) {
        if ( m{Host\:\s+(\S+)}gms ) {
                $hosts{$1}++;
                $match_count++;
        }
}

sub dump_stats {
        print "\n\nACTIVE HOSTS\n";
        foreach my $host ( reverse sort { $hosts{$a} <=> $hosts{$b} } keys %hosts ) {
                my $ratio = $hosts{$host} / $match_count;
                printf "%-5d %-32s %.2f %% \n", $hosts{$host}, $host, $ratio*100;
        }
        alarm(5);
}

Torne o script executavel:

chmod 755 tcpd_host_filter.pl

Agora rode o tcpdump com as opções -s 65535, que determina o tamanho máximo de captura, e -w – que escreve todo o conteúdo do pacote capturado à saída padrão.

tcpdump -s 65535 -w - | ./tcpd_host_filter.pl

O script lerá a captura em tempo real, no entanto só imprimirá as estatísticas a cada 5 segundos, para evitar uma inundação de dados na tela.

Exemplo de saída:

ACTIVE HOSTS
120   site1.com             30.61 %
116   site2.com                            29.59 %
74    zefonseca.com                    18.88 %
29    site3.com                        7.40 %
9     site4.com                 2.30 %
8     site5.com               2.04 %
7     site6.com                 1.79 %
7     site7.com                 1.79 %
[ ... ]

Talvez algum leitor se lembre de um programa chamado QBasic que acompanhava os últimos DOS? Corre o boato de que Bill Gates sempre foi apaixonado pela linguagem BASIC e, por este motivo, foi a linguagem adotada pela Microsoft para tantos de seus produtos(Visual Basic, VBA, VBScript, etc). Talvez seja pelo mesmo motivo que sempre houve um interpretador de BASIC embutido nos sistemas operacionais Microsoft. Desde o GW-BASIC dos IBM PC’s, passando pelo QBasic nos últimos DOS e o Windows Scripting Host nos Windows mais recentes.

Um dos programas de demonstração do BASIC, que costumavam acompanhar o DOS, era o GORILLAS.BAS – um jogo onde 2 primatas sobem em edifícios de uma cidade e travam uma guerra de bananas explosivas. Os jogadores devem inserir a velocidade e angulo de lançamento das bananas de acordo com a ventania no momento e, assim, tentar acertar o oponente.

O jogo, bastante simples, marcou uma época no mundo dos PC’s. A primeira versão, com direitos autorais da IBM, foi lançada em 1991. Logo mais, surgiram versões com efeitos especiais e mais variáveis, como a possibilidade de alterar a gravidade, ou de jogar com gorilas “atômicos” em um cenário esquisito.

Ao fim de Junho de 2009, sofrí um acidente e, não tendo nada melhor para fazer, preso à uma cama, decidí tentar reescrever o clássico Gorillas.BAS em Javascript. Mantive o máximo da originalidade, inclusive as cores dos prédios, janelas. O algoritmo do movimento da banana é baseado em meus experimentos com balística.

Portanto, fica aí para quem desejar lembrar do velho DOS: Jogue GORILLAS.JS – Versão de 2010 do clássico de 1991