Gerador de Markov

Um dos sites mais úteis que existem é o Gerador de Lero-lero. Não tenho certeza se o algoritmo usado é um Gerador de Markov mesmo, mas se não for, a idéia é bem parecida.

Gerador de Markov é um programa que analisa um texto procurando as combinações de palavras mais comuns e então gera um texto usando as mesmas combinações em um texto que é estatisticamente similar ao anterior. Como essa análise será feita depende da implementação. Eu escolhi usar combinações de 3 palavras, ou seja, uma palavra do texto gerado depende das duas anteriores a ela. Variando a quantidade de palavras usadas em cada combinação, altera-se o texto resultante: se eu escolhesse combinações de uma palavra, o texto gerado seria completamente aleatório, se eu escolhesse combinações de dez palavras, o texto resultante ficaria mais parecido com o original.

A implementação de um Gerador é relativamente simples, clique em “Ler o resto do artigo” para ter acesso ao código em Common Lisp. O código está bem dividido e cada função tem uma função clara (evidentemente).

Primeiramente, criamos uma hash-table que conterá as combinações de palavras. Usamos uma hash-table por ela ser mais eficiente. Se usássemos listas ou árvores, teríamos de fazer buscas toda vez que o Gerador fosse adicionar uma nova palavra ao texto. Logo no começo também, inicializamos o gerador de números aleatórios.

Para que possamos analisar as combinações de palavras, precisamos primeiro dividir a string em uma lista de strings. A função “space-position” se ocupa de descobrir onde fica o próximo “divisor de palavras”, ou seja, um espaço, um tab ou uma quebra de linha. O que vier antes será o delimitador. Se houver vários espaços em sequência, nós teríamos uma lista com algumas strings vazias, mas o “cond” na função “split-string” detecta isso com “(= pos 0)” e evita que isso aconteça.

Logo em seguida vem algumas funções auxiliares. “Last-two” retorna os dois últimos elementos de uma lista qualquer. Precisaremos dela mais tarde. “Random-elt” e “random-key” retornam um elemento aleatório de uma lista e uma chave aleatória de uma hash-table respectivamente. “List-triples” retorna os trios que podem ser formados de uma lista. Note que ela não gera todos os arranjos possíveis, apenas as combinações sequenciais. Imagine que existe um bloco com espaço para três “coisas”. Esse bloco percorre a lista sequencialmente gerando os trios. Assim, a lista ‘(1 2 3 4 5) seria percorrida como: ‘((1 2 3) 4 5), ‘(1 (2 3 4) 5) e ‘(1 2 (3 4 5)). Portanto, (list->triples ‘(1 2 3 4 5)) retornaria ‘((1 2 3) (2 3 4) (3 4 5)). “String->symbol” retorna um símbolo com o mesmo nome que o conteúdo da string passada como argumento. Não me pergunte porque eu preferi usar símbolos ao invés de strings mesmo. Talvez o gerador ficaria melhor assim, já que ele saberia diferenciar quando uma palavra está iniciando uma frase pela letra maiúscula, ou talvez isso não mudasse lá grande coisa.

“Insert-triple-into-table” é a função que faz o trabalho sujo: ela é a responsável por inserir os trios gerados por “list->triples” na hash-table que críamos no começo do programa. Ela é feia, não é uma função que me orgulho de ter escrito, mas ela funciona. Perceba que cada entrada na hash-table inicial é, por sua vez, outra hash-table. Essa segunda hash-table guarda uma lista com as possíveis palavras que podem ser usadas.

“Insert-string-into-table” organiza o trabalho de separar uma string em uma lista de strings, transformá-las em símbolos, gerar os trios e inserí-los na hash-table.

“Insert-file-into-table” foi uma função que deu trabalho escrever. Inicialmente, ela seria a função responsável por abrir um arquivo, salvá-lo como uma string e então passar para “insert-string-into-table”. Porém, a forma com que fiz isso era péssima, o consumo de memória ia para as alturas e o tempo de execução também. Em uma das tentativas, reimplementei boa parte da “insert-string-into-table” em “insert-file-into-table”, mas acabei deixando as duas funções mesmo assim, já que as duas são úteis. Depois, consegui implementar esta função segundo a idéia original com um desempenho muito melhor.

Finalmente, a parte interessante: “generate” gera um texto com no máximo o número específicado de palavras. Não há garantias de que ele gerará o número máximo, já que algumas combinações podem fazer com que ele não consiga gerar mais nada.

Só para me exibir, resolvi colocar alguns trechos que o Gerador criou tendo como base o texto deste artigo (um artigo recursivo):

“logo no começo também, inicializamos o gerador de markov mesmo, mas se não for, a idéia é bem parecida.”

“gerador de markov é um gerador de markov”

“se houver vários espaços em sequência, nãs teríamos uma lista e uma chave aleatória de uma lista e uma chave aleatória de uma lista com algumas strings vazias, mas o “cond” na função “split-string” detecta isso”

Eu o tenho usado nas conversas de MSN com sucesso. Ele detecta que a outra pessoa falou “oi ” e gera o texto “olá =]” ou variação. Depois ele detecta a combinação “tudo bom?” e responde “sim, e contigo?”. Depois ele passa o comando para mim. OK, isso não é sério… ainda. Preciso aprender a fazer plugins para o Pidgin ainda (o bitlbee seria mais interessante nesse aspecto).

(defparameter *table* (make-hash-table))
(setq *random-state* (make-random-state t)) ; Random seed

(defun space-position (string)
  "Finds the position of a 'space' character in a string. By 'space' I mean a
newline, space or tab character."
  (let ((sp (position #\Space string))
        (nlp (position #\Newline string))
        (tp (position #\Tab string)))
    (let ((values-list (remove-if #'null (list sp nlp tp))))
      (if values-list
          (apply #'min values-list)
          nil))))

(defun split-string (string)
  "Splits a string into a list of strings use spaces as delimeters."
  (let ((pos (or (space-position string) -1)))
    (cond ((= pos -1) (list string))
          ((= pos 0)  (split-string (subseq string (1+ pos))))
          (t (append (list (subseq string 0 pos))
                     (split-string (subseq string (+ pos 1))))))))

(defun last-two (list)
  "Returns the last two elements from a list."
  (let ((l (length list)))
    (if (> l 1)
        (list (nth (- l 2) list) (nth (- l 1) list))
        nil)))

(defun random-elt (list)
  "Returns a random element from a list"
  (let ((l (length list)))
    (if (= l 0)
        nil
        (nth (random (length list)) list))))

(defun random-key (table)
  "Returns a random key from table"
  (random-elt (loop for key being the hash-keys of table collect key)))

(defun list->triples (list)
  "Returns sequencial triples from a list."
  (if (< (length list) 3)
      nil
      (append (list (list (nth 0 list) (nth 1 list) (nth 2 list)))
              (list->triples (cdr list)))))

(defun string->symbol (string)
  "Convert a string into a symbol"
  (intern (string-upcase string)))

(defun insert-triple-into-table (triple)
  "Insert a triple of symbols in the table"
  (if (hash-table-p (gethash (first triple) *table*))
      (progn
        (setf (gethash (second triple) (gethash (first triple) *table*))
              (push (third triple) (gethash (second triple) (gethash (first triple) *table*)))))
      (progn
        (setf (gethash (first triple) *table*) (make-hash-table))
        (setf (gethash (second triple) (gethash (first triple) *table*))
              (list (third triple))))))

(defun insert-string-into-table (string)
  "Inserts the string into a hash table."
  (mapcar #'insert-triple-into-table
          (list->triples (mapcar #'string->symbol (split-string string)))))

(defun insert-file-into-table (filename)
  (let ((str ""))
    (with-open-file (f filename :direction :input)
      (loop for line = (read-line f nil 'eof) until (eq line 'eof)
         do (setq str (concatenate 'string str '(#\newline) line))))
    (insert-string-into-table str)))

(defun generate (words)
  "Generate a text with 'words' words."
  (let* ((first-word (random-key *table*))
         (second-word (random-key (gethash first-word *table*)))
         (text (list second-word first-word))) ;;; This list will be reversed
    (dotimes (i words)
      (let ((first-table (gethash (second text) *table*)))
        (if (hash-table-p first-table)
            (push (random-elt (gethash (first text) first-table)) text))))
    (format t "~(~{~a ~}~)" (reverse text))))

Ultimamente tenho feito duas coisas: lido sobre Haskell e não postado no blog (além das outras coisas do dia-a-dia, claro).

Programas em Haskell são preguiçosos. Isso significa que quando uma variável é definida, ela só será computada quando seu valor for necessário. Assim, se fizermos um programa similar ao de baixo, fatorial de 1000 nunca será calculado, já que o seu valor não é necessário para calcular 1+1.

x = factorial 1000
putStrLn $ show (1+1)

Extrapolando essa mesma ideia* para outras definições, podemos definir uma lista de infinitos uns:

uns = repeat 1

Ou então com todos os números naturais:

naturais = [1..]

Com um pouco mais de perspicácia, é possível criar listas contendo todos os números de Fibonacci, ou então todos os fatoriais:

fibs = 1:1: (zipWith (+) fibs (tail fibs))
facs = 1:(zipWith (*) facs [1..])

Se quisermos 10 elementos de cada, fazemos:

dezFibs = take 10 fibs
dezFacs = take 10 facs

Essa implementação é bastante eficiente : se precisamos do fatorial de 10 e logo em seguida o de 11, não precisamos calcular 11×10×9×…×1, basta calcular 11×10!, que já havia sido computado. Melhor ainda : se uma hora precisarmos do fatorial de 7, ele já estará calculado, pronto para ser utilizado.

Agora sim a parte interessante, em que C entra nessa história. Embora minha implementação não seja nem de longe tão interessante como a utilizada pelo Haskell, ela serve de base para mostrar como uma implementação de stream ou listas infinitas pode ser feita em C.

A grande diferença entre listas e streams é que não trabalharemos com a idéia de um ponteiro para o próximo elemento, mas sim com uma expressão que ao ser executada nos dará o próximo elemento. Ou seja, ao invés de um ponteiro para outro elemento do mesmo tipo, nós temos um ponteiro para uma função.

typedef struct {
    int i;
    int (*cont)(int);
} stream;

Isso altera a forma como acessamos o próximo elemento. Não podemos mais utilizar o famoso ptr = ptr->prox porque estaremos apontando para uma função. Por isso, abstraí o processo de chamar a função com o valor da stream em uma função chamada proximo, que retorna uma nova struct com seu valor i atualizado pela função cont, o que dá a impressão de que avançamos na lista.

stream proximo(stream inicio)
{
    stream tmp;

    tmp.i = (*inicio.cont)(inicio.i);
    tmp.cont = inicio.cont;

    return(tmp);
}

Para exemplificar o uso de streams, criei a função pega que é similar à função take no Haskell, mas que no caso não retorna os valores, só os imprime.

void pega(int elementos, stream inicio)
{
    int i;
    stream atual = inicio;

    for(i = 0; i < elementos; i++)
    {
        printf("%d\n",atual.i);
        atual = proximo(atual);
    }
    printf(".\n.\n.\n\n");
}

Por fim, criei duas streams e duas funções auxiliares (que falta fazem expressões lambda). O código completo se encontra abaixo:

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

typedef struct {
    int i;
    int (*cont)(int);
} stream;

stream proximo(stream inicio)
{
    stream tmp;

    tmp.i = (*inicio.cont)(inicio.i);
    tmp.cont = inicio.cont;

    return(tmp);
}

int soma_um(int i)
{
    return(i+1);
}

int repete(int i)
{
    return(i);
}

void pega(int elementos, stream inicio)
{
    int i;
    stream atual = inicio;

    for(i = 0; i < elementos; i++)
    {
        printf("%d\n",atual.i);
        atual = proximo(atual);
    }
    printf(".\n.\n.\n\n");
}       

int main(int argc, char *argv[])
{
    stream naturais, identidade;

    naturais.i = 1;
    naturais.cont = &soma_um;

    identidade.i = 1;
    identidade.cont = &repete;

    pega(10, naturais);
    pega(10, identidade);
    return 0;
}

*eu escrevi “idéia” mas aparentemente os verificadores ortográficos já aderiram todos às novas regras ortográficas… fica assim mesmo.

Não sei quantos nomes existem para descrever esta forma de organizar séries de dados na memória, esses três do título foram as que eu consegui pensar em 5 segundos.

Enfim, comecemos pela forma mais simples de armazenar séries de dados na memória, arrays, seguiremos para listas, árvores, e então chegaremos às hash tables. Se tudo que você quer é um exemplo de implementação, vá ao fim do artigo.

Arrays

Internamente, quando se declara um array, um bloco de memória contínuo é alocado. Isso significa que elementos de um array estão sempre próximos entre si e que percorrer todo um array é relativamente rápido. O ponto fraco dos arrays é não serem flexíveis: Um array de tamanho 5 tem tamanho 5 e pronto, acabou. É possível criar um array b com tamanho 6 e copiar os 5 primeiros elementos de a para b, mas o array a continua tendo tamanho 5. No entanto, se esse tipo de operação começa a se tornar frequente demais, a vantagem de performance do array começa a desaparecer.

Primeiro, é necessário alocar o novo array e copiar os elementos. Depois, é necessário limpar o array anterior, ou daremos início a um gasto desnecessário de memória.

Com o problema da flexibilidade em mente [1], foi criado um novo método para lidar com séries de dados, as listas ligadas/linkadas.

Listas

Listas ligadas recebem esse nome porque cada nó (node) se liga a outro. Existem algumas formas diferentes de se implementar isso, como:

• Cada elemento aponta para o próximo. O último aponta para NULL. É assim que funcionam as cons cells em Lisp, Haskell e aposto que em várias outras linguagens.
• Cada elemento aponta para o próximo e o anterior. Isso facilita algumas operações, mas complica outras. Há um aumento no consumo de memória também, já que são necessários dois ponteiros.

Existem outras formas, assim como variações dessas. Lembre-se que há sempre uma troca entre consumo de memória e eficiência no processamento. Existem formas de usar listas que apontam para o próximo elemento e para o anterior usando apenas um ponteiro, mas para isso é necessária uma operação a mais (XOR).

Um detalhe sobre listas: geralmente os novos elementos dela são “empurrados” (push) no começo da lista, ao invés de adicionados (append) ao fim da mesma. O código fica muito mais rápido assim, já que não é necessário percorrer toda a lista para adicionar um novo elemento.

Existem também as árvores binárias, que estruturalmente são parecidas com listas, mas que apresentam outras vantagens e desvantagens.

Árvores binárias

Árvores binárias facilitam muito nas buscas: Se a condição c for verdadeira, siga à esquerda, senão, siga à direita. Isso significa que mesmo em árvores muito grandes, o número de “passos” dados é relativamente pequeno. Para se ter uma idéia, em uma árvore com 100.000 elementos, no máximo 17 “passos” terão de ser dados (). No entanto, para que isso seja verdade, a árvore tem de estar bem equilibrada (tanto o lado esquerdo como o direito terem o mesmo número de níveis). Existem algoritmos para isso, mas não entrarei nesses detalhes.

Toda essa agilidade em buscas vem com um preço: a inclusão de novos elementos em uma árvore é mais próxima da função append em uma lista que um push. Apesar de não ser necessário atravessar a árvore toda, ainda é necessário fazer comparações e tomar decisões a partir daí. Além disso, árvores consomem um pouco mais de memória, já que são necessários dois ponteiros (esquerda e direita) ao invés de só um (próximo) como geralmente é o caso em listas.

Por fim, existem as hash tables, que mistura arrays com listas e tem bom desempenho em buscas.

Hash tables

Hash tables são arrays de pequenas listas. No entanto, esse array não é acessado sequencialmente. Para ficar mais claro, vou começar com a função que dá nome a esse método: a função de hash.

Função hash
Esta função tem por objetivo associar um número a uma “coisa”. No exemplo que darei mais a diante, a função hash associa um número a uma pessoa a partir de seu nome. É esse número que nos dirá em que posição do array a “coisa” será armazenada; por isso, é preciso levar duas coisas em consideração: seu tempo de execução, já que ela será executada na adição de novos elementos e na busca por elementos já existentes, e a probabilidade de ela gerar o mesmo número para representar objetos diferentes.

Colisões
Se por um acaso a função hash gerar o mesmo número n para dois elementos, o programa não travará, nem o elemento anterior será apagado. O que ocorrerá é que a posição n deixará de conter unicamente um elemento, agora ela contém uma pequena lista de dois elementos.

Por que todo esse alarde sobre funções hash que gerem números diferentes? Pelo simples fato de que se você incluiu 10 elementos em um array com 10 posições, era de se esperar que em geral cada posição tivesse apenas um elemento. No entanto, com uma função hash ruim, pode acontecer de uma única posição ter, por exemplo, oito elementos. Analisando a performance deste caso, parece muito mais uma lista que uma hash table.

Lembre-se de que a função hash não pode ser aleatória ou depender do tempo, por exemplo, ou você não irá encontrar o elemento na hora de fazer uma busca!

O Array
O número de colisões entre os números não depende exclusivamente da função hash. É evidente que se o programa for salvar 1000 elementos em um array de 10 posições, haverá várias colisões. Pelo outro lado, salvar 10 elementos em um array de 1000 posições é um desperdício enorme de memória.

O código

Creio que o código esteja bastante claro, mas qualquer coisa perguntem. Se vocês quiserem “ver” um caso de colisão, troque o 5 na linha #define REGISTROS 5 por 4.

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

/* Define o numero de posicoes no array. Note que esse nao eh o limite maximo */
#define REGISTROS 5

/* Abstracao de uma pessoa. Apenas para exemplo. */
typedef struct Pessoa Pessoa;
struct Pessoa {
    char *nome;
    char *profissao;
    unsigned short idade;
    unsigned short senha;
    Pessoa *proxima;
};

/* Onde os registros serao salvos */
Pessoa *pessoas[REGISTROS];

unsigned int hash(const char *nome);
unsigned int registrar_pessoa(Pessoa *p);
Pessoa *achar_pessoa(const char *nome);

int main(int argc, char *argv[])
{
    /* Exemplos */
    Pessoa joao = { "Joao Ninguem", "Bohemio", 21, 6969, NULL };
    Pessoa jose = { "Jose Pessoa",  "Nerd", 12, 1234, NULL };

    registrar_pessoa(&joao);
    registrar_pessoa(&jose);

    achar_pessoa("Joao Ninguem");
    achar_pessoa("Jose Pessoa");
    achar_pessoa("Maria Pessoa");

    return 0;
}

/* Dado um nome, retorna um numero no intervalo [0,REGISTROS[ */
unsigned int hash(const char *nome)
{
    char *p = nome;
    unsigned int soma = 0;

    while(*p != 0) /* caractere nulo indica fim da string */
    {
        soma += *p;
        p++;
    }

    return(soma % REGISTROS);
}

/* Registra uma pessoa no array */
unsigned int registrar_pessoa(Pessoa *p)
{
    unsigned int posicao;
    if(p == NULL)
        exit(1);

    posicao = hash(p->nome);

    /* Posicao vazia, basta incluir a pessoa aqui */
    if(pessoas[posicao] == NULL)
    {
        pessoas[posicao] = p;
    }

    /* Houve uma colisao entre as posicoes, devemos usar o campo "proxima" */
    else
    {
        Pessoa *tmp = pessoas[posicao];
        while(tmp->proxima != NULL) tmp = tmp->proxima;
        tmp->proxima= p;
    }

    printf("registrado em %u.\n", posicao);
    return(posicao);
}    

Pessoa *achar_pessoa(const char *nome)
{
    unsigned int posicao = hash(nome);
    Pessoa *p = pessoas[posicao];

    for(; p!=NULL ; p = p->proxima)
    {
        /* Nome foi encontrado */
        if(strcmp(p->nome, nome) == 0)
        {
            printf("pessoa encontrada em %u.\n", posicao);
            return(p);
        }
    }

    /* Se a funcao chegar aqui, o loop terminou sem encontrar a pessoa, entao
     * ela nao existe */
    printf("pessoa nao encontrada.\n");
    return(NULL);
}

[1] Não tenho certeza se historicamente os arrays se desenvolveram antes das listas, eu creio que sim.

Quem clicou no meu identi.ca viu que só estou escrevendo em inglês lá. Entretando, às vezes quero escrever um texto maior, e lá no identica não há espaço, então eu resolvi criar um blog em inglês.

Um blog não substitui o outro, a idéia é que eles se complementem, mas a verdade é que no momento eu gosto mais do outro, por motivos que constam no primeiro post do outro blog: aqui eu sou muito mais um tradutor que um criador de conteúdo, e eu mesmo não faço parte do meu público alvo. Com isso eu consigo separar as coisas e ver cada blog em seu devido lugar, e evitar decepções.

αρσ (alpha rho sigma)

Acabei de criar um conta no Identi.ca e no Twitter. Eu vou postar principalmente em inglês, mas quem quiser fique à vontade para me seguir (preferencialmente no Identi.ca, mas isso é com vocês).

Estava dando uma olhada numa entrevista com o criador do BigLinux. Além de manter a distro, ele tem um site de buscas chamado “BigBusca”. Entrei para dar uma olhada, crente de que seria uma porcaria. Engano meu. Apesar do sistema de busca não ser exatamente dele (são buscas personalizadas do Google), existem opções que ficam meio escondidas no Google mesmo.

Por exemplo, na pesquisa Web, é possível escolher a idade máxima dos artigos (24 horas, um mês, um ano, etc). A busca por documentos permite especificar se quero pdfs, docs, odts… A busca por imagens novamente apresenta facilidades do tipo.

Ah sim, o link: BigBusca

Eu instalei os pacotes cairo-lcd e libxft-lcd aqui e as fontes ficaram com uma aparência bem melhor. Claro que isso é subjetivo, então recomendo que experimentem os pacotes cairo-cleartype, freetype2-cleartype e libxft-cleartype.

A diferença entre eles é o algoritmo usado no subpixel shading. Pessoalmente, acho o algortimo padrão ruim, tanto que eu o deixava desligado. O Cleartype é o mesmo usado pelo Windows, mas também não gosto, acho que as fontes ficam “embaçadas”. O LCD, se não me engano, é um conjunto de patches utilizado pelo Ubuntu.

Infelizmente, nenhum desses dois últimos poderá vir a ser o padrão por questões legais.

Eu adoro imagens de fractais, geralmente servem como ótimos papéis de parede e acho interessante essa conexão entre Matemática e Arte.

Durante algum tempo dei uma pesquisada nos programas disponiveis para Linux e elegi meus três favoritos:

• xaos – é o mais antigo, mas é relativamente leve e roda bem até mesmo em máquinas mais modestas. Da minha galeria no DeviantArt, o único que foi feito com ele foi este: Burtonian Brain.
• qosmic – é uma interface gráfica para o flam3, mas ainda não aprendi a usá-lo muito bem.
• gnofract4d – é o mais amigável de todos e é possível chegar a resultados interessantes usando apenas a função “Explorer”. Um detalhe interessante é que um dos meus fractais está nos favoritos do criador do software (o Malignific).

Para quem quiser ver, minha galeria no DeviantArt tem alguns fractais que foram feitos usando esses programas.

Após uma semana mais ou menos com o Enlightenment, posso dizer que gosto dele, mas que ele ainda não está pronto para uso. Não duvido que quando ele estiver pronto ele será um ótimo gerenciador de janelas / desktop, mas no momento os pequenos defeitos me encomodam.

Pesquisei mais gerenciadores de janelas aqui e ali, mas os que pareciam promissores eram projetos mortos, todos os outros que pareciam interessantes eu já tinha testado e não gostava por um detalhe ou por outro.

Por fim, resolvi fazer o meu próprio gerenciador, baseado no que eu gostava ou não em cada gerenciador que já experimentei (e acreditem, eu já experimentei vários). Se você não quiser ler um pequeno review de cada gerenciador, pule direto para o cabeçalho “O meu”.

Não tilings:

• Enlightenment: O Enlightenment é um projeto que tem futuro. Não conheço os desenvolvedores do projeto, mas aposto que são perfeccionistas; entretanto, o projeto ainda está em fase alfa, significando que ainda faltam muitas coisas até que ele esteja de fato utilizável.
• XFCE4: Tem um gerenciador de janelas bom, que permite a utilização de composição, janelas transparentes, de maneira bastante fácil (e bastante leve). Infelizmente, não achei um modo de fazer com que certos programas abrissem em certos desktops virtuais.
• KDE e GNOME: São os projetos com maior integração entre os programas que os compõe, algo que de certa forma eu sinto falta, mas ambos são monstruosos: mais de 300MB de downloads cada. Além disso, apesar de às vezes eu sentir falta de uma maior integração entre os programas, eu sei que sou minimalista na essência, e que logo me encheria dos dois.
• Openbox: Eu gosto do Openbox, mas o uso de XML como arquivo de configuração realmente me desanima. Entre os *box, é o mais bonito.
• Fluxbox: Fluxbox é leve e é relativamente fácil de configurar (se comparado ao Openbox), mas nem mesmo com os melhores temas ele parece ter sex appeal, sempre sinto que estou usando um software arcaico quando estou com ele.
• PekWM: Um gerenciador de janelas muito bom, reune as qualidades do Openbox (é bonito) e do Fluxbox (é fácil de ser configurado). Entretanto, ele também sofre da síndrome de não parecer um software “terminado”, assim como o Enlightenment.

Além disso, não posso me enganar, os gerenciadores de janela que mais gostam foram os tiling, mas mesmo assim eles não são perfeitos…

Tiling:

• DWM: Espartano demais. Ele sequer tem um arquivo de configuração propriamente dito, as configurações são feitas em um header (um arquivo .h) e o programa deve ser recompilado para que as alterações tenham efeito.
• Awesome: Legal, mas seu arquivo de configuração muda mesmo a cada troca de versão menor (de 3.0 para 3.1 mudou, de 3.1 para 3.2 mudou…).
• Xmonad: Legal, mas é escrito em Haskell, o que faz do GHC uma dependência. Eu não uso Haskell para mais nada, então ter um pacote que ocupa mais de 300MB quando descompactado é exagero.

O meu:

Baseado nisso tudo, resolvi fazer o meu. As idéias principais são:

• Configurável sem precisar recompilar.
• O arquivo de configuração em hipótese alguma será em XML.
• Pequeno número de dependências, e preferencialmente dependências pequenas.
• Configurável por uma linguagem que permita que o gerenciador seja extensível.
• A sintaxe do arquivo de configuração não ficará mudando de hora em hora.

O resultado disso tudo é um fork do DWM que usa o ECL para lidar com seus arquivos de configuração. O que isso significa? Que o usuário tem um ambiente Lisp completo para suas configurações.

- Quantos desktops virtuais você quer?
- 5!
- Cinco fatorial? Sem problemas:

(defun factorial (n)
  (if (= n 1)
      1
    (* n (factorial (1- n)))))

(workspaces (factorial 5))

Assim que ele estiver minamente funcional, estarei disponibilizando o código para quem quiser testar.

Não preciso nem dizer que sou um chato em relação a gerenciadores de janelas. Passei um tempo com o PekWM, mas ele não estava se entendendo muito bem com o Emacs. Além disso, algumas leituras recentes sobre inovações no Desktop me fizeram querer largar mão um pouco do minimalismo, estava até cogitando usar o KDE 4.3, e estou ansioso pelo GNOME 3.

Dei uma olhada na Wiki do Arch Linux para ver que outras opções eu tinha e me lembrei do Enlightenment 17. Logo quando editei meu .xinitrc e iniciei o X com o Enlightenment, uma surpresa : Uma tela inicial permitindo a configuração de algumas coisas. O interessante é que existem “perfis” pré-configurados : um minimalista, que creio que não tenha tantos efeitos visuais, o tradicional, e dois que me chamaram a atenção para dispositivos de tela pequena (um é voltado para Netbooks e outro para dispositivos embarcados).

Comecei a mexer com ele e me impressionei com a atenção que foi dada aos mínimos detalhes. Por exemplo, no pager, dispositivos que mostra os Desktops Virtuais, existem miniaturas das janelas que estão abertas naquele Desktop. Se uma janela chama a atenção, sua miniatura no pager fica balançando. O ícone que aparece no canto superior esquerdo da decoração da janela também fica balançando, e aparece um ponto de exclamação.

Outro detalhe interessante é a existência de um botão “Modo de apresentação”. Ele desliga temporariamente a proteção de tela e as configurações de economia de energia, assim a tela não desliga enquanto você está fazendo aquela apresentação ou assistindo aquele filme.

Vale lembrar, entretanto, que ele ainda é uma versão em desenvolvimento. Apesar dessa atenção dispensada até aos mínimos detalhes, ele ainda não é perfeito. Por exemplo, nas configurações de que aplicativos serão iniciados automaticamente ao iniciar não é possível adicionar aplicações arbitrárias. Quando eu quis que o xbindkeys fosse iniciado junto ao Enlightenment, tive de criar um “ícone” para a aplicação e então adicioná-la à lista de aplicações iniciadas.

Outro problema é o gerenciador de arquivos. No momento, ele é minimamente funcional. Minimamente. Para se ter uma idéia, se estou em /home/usuario, não há como acessar /home diretamente. Ao invés de abrir Home e subir um nível, é necessário abrir o Root e clicar em home. Por enquanto fica só a promessa e a curiosidade de como seria um gerenciador de arquivos inovador.