Abrindo parêntesis

A minha descoberta do LISP

É sabido que este blog visa uma tarefa essencial: descomplicar a programação e voltar às raízes usando “C” e assembly.

Acabamos também transformando-o em uma colcha de retalhos que contém dicas sobre o melhor sistema da atualidade para se trabalhar com programação – o GNU/Linux – e suas ferramentas.

Acabo então, por puxar mais uma ponta nesta colcha, pois ontem acabei por penetrar em mais um baluarte remanescente da era de ouro dos computadores: o LISP.

Problemas originais

O primeiro problema que enfrentamos quando queremos programar é a nossa própria ansiedade em ver tudo “rodando”. Esta talvez seja a raiz de todos os problemas que enfrentamos após lançarmos aquela ideia num editor de textos e vê-la compilar “sem erros”. Na realidade esta é a verdadeira gênese de um inferno astral que surge ao “liberarmos o programa para o mundo”. Isto ocorre pois o mesmo, foi feito enfatizando os alogorítimos, em vez dos dados.

O dado, ou seja a informação sem tratamento, deveria ser tratado como cidadão de primeira classe, ao invés dos algorítimos o serem. E o planejamento cuidadoso de sua forma e estrutura é que faz a diferença entre um programa que “roda” e um programa que “resolve” um problema sem criar outros.

Na matemática, damos muita ênfase aos números e o processo envolve dar significado a eles, primeiramente, para depois agrupá-los e classificá-los. Na programação, deveriamos fazer o mesmo com os dados, antes de processá-los. Mas, caso o façamos, nos deparamos com uma realidade sutil, percebida por poucos: computadores não foram feitos para trabalhar com “textos”, mas sim com números. O próprio nome, computador, já existia antes de formalizar-se sua existência, e significa: contar, calcular…

Como fazer isto, então, com textos?

Há muito tempo percebi que a ferramenta mais amigável de um programador é o seu editor de textos e a mais pervertida é a sua IDE. A primeira é onde nasce o programa e ele pode ser analisado sem interferências ou falhas do ambiente. É o programa brotado da ideia para a tela, estático. A segunda é onde se criam os idiotas “chaplinianos” que pensam estar programando, quando na realidade estão apertando parafusos, ou melhor dizendo juntando, desonradamente, peças do trabalho de outros e atribuindo-as aos seus. Vide dotneticos, delphicos, javeiros e outros bichos mais…

Contatos imediatos do terceiro grau – Emacs

Na minha busca pela ferramenta certa, encontrei no ano passado e pela segunda vez na vida, o GNU/Emacs, e pude comprovar o poder de fogo desta arma. Depois de muito “atirar” com ela – e também de me ferir – percebi que ela se utiliza de uma engrenagem que a faz ter tanto poder e versatilidade: o LISP.

Adiei, até poder me dizer usuário de emacs, ou “emacser”, o aprendizado do funcionamento da engrenagem. Primeiro, porque sempre vi o LISP, como a maioria vê: um alien. Segundo porque, assim como todos, tenho outras coisas a fazer, em vez de estudar matemática. Melhor então me aproveitar do trabalho dos outros… (;-))

E nesta de “aproveitar o trabalho dos outros” sempre achei estranho lidar com os mesmos problemas que, ao serem dissecados até o fim, acabavam sempre degenerados em números, listas e quando se tratava de strings, a melhor solução parecia ser a recorrência, mas que por puro medo e preconceito eu abominava.

Forçando a barra e usando martelo como chave de fenda

Esta semana eu estava resolvendo um problema que me atormenta há muito tempo: como eliminar espaços extras numa string deixando apenas um no lugar e eliminando as bordas.

Abri a cabeça e fiz um código – feio – mas que funcionou bem. Só que recorrente. Testei de todo o jeito e notei que é muito estável. Aquilo me chamou a atenção: por que não usar isto mais vezes?

#include <ctype.h>
#include <stdio.h>

/* Objetivo: eliminar espaços duplicados, deixando apenas um
   no seu lugar e eliminar os espaços extra das extremidades 
*/

void shrinkstr( char *s, int count)
{
  while ( *(s + count) != 0 ) 
      *s ++ = *(s + count) ;
   *s = 0;
}

void jumpspcs( char * str, int * count )
{
  if (*str == 0) {
    str -= *count;
    if ( isspace(*--str) ) *str = 0;
    return;
  }

  if ( isspace(*str) ) {
    * count += 1;
    jumpspcs( ++ str, count );
  }

  else {
    str -= *count - 1 ;
    shrinkstr(str - 1, *count);

    if ( isspace(*str) ) {
      *str = ' ';
      str ++; // deixa apenas um espaço
    }

    *count = 0;
    jumpspcs( str , count );
  }
}

int main( int argc, char ** argv)
{
  char *str = argv[1];
  int n = 0;

  if (argc < 2)
  {
     puts("Uso: test \"   bla   bla   bla  \"");
     return 1;
  }
  jumpspcs( argv[1], &n);
  printf("'%s'\n", str);
  return 0;
}

Olhando para o código, percebi que o mesmo “não fica bem” numa linguagem como o C. Parece “torto”.

O motivo é muito simples: C, C++, Java, C#, etc… Possuem o mesmo DNA: Fortran. Além do claro fato que eu não sou matemático e muito menos programador de primeira linha.

Mas até eu percebo que usar estas ferramentas é como usar um martelo no lugar de uma chave de fenda para instalar um parafuso.

Olá matemática: o Cálculo revisitado

Esta semana também encontrei um velho conhecido: o Cálculo. Estava folheando o livro do James Stewart e fiquei maravilhado como um livro, bem diferente daqueles do Thomas Finney (nos quais já estudei), consegue ensinar, de forma tão fácil o que eu nunca tive coragem de digerir. O livro aborda conceitos práticos, reais e aplicáveis com o Cálculo e deixa-nos a real sensação que não somos tão burros, como os professores insistem em nos provar, ao invés de nos ensinar.

Por sorte, também encontrei outro livro, sobre LISP, este bem mais recente, do Conrad Barski, M.D.. Foi uma surpresa gratificante notar que sou muito idiota por ter tido “medo” e evitado esta linguagem.

O modo como o autor expõe os conceitos – tipo gibi e ainda por cima cria um “joguinho” nos exemplos – nos leva a achar muito do que já vimos e tentamos resolver com listas, árvores, strings, etc usando os recursos toscos das outras linguagens.

Como vi num exemplar antigo ( Agosto 79, Vol. 4, Num. 8 ) da revista Byte – uma relíquia que consegui via p2p – numa edição totalmente dedicada ao
LISP: o LISP é um assembly de alto nível feito para uma “maquina virtual”, John Allen.

“LISP é simples e difícil, elegante e ad hoc; é a beleza da mistura do previsível com o fortuito. LISP é uma linguagem de programação, sempre caracterizada como de “propósito especial” para processamento de listas. Mas LISP é tão de “propósito especial” quanto a matemática é para se processar cálculos de ponto-flutuante. Da mesma forma que existe mais matemática do que “contabilidade e escrituração” nas ditas linguagens de “propósito geral”.

A melhor descrição de programação em LISP é ela ser uma “linguagem de máquina” de alto nível cujos dados são organizados de forma diferente daquela de padrões de bits da maioria dos computadores, e o LISP é o assembly para esta máquina.”

Note que isto foi escrito em 1979, quando o JAVA nem sonhava em dar o ar da graça. Ou seja o LISP contém muito do que buscamos de forma primitiva, obter com os nossos “C’s” e “Pascais” que por aí vivem.

Daqui para frente

Eu ando bem cansado de ficar remoendo os problemas usando técnicas e artifícios – macetes mesmo – com a linguagem “C”. Sim gosto muito dela, mas falta um ingrediente: entendimento das raízes.

Instalei o CLISP no meu computador e fiquei muito animado e satisfeito com os resultados imediatos obtidos usando conceitos bem primitivos.

A parte difícil então, fica daqui por diante: como abandonar os velhos hábitos, tirar a máscara e aprender Matemática; de novo ?!…

Acho que o jeito vai ser “abrir um parêntesis” e recursivamente utilizar o LISP acoplado aos meus adorados programas em “C”, afinal a exemplo do RMS, o GNU/Emacs é exatamente isto: 30% C, 70% LISP.

Anúncios

3 comentários sobre “Abrindo parêntesis

Deixe um comentário

Faça o login usando um destes métodos para comentar:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s