E, sim, degradês, bordas arredondadas e letras grandes sem serifa fazem parte do layout

A interpretação de código é bem simples: o código FORTH é “compilado” para uma string contendo código Python; o Python, depois, compila esse código e cria uma função. Não é a maneira mais limpa e nem provavelmente a mais eficiente, mas funciona bem e foi a mais fácil de implementar.

Além disso, essa implementação permite fazer o disasm (para mnemônicos da Máquina Virtual do Python) de qualquer palavra, inclusive as “built-in”.

Não sei qual a utilidade prática de um negócio desses. Só sei que foi divertido escrevê-lo.

Exemplos e downloads estão disponíveis na página do projeto.

• o form factor semelhante (tudo bem que um Nokia inteiro cabe somente no espaço da tela do Apple)
• a idade do Newton, e a indisponibilidade de modelos novos (o hardware morre um dia)
• a plataforma dos Nokia ser aberta (e, portanto, passível de customização por parte dos usuários)

Eu não gosto da atual geração de Smart Phones. Como telefones, tudo bem: fazem o serviço muito bem. Fazem e recebem chamadas. Possuem agendas telefônicas (inclusive o o reconhecedor de cartões de visita do A1200 ganha meus parabéns). Permitem trocar SMS como qualquer outro telefone de “dérreal”. Mas não consigo pensar neles como PDAs.

Para mim, PDA não é apenas uma agenda eletrônica de compromissos e contatos. É preciso também ser bloco de anotações (ou um “caderno com calculadora gráfica programável”, mesmo, que é como uso meu Newton na universidade). E é esse o maior problema com máquinas atuais: não me sinto confortável em usá-las. A tela é pequena demais, a stylus é pequena demais. É, realmente, costume com o Newton, onde a única coisa pequena é a capacidade de armazenamento.

E, como as funcionalidades que eu sinto falta são apenas software, e software precisa de hardware para ser executado, a cada lançamento de um dispositivo similar fisicamente ao Newton, com plataforma aberta (ou com altas possibilidades de personalização), faz com que nós, Refugiados do MessagePad, consigamos ver uma luz no fim do túnel. E, dentre os gadgets que vi recentemente, os tablets da Nokia são os com maior capacidade para substituir meu Newton. Nem, que para isso, eu tenha que escrever todo o software para deixá-lo do jeito que estou acostumado a usar. E uma plataforma aberta só faz deixar meus sonhos mais próximos de serem realidade.

No HardInfo, um módulo consiste em:

• Uma lista de entradas (cada item da lista é mostrado como subitem da árvore na GUI; por exemplo, o módulo “Devices” tem as entradas “Processor”, “Memory”, “PCI Devices” e assim por diante)
• Cada entrada possui uma função de obtenção de informações e uma função de callback
  • As funções de callback apenas retornam o que foi encontrado, como uma string (usando o formato do GKeyFile da GLib). É garantido que essas funções só serão chamadas após as funções de obtenção
  • Já as funções de obtenção são as que vasculham o ambiente procurando as informações necessárias
• Uma lista de métodos exportados (módulos podem chamar métodos de outros módulos)
• Uma lista de dependências de módulos (por causa da chamada de métodos de outros módulos)
• Informações de versão, copyright, descrição, etc.

É bastante coisa, mas acredite: tudo necessário. Os módulos atuais, embora não estejam com o código mais limpo e simples de entender possíveis, são uma boa fonte de consulta para entender como essas coisas se encaixam.

De qualquer forma, ao incluir o cabeçalho “hardinfo.h”, algumas estruturas e funções serão prototipadas. A partir disso, pode-se começar a criar o módulo:

#include "hardinfo.h"

void   scan_entrada(gboolean reload);
gchar *callback_entrada();

static ModuleEntry entries[] = {
 { "Entrada", "entrada.png", callback_entrada, scan_entrada },
};

static gchar *__entrada = NULL;

void
scan_entrada(gboolean reload)
{
   SCAN_START();

   if (!__entrada) {
      entrada = g_strdup("[Entrada]n"
                         "Olá Mundo=n");
   } else {
      g_free(entrada);

      entrada = g_strdup("[Entrada]n"
                         "Refresh=:)n");
   }

   SCAN_END();
}

gchar *callback_entrada()
{
   return __entrada;
}

/*
 * Retorna a lista de módulos. Não é necessário informar o tamanho, pois isso
 * é calculado em runtime.
 */
ModuleEntry *
hi_module_get_entries(void)
{
    return entries;
}

/*
 * O nome do módulo (como será mostrado na interface). O ícone não precisa ser
 * especificado, pois ele é o nome do arquivo ".so", mas com a extensão ".png".
 */
gchar *
hi_module_get_name(void)
{
    return g_strdup("Módulo Exemplo");
}

/*
 * O peso. Usado para selecionar a ordem do módulo na interface. Quanto maior o
 * seu valor (0~255), mais para baixo ficará.
 */
guchar
hi_module_get_weight(void)
{
    return 160;
}

/*
 * Se houver necessidade de inicializar alguma variável do módulo (como criar
 * tabelas hash, listas ligadas, árvores, etc), faça isso aqui.
 */
void
hi_module_init(void)
{
    g_warning("Olá mundo!");
}

/*
 * Chamado quando o usuário pede informações sobre o módulo (Help -> About Modules ->
 * Nome do Módulo).
 */
ModuleAbout *
hi_module_get_about(void)
{
    static ModuleAbout ma[] = {
      {
          .author       = "Foobar da Silva",
          .description  = "Exemplo de módulo para o HardInfo",
          .version      = VERSION,
          .license      = "GNU GPL version 2"
      }
    }; 

    return ma;
}

Feito isso, é só compilar o módulo. A maneira mais fácil é colocar o módulo no diretório do HardInfo, editar o Makefile.in e adicionar o nome do arquivo na variável MODULES; e, após isso, rodar o configure novamente. Ao executar make, seu módulo será compilado também.

Agora é só instalar e executar o HardInfo. Seu módulo deve aparecer automagicamente. Tente apertar o botão “Refresh” para ver o que acontece. Monitore também a saída no console, para ver se o Warning é realmente mostrado lá (ou se foi mostrado em uma caixa de diálogo). De agora em diante, basta transformar este módulo em algo útil, obtendo informações sobre o hardware ou software básico. E, claro, não deixe de contribuí-lo: as chances dele ser distribuído em uma nova versão são bem grandes.

• Ícones do Projeto Tango
• Reorganização dos módulos

• Adição de benchmark de FPU
• Possibilidade de salvar os resultados do benchmark como imagem (com barras de porcentagem relativa)

• Possibilidade de copiar as informações para a área de transferência
• Escolha do formato do relatório (texto puro ou HTML)
• Módulos podem exportar métodos. Outros módulos podem chamá-los. Isso adicionou um pouco de complexidade no carregamento dos módulos, já que há verificação de dependências
• Bugfixes (todos os reportados por email e pelos bugtrackers do Ubuntu e Debian)
• Nova API de módulos (mais eficiente e madura que a anterior, embora incompatível)

Todas as novidades mencionadas aqui (e na página de coisas a fazer do projeto) estão disponíveis no repositório Subversion. Quem tiver a possibilidade de testar, por favor o faça.

• Terminei o quarto semestre na faculdade. Infelizmente não passei em uma matéria, mas fiquei surpreso de ter passado em Antropologia Teológica B (sim, todo curso da PUC é obrigado a ter esse negócio e eu fui muito mal nas provas e trabalhos… acho que gostaram do meu texto para ter passado com 6!). E outro fato bizarro: fiquei com 10 em paradigmas de linguagens de programação. Eu odeio Java (agora ainda mais, que conheci um pouco da linguagem e arquitetura), mas a matéria foi essa o semestre todo…
• Comprei algumas coisas para o meu arsenal de periféricos e servidores da rede daqui de casa:
• Multifuncional Epson CX4900. Scanner, impressora e copiadora. Funciona muito bem no Linux: o scanner funciona direto com o backend “epson” (e coloquei o saned para rodar, o que me permite escanear de qualquer computador da casa), a impressora funciona bem com o driver da CX4700 do Gutenprint (o driver proprietário é tão ruim que não permite selecionar a qualidade de impressão!), e a copiadora funciona sem estar ligada ao computador. O bizarro é que o negócio custou R$500 R$400 mas não veio com um mero cabo USB que custa R$2! Shame on you, Epson! Ainda bem que tinha um cabo perdido aqui em casa, de um hub USB 1.1 que nem usava mais…
• 

  PowerMac G3 Bege (Desktop). Configuração stock, de 266MHz, mas com 96MB de RAM. Vou usá-lo como novo servidor da rede. Como brincadeira, instalei o MacOS X 10.2 e usei por alguns dias. Reinstalei o MacOS 9 em seguida e agora coloquei Ubuntu Edgy nele. Funciona bem e pude testar algumas coisas do HardInfo em PowerPC. Fiz um leve overclock para 280MHz e devo aumentar a quantidade de RAM para 512MB logo logo.

• Finalmente coloquei um HD maior no condor. Agora posso, sem medo, usar o TorrentFlux para baixar coisas enquanto não estiver em casa. O HD não é novo, é o que estava no meu Pentium 3 e já estava sem uso há uns 2 anos. Coloquei numa dessas gavetas de HD, mas ela é meio barulhenta por causa da ventoinha diminuta. Comprei os componentes para montar um circuito que acione o ventilador automaticamente de acordo com a temperatura, mas só devo brincar com isso ano que vem. Circuito simples, só um amp-op, um NTC e meia dúzia de porcaria.
• Outras duas coisas que foram espetadas no condor são uma placa de rede de 100MBit (sim, eu ainda estava usando uma de 10MBit…) e uma placa USB 2.0 (para ligar a impressora).

• Comprei também uma bolsa para a câmera: Minha S5100 estava acomodada numa bolsa de couro (horrível para câmeras, mas eu lotei de potinhos de silica gel), mas ela é um bocado grande e desajeitada. Fora que alguns acessórios (como o carregador de baterias, filtros, pilhas extras, cabos, etc) tinham que ficar fora do estojo. Por R$50 acredito ter feito uma boa compra: é uma bolsa térmica com espaço suficiente para todos os acessórios que eu tenho.
• Fora isso, ganhei de amigo secreto a versão do Tim Burton do “Charlie and The Chocolate Factory”. Obrigado, Mariana!
• O box com Kill Bill 1 e 2 também estava em promoção no Submarino, e o arrematei junto com o filme “Jogos de Guerra”. Ainda bem que o Orkut serve para alguma coisa: aquela comunidade “Descontos na Internet” é uma das únicas coisas que prestam por lá…
• A versão 0.4.2 do HardInfo atrasou um pouco (um mês, talvez atrase mais um). Essa semana deve sair o RC3. Euquanto isso, as mudanças mais significativas da versão 0.4.1:
• Geração de relatórios sem precisar de GUI
• Escolha do formato do relatório (por enquanto somente Texto Puro e HTML, mas adicionar outros é trivial)
• Melhor visualização dos resultados dos benchmarks (com gráfico de barras e porcentagem relativa)

• Informações sobre baterias e mais tipos de sensores
• Suporte a SMP em x86 (ninguém quer doar um PowerPC ou Sparc dual para adicionar suporte à SMP no HardInfo? )
• Maior estabilidade
• Brinquei um pouco com uma lente olho de peixe que comprei (na verdade é um Olho Mágico que achei numa loja de R$1,99). A lente tem uma qualidade péssima como era de se esperar, mas consegui me divertir bastante. Comprei a lente para colocá-la na minha WebCam e monitorar todo meu quarto remotamente.
• Mandei duas propostas de palestras para o FISL. Vamos ver se consigo patrocínio para viajar para POA dessa vez. Pelo menos carona e guia turístico já consegui (olá Carol! )…
• Meu irmão conseguiu um Playstation 2. Retiro o que disse sobre o console: alguns jogos são muito bons, como Kingdom Hearts, God of War e Prince of Persia (saudades de quando jogava isso no XT…). Testei rapidamente o SNES Station (emulecador de SNES para PS2), e fiquei impressionado. Muito fácil de gerar o disco e rodou praticamente qualquer coisa (yay!). Só falta brincar agora com esses reprodutores de mídia, para tocar vídeos via rede. Aí não assisto anime em tela de 17″ nunca mais!
• E por último, mas não menos importante: quando já estava pronto para apagar minha conta no Orkut, conheci pessoas novas que me fizeram reconsiderar a idéia. Saudações, Luma e Iana!

Não é por nada que fiquei animado a fechar todos os bugs, adicionar novas funcionalidades e preparar tudo para a próxima versão, provavelmente a ser finalizada no final de novembro.