Varuzza on Lisp

Começando a molhar os pés com Clojure

2009-05-27T18:12:00.000-07:00

Para comemorar a versão 1.0 do livro sobre Clojure resolvi voltar a estudar a linguagem.

Quando se começa uma nova linguagem é sempre difícil achar uma configuração de ambiente que seja confortável. Para common lisp a escolha é simples, slime é a melhor opção, porém, para qualquer linguagem que envolve a JVM é preciso pesar bem o uso de uma IDE estabelecida para java.

Para NetBeans existe o plugin enclojure, que funciona com o NetBeans 6.5. Ao instala-lo tive duas boas surpresas: a qualidade gráfica do NetBeans, que está com belas fontes com anti-aliasing e a segunda foi o fato do plugin em estágio alpha estar funcionando com REPL e tudo.

Forth, Lisp e 8 bits

2009-05-19T20:23:00.000-07:00

Forth é feito para maquinas pequenas. De uma olhada no código fonte em assembly dessa versão de forth:

http://www.annexia.org/_file/jonesforth.s.txt

Eles criaram uma maneira de eliminar o call de forma a economizar alguns bytes por chamada de função. Forth é muito legal. Vale sempre lembrar que foi feita uma versão para atari:

http://www.pelulamu.net/viznut/blog/2007-05-26/atari-forth-small.jpg

O lisp já tem outra filosofia, ele foi criado para fazer manipulação simbólica. Não faz muito sentido um lisp de 8, bits porque cada palavra da alocada possui alguns bits como tag de tipo. Tanto é assim, que o principal computador na época aurea do lisp era o PDP-10 que tinha 36 bits, portanto dava para usar 4 bits para tagging e sobravam 32 bitrts para armazenar os valores.

Brief Incomplete and Mostly Wrong history of programming languages

2009-05-08T03:49:00.000-07:00

Muito divertido esse post:

http://james-iry.blogspot.com/2009/05/brief-incomplete-and-mostly-wrong.html

Especialmente para quem conhece a história do Lisp.

Aprendendo Scala

2008-10-14T13:30:00.000-07:00

Estou aprendendo a linguagem de programação Scala, que é uma linguagem de programação funcional estaticamente tipada que gera código para a JVM e para .NET.

Scala é bastante elegante, com várias novidades no tratamento da tipagem que tornam a linguagem muito menos verborrágica que o java. A sintaxe para criar closures é particularmente elegante: x => expr

Porém, já descobri algumas coisas que eu estou sentindo falta:

Multiple values return: Em scala é possível retornar uma n-tupla, mas não é a mesma coisa, não é possível ignorar os valores secundários da função como no lisp, e especialmente, não existe a construção multiple-values-bind.

Geração dinâmica de classes. É impressionante como é difícil fazer ORM em uma linguagem estática. Não existe nada no hibernate que permita fazer uma introspeção no banco e gerar o código da classes automaticamente, como o rails e o cakephp fazem. É preciso fazer uso de um gerador de código estático como o salto-db (ugle).

Update: É possível fazer multiple-value-bind em scala:


val (a,b) = (1,2)
a: Int = 1
b: Int = 2

13949712720901ForOSX

2008-10-06T10:59:00.001-07:00

>Java 1.6 for OS x!!!!!

13949712720901ForOSX

Testanto o rucksack

2008-08-17T20:41:00.000-07:00

Elephant é uma biblioteca para persistência de dados em Common Lisp construída em cima do BerkeleyDB. A biblioteca tem uma boa documentação e uma comunidade de usuários e mantenedores ativa, porém, eu não consigo fazer ela funcionar no Linux 64 bits (No Mac 32 bits funciona). Já escrevi para a lista deles e nenhuma resposta. É um bug na invocação da função em C db-env-create da BerkeleyDB. Tentei eu mesmo debugar o código do elephant, mas não foi para frente.

Resolvi uma nova abordagem, hoje eu testei a biblioteca Rucksack. É um código menos maduro que o Elephant e aparentemente só um desenvolvedor o mantém, no entanto, o Rucksack não depende de nenhum código em C, é uma implementação de persistência totalmente feita em Common Lisp, inclusive com indexação por B-Tree. O desempenho me pareceu bom, consegui inserir mais de 26 mil registros em aproximadamente 140 segundos no MacBook.

É muito bonito fazer tudo isso sem sair do Lisp. Essa biblioteca parece ter um grande potencial, por exemplo, uma linguagem de queries OOP ou baseada em Prolog iria ser muito legal (uma espécie de AllegroCache Free software).

XEmacs no windows

2008-07-29T13:54:00.000-07:00

No windows é melhor utilizar o XEmacs do que o GNU Emacs. Além dele possuir um instalador legal, ele reenderiza as fontes melhor que a versão do Stallman.

Uma curiosidade é que o XEmacs é um fork do GNU Emacs feito pela Lucid na esperança de escapar da falência após o AI Winter.

Windows Vista

2008-07-27T07:30:00.001-07:00

Logo que o vista eu o testei brevemente. Minha primeira impressão havia sido péssima, o sistema me pareceu lento e kitsch, muito pior que o XP.

Ontem eu tentei novamente e minha impressão mudou completamente. Não sei se é porque eu testei em uma máquina nova, mais rápida e com monitor LCD widescreen, o use é porque o Vista SP1 esta muito melhor que o original, o fato é a minha impressão sobre o Vista mudou fortemente, atualmente eu o acho melhor que o XP (mas ainda não é um Mac OS X).

A biblioteca mpfr

2008-07-15T05:09:00.000-07:00

Acabei de descobrir (na lista do GMP) a biblioteca mpfr (feita pela INRIA, provavelmente quer dizer MP france). Esta biblioteca é uma extensão do GMP, que adiciona regras de arredondamento e funções transcedentais.

As regras de arredondamento tem como objetivo retornar resultados com todos os digitos significativos, de maneira similar ao mathematica. Tenho a impressão que o mpfr é muito mais adequado para aplicações matemáticas do que o GMP.

Agora preciso adapter o cl-mpfloat para utilizar o mpfr.

Sempre tem um comando para você

2008-07-13T18:38:00.001-07:00

Para formatar o valor de pi que aparece no post anterior, eu descobri um novo comando do unix: fold. Ele quebra linhas muito longas em linhas com 80 colunas, ou outro valor especificado com a opção -w.

Calculando pi em lisp

2008-07-13T18:07:00.000-07:00

O método de Brent-Salamin (ou Gauss-Legendre) é um algoritmo muito simples para calcular o valor de pi (não sei se é o mais eficiente).

O problema de calcular qualquer uma dessas constates é lidar com a precisão de máquina, não é possível calcular pi com mais de algumas casas decimais usando as operações de ponto flutuante do processador.

Infelizmente, ao contrário do CLISP, o SBCL não tem a capacidade de lidar com números de precisão arbitrária, por isso eu fiz um cffi binding para as funções para float de precisão arbitraria da biblioteca GMP (GNU Multiple Precision Arithmetic Library). O código esta disponível via git: http://www.lambdatau.com/git/cl-mpfloat.git.

Além do binding, eu fiz um wrapper em CLOS para simplificar o uso. A performance não é nada espetacular, o programa demora 2.7s para calcular pi com 300 mil casas decimais, mas é prático.

Talvez uma DSL para compilar as expressões aritméticas em chamadas a biblioteca, de forma a minimizar a alocação de valores, melhore a performance.

Segue a primeira página do valor calculado:


3.141592653589793238462643383279502884197169399375
10582097494459230781640628620899862803482534211706
79821480865132823066470938446095505822317253594081
28481117450284102701938521105559644622948954930381
96442881097566593344612847564823378678316527120190
91456485669234603486104543266482133936072602491412
73724587006606315588174881520920962829254091715364
36789259036001133053054882046652138414695194151160
94330572703657595919530921861173819326117931051185
48074462379962749567351885752724891227938183011949
12983367336244065664308602139494639522473719070217
98609437027705392171762931767523846748184676694051
32000568127145263560827785771342757789609173637178
72146844090122495343014654958537105079227968925892
35420199561121290219608640344181598136297747713099
60518707211349999998372978049951059731732816096318
59502445945534690830264252230825334468503526193118
81710100031378387528865875332083814206171776691473
03598253490428755468731159562863882353787593751957
78185778053217122680661300192787661119590921642019
89380952572010654858632788659361533818279682303019
52035301852968995773622599413891249721775283479131
51557485724245415069595082953311686172785588907509

Alguém esta vendo alguma mensagem oculta ai?

Animação com o cl-opengl

2008-05-29T19:32:00.000-07:00

Ontem de noite eu adaptei um exemplo do livro OpenGL SuperBible para o lisp. É um programinha que desenha um retângulo que fica andando na tela. Com ajuda do Luís Oliveira eu consegui uasr o evento de tick para controlar a velocidade da animação.

Eu adicionei um efeito com a cor, ela vai mudando conforme o triangulo anda pela tela. Assim o programa fica um pouco menos simplório.

O programa segue abaixo.

;;
;; Bounce Rectangles
;;
;; Adapted from OpenGL Superbible pg. 62
;;

(declaim (optimize (speed 3) (debug 0) (safety 0)))

(eval-when (:load-toplevel :compile-toplevel)
(asdf:oos 'asdf:load-op :cl-glut))

(defclass bounce-window (glut:window)
((x :initform 0)
(y :initform 0)
(range :initform 100.0)
(window-height :initform 100.0)
(window-width :initform 100.0)
(size :initform 10)
(xstep :initform 2)
(ystep :initform 3)
(terminated :accessor terminated :initform nil))

(:default-initargs
;; Call tick event every 25 milis (approx.)
:tick-interval 25
:width 600 :height 400 :pos-x 100 :pos-y 100
:mode '(:double :rgb) :title "Bounce Rectangles"))

(defgeneric color (self color x y))

(defmethod glut:reshape ((win bounce-window) w h)
(gl:viewport 0 0 w h)
(gl:matrix-mode :projection)
(gl:load-identity)
(with-slots (range window-height window-width) win
(let ((aspect-ratio (/ (float w) (float h))))
(declare (float aspect-ratio))
(if (<= w h)
(progn
(setf window-height (/ range aspect-ratio))
(setf window-width range)
(gl:ortho (- range) range (- window-height) window-height range (- range)))
(progn
(setf window-height range)
(setf window-width (* range aspect-ratio))
(gl:ortho (- window-width) window-width (- range) range range (- range))))))
(gl:matrix-mode :modelview)
(gl:load-identity))

;; Calculated color by (x,y)
(defmethod color ((self bounce-window) color x y)
(with-slots (window-width window-height) self
(let ((alpha (/ (* 2 (abs x)) window-width))
(beta (/ (* 2 (abs y)) window-height)))
(case color
(R alpha)
(B beta )
(G (- alpha) beta)))))

;; Change the vertex color according to (x, y)
(defmethod color-vertex ((self bounce-window) x y)
(gl:color (color self 'R x y) (color self 'G x y) (color self 'B x y))
(gl:vertex x y))

(defmethod glut:display ((self bounce-window))
(gl:clear :color-buffer)
(with-slots (x y xstep ystep size) self
(gl:begin :polygon)
(color-vertex self (- x size) (- y size))
(color-vertex self (+ x size) (- y size))
(color-vertex self (+ x size) (+ y size))
(color-vertex self (- x size) (+ y size))
(gl:end))
(glut:swap-buffers))

;; Update rectangle position
(defmethod glut:tick ((self bounce-window))
(with-slots (x y xstep ystep size range terminated window-width window-height) self
(incf x xstep)
(incf y ystep)

(when (> (+ (abs x) size) window-width)
(setf xstep (- xstep)))

(when (> (+ (abs y) size) window-height)
(setf ystep (- ystep)))

;; Check bound. THis is in case the window is made
;; smaller while rectangel is bouncing and the
;; rectangle suddenly find itself outside the new
;; clipping volume
(if (> x (+ window-width (- size) xstep))
(setf x (+ window-width (- size) -1))
(if (< x (- (+ window-width xstep)))
(setf x (- (+ window-width 1)))))

(if (> y (+ window-height (- size) ystep))
(setf y (+ window-height (- size) -1))
(if (< y (- (+ window-height ystep)))
(setf y (- (+ window-height 1)))))

;; Don't post-redisplay if window is closed (otherwise crash sbcl)
(if (not terminated)
(glut:post-redisplay))))

(defmethod glut:keyboard ((win bounce-window) key x y)
(declare (ignore x y))
(when (or (eql key #\Esc) (eql key #\q))
(glut:close win)))

(defmethod glut:close ((win bounce-window))
(glut:disable-tick win)
(setf (terminated win) t)
(glut:destroy-current-window))

(defun bounce-rectangle ()
(let ((win (make-instance 'bounce-window)))
(glut:display-window win)))

Closures versus objetos

2008-05-28T21:23:00.001-07:00

Closures são entidades fluidas, eles podem aparecer e desaparecer sem que ninguém perceba. Já os objetos, possuem uma enorme plaquinha com o nome deles e a família à qual pertencem e telefone para ligar caso eles se percam.

Programadores humanistas

2008-05-14T04:00:00.000-07:00

Peter Seibel escreveu o excelente Practical Common Lisp. Em uma palestra ministrada no google ele diz que se formou em letras, mas como ele sabia programar acabou indo trabalhar na WebLogic, empresa que fez um dos primeiros application server para java.

Tim O'Really também é formado em letras, ele começou escrevendo manuais técnicos com um amigo e hoje é um guru que da palestras sobre web, programação, etc. Mitchell Kapor estudou psicologia, linguistica e computação na universidade, ele criou o Lotus 1-2-3 ficou rico e agora é venture capitalist.

Nos três casos eu fiqeui surpreso de ver grandes programadores com formação em humanas. Mas pensando melhor no assunto isso me parece resultado da formação menos rígida que se tem nas universidades americanas. No Brasil é preciso escolher o curso antes de entrar na universidade, nos EUA entra-se na universidade e após fazer uma série de cursos obrigatórios para todos se escolhe um "major", que é a disciplina na qual o aluno vai se especializar.

Eu sempre achei a abordagem americana estranha, mas vendo esses exemplos mudei de opnião.

A new function a day

2008-05-08T13:48:00.000-07:00

Estou fazendo um simulação que calcula um determinado valor para diversos valores de y. A cada passo eu salvo o valor de y e f(y) em um arquivo para depois construir um gráfico.

Porém, quando y fica muito grande a simulação come toda a memória e eu tenho que matar o lisp. Após matar o lisp olho para o arquivo gerado e vejo que ele esta vázio pois o buffer do arquivo não havia sido preenchido nenhuma vez.

Após alguns momentos de raiva eu pesquiso por flush com o apropos. Encontro esta função

(sb-int::flush-standard-output-streams)

Nenhuma documentação sobre ele, porém faz o que eu preciso, além dos valores no arquivo eu agora consigo imprimir um monitor para acompanhar o andamento do programa.

Garamond no TeX

2008-04-09T20:39:00.000-07:00

Garamond é uma ótima fonte, boa alternativa para variar do Computer Modern.

Quem quiser usar o Garamond no LaTeX deve ir para este link:

http://gael-varoquaux.info/computers/garamond/index.html

Existem outros pacotes com a configuração do Garamond para LaTeX, mas este é o que funcionou melhor.

Pure Lisp on X

2008-03-30T16:39:00.000-07:00

Um projeto antigo e interessante é o clx, uma implementação do X protocol em Lisp. Nada mais simples para fazer programação gráfica, ele abre um socket com o xserver e manda ver, sem FFI, sem bibliotecas em C, pure lisp on X.

A implementação que funcinou no SBCL (1.0.15) foi a que esta disponível através de:


  darcs get http://common-lisp.net/~crhodes/clx

Funciona tanto no Linux quanto no OS X.

Eu fiz um pequeno exemplo que utiliza a minha biblioteca cl-randist. Para executar é preciso pegar a ultima versão com o git:


  git clone http://lambdatau.com/git/cl-randist

Depois de instalar as duas bibliotecas, não se esqueça de atualizar os links para o asdf.

O código do programa esta abaixo:


(eval-when (:compile-toplevel)
  (require 'clx)
  (require 'cl-randist)
  (defpackage #:xgauss
    (:use #:cl #:xlib :randist)
    (:export run)))

(in-package :xgauss)

(defun run (&key (width 400) (height 400)  (host ""))
  (let* ((display (xlib:open-display host))
  (screen (first (xlib:display-roots display)))
  (black (xlib:screen-black-pixel screen))
  (white (xlib:screen-white-pixel screen))
  (root-window (xlib:screen-root screen))

  (points (loop for i from 0 to 10000
      collect (cons
        (floor (random-normal (/ width 2) (/ width 10)))
        (floor (random-normal (/ height 2) (/ height 10))))))
       
  (gc (xlib:create-gcontext
     :drawable root-window
     :foreground black
     :background white))

  (my-window (xlib:create-window
       :parent root-window
       :x 0
       :y 0
       :width width
       :height height
       :background white
       :event-mask (xlib:make-event-mask :exposure
             :button-press))))
    (xlib:map-window my-window)
    (xlib:event-case (display :force-output-p t
         :discard-p t)
      (:exposure ()
   (dolist (pt points)
     (xlib:draw-point my-window
       gc
       (car pt) (cdr pt))))
      (:button-press () t))
    (xlib:destroy-window my-window)
    (xlib:close-display display)))

O resultado é este:

Vejam uma bela nuvem gaussiana :-)

O código é muito simples, a maior parte é burocracia para abrir uma janela e criar um graphic context, toda a ação esta nestes dois trechos, o primeiro que gera 10 mil pontos:


  (points (loop for i from 0 to 10000
      collect (cons
        (floor (random-normal (/ width 2) (/ width 10)))
        (floor (random-normal (/ height 2) (/ height 10))))))

E o segundo que manipula os eventos do X:


    (xlib:event-case (display :force-output-p t
         :discard-p t)
      (:exposure ()
   (dolist (pt points)
     (xlib:draw-point my-window
       gc
       (car pt) (cdr pt))))
      (:button-press () t))

Pensando como programador em C

2008-03-29T20:56:00.000-07:00

Estava tentando fazer um cache para valores de uma função. O resultado é a macro que esta abaixo.


  (defmacro with-cache (cache key &body body)  
    (with-gensyms (cached? value)
      `(if ,cache
    (multiple-value-bind (,cached? ,value) (has-key? ,cache ,key)
      (if ,cached?
          ,value
          (set-value ,cache ,key
          (progn
         ,@body))))
      ;; cache eq null -> no caching
    (progn ,@body))))

Nada mais simples. Se a variavel cache for nil body é executado, caso contrário testa-se para ver se key já esta no cache com a função has-key?, que caso o valor esteja presente já o retorna como segundo valor. Se o valor não estiver no cache, o valor retornado por body é armazenado e retornado por set-value.

A primeira implementação e has-key? e set-value utilizavam somente hash-table, o problema é que quando um valor é armazenado no cache ele ali permanece para sempre. Por isso eu precisava implementar alguma forma de controle.

Pensei em controlar o tamanho do cache, quando ele ficasse cheio eu eliminaria os valores mais antigos da hash table. O problema é descobrir uma função que retorna-se a quantidade de memória utilizada por um dado objeto, um equivalente sizeof do C. Só encontrei uma função específica do Allegro CL: find-object-size e mais nada.

Só que eu estava pensando como um programador em C, viciado em controle manual de memória. O que eu precisava era uma forma de avisar o Garbage Colletor que os valores no cache podiam ser deselocados quando fosse preciso.

Como quase sempre a solução para o meu problema já existia em Lisp, e se chama weak reference[1]. Uma weak reference é um ponteiro que não conta na hora de avaliar se um objeto pode ser jogado no lixo ou não. Em algumas implementações (SBCL incluído) é possível especificar no make-hash-table se os ponteiros vão ser do tipo weak com o parâmetro :weakness.

Existem diversas opção de weakness para hash-table, eu escolhe o tipo :value, que mantém o pair key,value enquanto houverem referências para o valor.

[1] http://www.haible.de/bruno/papers/cs/weak/WeakDatastructures-writeup.html

cl-randist no cliki

2008-03-07T20:17:00.000-08:00

Publiquei a minha biblioteca de geracao de variaveis aletaorias no cliki.

Tambem esta disponivel a documentacao do pacote.

Hospedando o cl-randist

2008-02-28T06:21:00.000-08:00

Criei um entrada para o meu projeto cl-randist no google code:

http://code.google.com/p/cl-randist/

A interface para criacão dos projetos é muito boa e ele oferece além de espaco para dowloads uma wiki e sistema de controle de versão. Infelizmente a única opcão é o SVN, portanto eu criei clones do meu repositório Git em outros dois hosts: github e gitorious

O github tem uma inferface melhor, mas talvez se torne pago após o período beta. O bom é que como o git é distribuído, a localizacão do repositório não é um ponto crucial.

PS: Agora que eu tenho uma wiki disponível, talvez eu crie vergonha na cara e escreva a documentacão do cl-randist.

Otimização de código em Lisp

2008-02-24T06:36:00.000-08:00

O Lisp pode funcionar com dynamic typing ou static typing, sendo que no segundo caso não é feita promoção automática de tipos como no C. Portanto se vc declara que uma função recebe double-float, ela só pode receber double floats.

Existem 3 tipos de declações de tipos no lisp:

1) (defun f (x)
(declare (type fixnum x))
(1+ x))

O declare serve como dica para o compilador otimizar o código. Dependendo de como estiverem as declarações de otimização podem este declare pode gerar códigos diferentes, dependendo das diretivas de otimização:

(defun speedy-f (x)
(declare (type fixnum x)
(otimize (speed 3)))
(1+ x))

Vai gerar um código otimizado para inteiros e que sinaliza um erro caso seja passado outro tipo de dado. Porém:

(defun speedy-unsafe-f (x)
(declare (type fixnum x)
(otimize (speed 3) (safety 0)))
(1+ x))

Vai gerar um código que aceita qualquer coisa e retorna um resultado errado, no meu computador:

(speedy-unsafe-f 1d0)

=> 8599862262

2) O coerce é uma função que gera explicitamente o código de conversão de tipo. Por exemplo

(loop for x from 1 to 10 sum (/ x))
=> 7381/2520

Já

(loop for x from 1 to 10 sum (/ (coerce x 'float)))
=> 2.9289684

3) Por fim existe a declaração da assinatura da função:

(declaim (ftype (function (fixnum) fixnum) f))
(defun f (x)
(declare (type fixnum x))
(1+ x))

Que pode ajudar na otimização na chamada de f.

Existe muito pouca documentação em como criar códigos otimizados no lisp. Experimentação, ler códigos otimizados de outros e as mensagens de compilação do SBCL (principalmente com o highlight do SLIME) são as maneiras de aprender como faze-lo.

[Anúncio] cl-randist

2008-02-23T20:48:00.000-08:00

O meu primeiro projeto em lisp é uma biblioteca para a geração de variáveis aleatórias segundo distribuições probabilísticas. O código esta disponível no repositório:

http://www.lambdatau.com/git/cl-randist.git

Para obter uma copia da biblioteca utilize o git[1], com o comando:

git clone http://www.lambdatau.com/git/cl-randist

Acho que o código já esta em uma condição utlizado por outras pessoas em fase beta (por conta e risco de cada um, eu testei a média e a variância de cada função para um número grande de valores, e os valores estão razoavelmente próximos do esperado).

Ainda não existe documentação, mas a biblioteca disponibiliza as seguintes funções:

random-uniform (Utiliza o gerador de números aleatórios da implementação, que no caso do SBCL é o Mersene Twister)

random-normal (implementa o algoritmo zigurate)
random-gamma (implementa oa algoritmo Marsaglia and Tsang)

random-beta
random-binomial
random-negative-binomial

random-poisson
random-exponential
random-multinomial
random-f
random-pareto

random-chi-square

Todas as função implementadas são traduções manuais do código em C da biblioteca GSL[2].

Com execeção da função para a geração de variáveis aleatórias discretas, que eu peguei o código do Mario S. Mommer[3]:

make-discrete-random-var

Exemplo de uso:

(asdf:oos 'asdf:load-op :cl-randist)

(use-package :randist)

(random-normal 10d0 2d0)

(let ((discrete (make-discrete-random-var #p(0.5 0.3 0.1 0.1))))
(print (funcall discrete)))

Bom proveito para quem se interessa por probabilidade e simulações.

[1] http://git.or.cz/
[2] http://www.gnu.org/software/gsl/
[3] http://prxq.wordpress.com/2006/04/17/the-alias-method/

How to Mess with clos in subtle ways

2008-01-04T05:48:00.000-08:00

The code below is wrong and stupid, but can generate very subtle bugs,especially if the class definition and de nstring-capitalize code aren't related

;; STEP 1: Define a class
(defclass foo ()
((xxx :initarg :xxx)))
(make-instance 'foo :xxx 1)

;; STEP 2: use nstring-capitalize in the keyword symbol
(nstring-capitalize (symbol-name :xxx))

;; STEP 3: try to make of instance of class
(make-instance 'foo :xxx 1)

The result is:

Invalid initialization argument: :XXX in call for class #.
[Condition of type SB-PCL::INITARG-ERROR]

See also:
Common Lisp Hyperspec, 7.1.2 [section]

Backtrace:
0: (SB-PCL::CHECK-INITARGS-2-PLIST (:XXX 1) # (:|Xxx|) T)

According to http://www.lispworks.com/documentation/HyperSpec/Body/f_symb_2.htm

"symbol-name returns the name of symbol. The consequences are undefined if name is ever modified."

Shame on me.

Pensamento do dia

2007-10-28T04:28:00.000-07:00

Programadores Lisp são legais, o difícil é juntar mais de um na mesma sala.

Bouncing Rectangle (OpenGL demo)

2007-10-07T18:14:00.000-07:00

Adaptei um dos exemplos do livro OpenGL Super Bible de C para Lisp. Adaptei para a biblioteca cl-opengl (em algum post anterior eu explico como instalar a biblioteca). O programa é bem simples, porém bonitinho, ele desenha um quadrado vermelho que fica zanzando pela tela.

A tradução é extremamente linear, basta trocar o prefixo da função pelo pacote apropriado e tirar o sufixo: glColor3f -> gl:color.

O ponto menos óbvio é definir os callbacks, pois é preciso criar uma função em lisp que será invocada pelo C. Por isso a função tem que ser definida utiliando defcallback do cffi. Os calbacks são referenciados com a função calback.

Quando a função bounce é executada ela trava o REPL, mas ela pode ser executada em um thread separada, através da função make-thread.


(sb-thread:make-thread #'bounce)

Uma experiência muito interessante é modificar o programa com ele rodando, seja em uma thread separada ou não. Modifiquem a função timer, por exemplo multiplicando por 2 o incremento da posição (linhas 28 e 29):


  (incf x1 (* 2 xstep))
  (incf y1 (* 2 ystep))

Após um C-c C-k no Slime o quadrado aumenta de velocidade imediatamente, tai algo que não rola em C ou Java.

Vejam o código em Lisp abaixo:


;; From OpenGL SuperBible, chap 2, pag 62
;;
;; Bouncing rectangle

(defparameter x1 0.0)
(defparameter y1 0.0)
(defparameter rsize 25)
(defparameter xstep 1)
(defparameter ystep 1)
(defparameter window-width 100)
(defparameter window-height 100)


(cffi:defcallback render-scene :void ()
  (gl:clear :color-buffer-bit)
  (gl:color 1.0 0 0)
  (gl:rect x1 y1 (+ x1 rsize) (- y1 rsize))
  (glut:swap-buffers))

(cffi:defcallback timer :void ((value :int))
  (declare (ignore value))
  (when (or (> x1 (- window-width rsize)) (< x1 (- window-width)))
    (setf xstep (- xstep)))
  (when (or (> y1 window-height) (< y1 (- rsize window-height)))
    (setf ystep (- ystep)))

  (incf x1 xstep)
  (incf y1 ystep)

  #|
  Check bounds. THis is in case the window is made
  smaller while the rectangel is bouncing and the
  rectangle suddenly finds itself outside the new
  clipping volume
  |#
  (if (> x1 (+ window-width (- rsize) xstep))
      (setf x1 (- window-width rsize 1))
      (when (< x1 (- (+ window-width xstep)))
 (setf x1 (- (+ window-width 1)))))

  (glut:post-redisplay)
  (glut:timer-func 33 (cffi:callback timer) 1))

  
(cffi:defcallback change-size :void ((w :unsigned-int) (h :unsigned-int))

  ;; Prevent divide by zero
  (when (eq h 0)
    (setf h 1))

  (gl:viewport 0 0 w h)
  (gl:matrix-mode :projection)
  (gl:load-identity)
  (let ((aspect-ratio (/ w h)))
    (if (<= w h)
 (gl:ortho -100 100 (/ -100 aspect-ratio) (/ 100 aspect-ratio) 1 -1)
 (gl:ortho (* -100 aspect-ratio) (* 100 aspect-ratio) -100 100 1 -1))))

(defun setup-rc ()
  (gl:clear-color 0.0 0.0 1.0 1.0))

(defun bounce ()

  (glut:init "SBCL")
  (glut:init-display-mode :double :rgba)
  (glut:create-window "Bounce")
  (glut:init-window-size 800 600)
  (glut:display-func (cffi:callback render-scene))
  (glut:reshape-func (cffi:callback change-size))
  (glut:timer-func 33 (cffi:callback timer) 1)
  (setup-rc)
  (glut:main-loop))

E o código original em C esta aqui:


#include < GL/gl.h >
#include < GL/glu.h >
#include < GL/glut.h >
#include < stdio.h >

GLfloat x1 = 0.0f;
GLfloat y1 = 0.0f;
GLfloat rsize=25;

GLfloat xstep = 1.0f;
GLfloat ystep = 1.0f;

GLfloat windowWidth=100;
GLfloat windowHeight=100;

void RenderScene() {
  glClear(GL_COLOR_BUFFER_BIT);

  glColor3f(1.0f,0.0f,0.0f);
  glRectf(x1,y1,x1+rsize,y1-rsize);
  glutSwapBuffers();
}


void TimerFunction(int value) {

  if (x1 > windowWidth-rsize || x1 < -windowWidth) { 
    xstep = -xstep;
  }

  if (y1 > windowHeight || y1 < -windowHeight + rsize) {
    ystep = -ystep;
  }

  x1 += xstep;
  y1 += ystep;

  // Check bounds. Tjos om case tjhe window is made smaller whie
  // the rectangle is bouncing and the rectangle suddenly finds
  // itself outside the new clipping volume
  if (x1 > (windowWidth-rsize + xstep))
    x1 = windowWidth-rsize-1;
  else
    if (x1 < -(windowWidth + xstep))
      x1 = -windowWidth - 1;

  if(y1 > (windowHeight +ystep))
    y1 = windowHeight - 1;
  else
    if(y1 < -(windowHeight - rsize + ystep))
      y1 = -windowHeight + rsize - 1;
  
  glutPostRedisplay();
  glutTimerFunc(33,TimerFunction,1);
}

void ChangeSize(GLsizei w,GLsizei h) {
  GLfloat aspectRatio;

  if (h==0)
    h=1;

  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  aspectRatio=(GLfloat)w/(GLfloat)h;
  
  if (w <= h)
    glOrtho(-100.0,100.0,-100.0/aspectRatio,100.0/aspectRatio,1.0,-1.0);
  else
    glOrtho(-100.0*aspectRatio,100.0*aspectRatio,-100.0,100.0,1.0,-1.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

void SetupRC() {
  glClearColor(0.0f,0.0f,1.0f,1.0f);
}

int main(int argc,char *argv[]) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
  glutCreateWindow("Bounce");
  glutInitWindowSize(800,600);
  glutDisplayFunc(RenderScene);
  glutReshapeFunc(ChangeSize);
  glutTimerFunc(33,TimerFunction,1);
  SetupRC();
  glutMainLoop();

  return 0;
}

No Linux este programa é compilado com o comando:


gcc bounce.c -o bounce -lGL -lGLU -lglut -lm

Desdefinindo coisas

2007-09-15T07:22:00.000-07:00

Em lisp o ambiente de desenvolvimento e de execução é mesmo, permitindo que o programador crie o programa por partes, fazendo experiências em cada estágio do desenvolvimento. O problema é que a imagem fica poluída com funções e variáveis que foram abandonadas.

Para se livrar de um função indesejada existe a função fmakunbound:


(defun foo (x) 
   (+ x 1))

(foo 1)
=> 2

(fmakunbound 'foo)

(foo 1)
=> The function F is undefined.

De maneira equivalente existe a função makunbound para eliminar variáveis.


(devar x 1) 

x
=> 1

(makunbound 'x)

x
=> The variable X is unbound.

Pacotes também podem ser apagados, neste caso com a função delete-package:


(defpackage foo (:use :cl))
(delete-package 'foo)

Só falta descobrir como apagar um classe.

Macros Anafóricas

2007-09-09T12:33:00.000-07:00

Imagine uma função resolve-system que retorna a solução de um sistema de equações, ou nil caso não haja solução para este sistema. Agora considere o código abaixo:


(if (resolve-system system)
     (print (result-system system))
     (print "System without answer"))

Note que resolve-system, que pode ser uma função complexa e demorara, é chamada duas vezes em seguida, ou seja, este código demora o dobro de tempo que deveria. A solução eficiente para isto é escrever o seguinte código:


(let ((answer (resolve-system system)))
  (if answer 
      (print answer)
      (print "System without answer")))

Porém o código acima é muito menos elegante que o anterior. Uma solução elegante para este problema de otimização é o uso de Macros Anafóricas (anaphoric macros), como sugerido por Paul Graham no livro On Lisp[1]:


(defmacro aif (test-form then-form &optional else-form)
  `(let ((it ,test-form))
     (if it ,then-form ,else-form)))

Utilizando aif o nosso exemplo fica assim:


(aif (resolve-system system)
     (print it)
     (print "System without answer"))

Cuja a macro expansão é:


(let it (resolve-system system)))
  (if it 
      (print it)
      (print "System without answer")))

Exatamente como no código que havíamos optimizado na mão. Podemos utilizar a macro aif para definir uma série de outras macros anafóricas: awhen, awhile, acond, etc, e como queremos utilizar estas macros em diversos projetos diferentes faz todo sentido coloca-las em uma pacote próprio, por exemplo no pacote anaphoric. Porém neste momento a macro para de funcionar! Acabamos de gerar um bug extremamente sutil, que só pode ser detectado quando fizermos a macro expansão em um pacote diferente do qual a macro foi definida:


(macroexpand-1 '(aif (resolve-system system)
                 (print it)
                 (print "System without answer")))

-> (let anaphoric::it (resolve-system system)))
    (if anaphoric::it 
        (print it)
        (print "System without answer")))

Notem que o símbolo it que passamos como argumento da macro esta definido no pacote atual, porém o it do let e do if foram definidos no pacote anaphoric, e portanto se referem a valores diferentes. Uma primeira solução é explicitar o pacote do símbolo it:


(aif (resolve-system system)
     (print anaphoric::it)
     (print "System without answer"))

Porém nós quebramos a nossa abstração, pois temos que lembrar o pacote onde aif foi definido, o que pode gerar facilmente todo o tipo de bug. Mas no lisp podemos utilizar todo o sistema de manipulação de listas para manipular o código do programa:


(defun change-it-package (from)
  (subst 'it (find-symbol "IT" *package*) form))

(defmacro aif (test-form then-form &optional else-form)
  `(let ((it ,test-form))
     (if it 
         ,(change-it-package then-form) 
         ,(change-it-package else-form))))

O ponto mais difícil deste código é encontrar o símbolo it no pacote atual, para isto utilizamos a função find-symbol, e o fato da variável *packages* ter escopo dinâmico. Podemos ver que o resultado da macro expansão agora é o correto:


(macroexpand-1 '(aif (resolve-system system)
                 (print it)
                 (print "System without answer")))

-> (let anaphoric::it (resolve-system system)))
    (if anaphoric::it 
        (print anaphoric::it)
        (print "System without answer")))

Current Recomended Libraries

2007-08-14T17:31:00.000-07:00

Olhem esta lista de recomendações de bibliotecas para Lisp:

http://www.cliki.net/Current%20recommended%20libraries

Não é muito grande, mas só tem as bibliotecas de primeira linha.

McClim

2007-06-25T19:17:00.001-07:00

O McClim é a uma implementação free do Toolkit criado para as Lisps Machines. Nas última versão ele suporta (experimentalmente) widgets do GTK. Vejam com seus próprios olhos:


(asdf-install:install :mcclim)
(asdf:oos 'asdf:load-op :clim-gtkairo)
(asdf:operate 'asdf:load-op :clim-examples)
(clim-demo::demodemo)

Maxima

2007-06-11T18:02:00.000-07:00

Antes do Maple e do Mathematica havia o Macsyma, o mais avançado sistema de matemática simbólica dos anos 80, desenvolvido em Lisp, foi um dos principais motivadores para a evolução do Lisp. O sistema foi desenvolvido pelo MIT com dinheiro do Departamento de Energia, porém alguns pesquisadores resolveram ficar ricos com o programa, montaram uma empresa e se apoderaram do software. Este ato gerou dois resultados:

o código fonte do Macsyma foi quase perdido para sempre,
Um pesquisador chamado Richard Stallman iniciou uma cruzada contra o software proprietário.

Felizmente em 1982 William Schelter conseguiu permissão do DOE para uma versão Free Sofware do Macsyma, rebatizada de Maxima e disponível e mantida até hoje.

Outro fruto do AI Lab do MIT foi o editor emacs, que em comum com Maxima possui, além da origem, a possibilidade de ser extendido em Lisp. Uma das inúmeras extenções é o imaxima, que combina o
emacs, o maxima e o TeX, o sistema de digramação eletrônica criado pelo Donald Knuth.

O resultado de todo este blah, blah, blah, pode ser resumido a esta figura:

Uma alternativa completamente free de software matemático, produzido pelo trabalho conjunto dos melhores programadores do século XX.

O Maxima pode ser baixado aqui, e felizmente ele funciona na melhor implementação de Lisp disponível.Tendo o emacs e o Maxima basta seguir esta receita de bolo.

2 Questões sobre Scheme

2007-05-03T20:35:00.000-07:00

1) Se o Common Lisp é bloated porque todo mundo acaba criando a sua própria biblioteca de rotinas para complementar ele?

2) Os sistemas de macros do schema são mais seguros mas permitem fazer anaphoric macros?

Lisp no MacOS X

2007-04-29T20:22:00.000-07:00

A grande vantagem do Mac OS é que é Unix e portanto todas as ferramentas de costume estão lá. A primeira e mais importante é o emacs, ele já vem instalado, porém somente uma versão texto. Mas existe a projeto MacPorts (antigo DarwinPorts) que permite instalar todos os programas open source com um comando.

Com o MacPort dá para instalar o feijão com arroz: Mysql, Postgres, Apache2, Ruby, Rails, etc. Tem o emacs tb, mas a melhor opção é utilizar o beta do emacs22 que tem suporta nativo para o Carbon (Uma das API's gráficas do OS X). Ok, temos emacs funcionando maravilhosamente bem. O segundo passo é escolher qual Lisp usar. O mundo apple conta com OpenMCL, porém ele só suporta PPC e x64, bad news, só tenho um Core Duo 1 que não aceita extenção de 64 bits :-(

Mas tudo bem, a minha primeira escolha de Lisp era o SBCL. A versão do sita, tanto o binário quanto a source funcionam muito bem (versão 1.0.4 e 1.0.5). O próximo passo é instalar alguns pacotes. Primeiro os mais fáceis, cl-ppcre, split-sequence. Tudo ok. Em seguida um mais difícil hunchentoot. Primeiro problema, a CL+SSL não acha a lib ssl em /usr/lib/libssl.so, isso é porque no darwin as bibliotecas não tem terminação .so e sim .dylib. Modifiquei o CL+SSL para procurar a versão do MacPort em /opt/local/lib/libssl.dylib, tudo funciona perfeitamente. Mandei um patch para os autores da biblioteca.

Segundo problema, o slime esta esquisito e o hunchentoot trava o REPL quando invocado. Tendo criar um thread e descubro que o SBCL foi configurado para unitrheads. Bad news. Lendo o arquivo INSTALL descubro como ativar as threads, deve-se criar um arquivo chamado customize-targets-features.lisp com o seguinte conteúdo:


  (lambda (features)
    (flet ((enable (x)
             (pushnew x features))
           (disable (x)
             (setf features (remove x features))))
      ;; Threading support, available only on x86/x86-64 Linux, x86 Solaris
      ;; and x86 Mac OS X (experimental).
      (enable :sb-thread)))

Recompilar e pronto. Beleza, tudo funcionando, porém estou vivendo no wild world do software experimental.

Site novo

2007-04-23T21:08:00.000-07:00

Registrei o domínio lambdatau.com e estou tentando organizar o meu conhecimento de Lisp e programação em geral (além algumas outras coisas) de uma forma mais coerente do que no blog. Não tem nada ainda muito pronto, só um pouco de texto e o layout (que é de quase somente usar ASCII site, inclusive nas ilustrações).

Na verdade eu estou fazendo esse poste para aumentar o número de links para o site e assim deixar o google feliz :-)

Chicken Scheme

2007-04-14T20:52:00.001-07:00

Tai uma boa devesa do Chicken Scheme: http://lenz.unl.edu/wordpress/?p=15

C forall

2007-04-07T20:51:00.000-07:00

Há algo de novo no reino da programação de baixo nível. Um grupo da Universidade de Waterloo (CA) esta propondo uma extenção para o C chamada de Cforall. Assim como o C++ foi uma extenção do C inspirada no Smalltalk o Cforall é uma extenção do C inspirada, na minha humilde opnião, no CLOS.

Mais sobre a Lucid Inc.

2007-04-02T22:32:00.000-07:00

Contuando a minha pesquisa sobre a história do lisp encontrei um conjunto de ensaio de Richar P. Gabriel fundador de Lucid, inc chamado Patters Of Software. Apartir da página 175 ele conta a história da ascenção e queda da empresa. É uma história triste pois a Lucid foi criada para ser a melhor empresa de Lisp e dominar o mercado, ela contratou as melhores pessoas, o próprio Gabriel estudou 25 nas melhores escolas, foi aluno do John McCarthy em pessoa e terminou em um retumbante fracasso. A importância da Lucid em sua época pode ser medida através da preocupação de um de seus principais concorrentes, a Franz Inc, como esta relatado neste artigo.

A Lucid tinha, dinheiro, as melhores cabeças, grandes contratos, etc, mas faliu. A Franz que era o Underdog na época esta ai até hoje e dando lucro. Esta é um ótimo exemplo de como gerir um empresa de software, a Franz fez o que os clientes queriam e foi ganhando o seu dinheirinho enquanto que a Lucid queria criar a próxima grande revolução.

Outro aspecto interessante da Lucid é que ele era uma empresa com um produto de sucesso que foi abandonado em detrimento à um novo projeto que terminou em fracasso. No caso o produto era o Lucid Lisp, que foi usado como cash cow para o projeto de um ambiente de desenvolvimento para C++, porém isso afetou a moral dos desenvolvedores e afastou os clientes que percebem a queda na qualidade do atendimento e lendidão no lançamento de novas versões. O novo projeto miraboloso se revelou um erro, mas o projeto a Lucid já havia se queimado com os clientes de Lisp. Essa história é muito parecida com a da infocom descrita neste paper.

A última lição sobre o fracasso da Lucid é o perfil do CEO que foi contratado no fim da vida de empresa o Bob, um bussness man, menos inteligente que os desenvolvedores que ele administrava e que achava que você pode administrar uma empresa sem entender o que ela faz, algo parecido o que ocorreu com a Apple no período em que o Steve Jops esteve longe. Além de tudo Bob era uma pessoa com caracter duvidoso, o que só acelerou a derrotada da Lucid. Muitas fezes os Geeks relevam defeitos de pesonalidade de pessoas do mercado pois acham que o mundo dos negócios são assim mesmo e que eles não tem condições de fazer o que esses caras fazem, afinal eles são falastrões e tem "contatos", isso é um grande erro, pois em geral as pessoas que posam de bussness men são pura e simplesmente pessoas burras que decoraram um discurso pronto.

Isso me faz pensar que o google acertou fortemente em duas decisões: Não chamar uma pessoa de fora para administrar a empresa e agir de maneira honesta. Agir de maneira honesta é algo que geralmente se paga pois se você é desonesto o "good will" se quebra, e mais cedo ou mais tarde a sua empresa acaba sendo abandonada por todos.

Garbage Collector e Falencias.

2007-04-01T18:08:00.000-07:00

É extremamente interrante a história de empresas que desenvolveram versões comerciais do Lisp. A Symbolics surgiu do MIT AI lab para produzir Lisp Machines, porém a revolução dos microcomputadores tirou a vantagens que os processadores "custom made" tinham, a symbolics foi suplantada pelas empresas que fabricavam compiladores de lisp para processadores comums como a Lucid e a Franz.

Porém a Lucid teve problemas de gerência e resolveu se reinvetar como uma empresa que desenvovia IDE's para C++ e abandonar o ainda lucrativo negócio do Lisp. Com o fim das verbas fartas tanto a Lucid quanto a Symbolics sairam dos negócios. A Lucid acabou sendo comprada pela Harlequin que desenvolvia versões comerciais de linguagens de alto nível, além do Lisp eles desenvolveram versões para o ML, Dylan e PostScript.

Muitos progamadores da Symbolics e da Lucid foram contradados pela Harlequin, e entre 1994 e 2001 houve um grupo dedicado exclusivamente ao desenvolvimento do sistema de coletor de lixo, incluindo P. Tucker Winthington, que mantinha o coletror de lixo da Symbolics.

A roda da falência girou mais uma vez e a Harlequin foi comprada pela Global Graphics que estava interessada somente na implementação de PostScript deles. A parte de Dylan se tornou a Functional Objects Inc que deixou de funcionar em 2006 e o DylanWorks agora é o projeto OpenDylan. A parte de Lisp e IA se tornou a Xanalysis que opera até hoje com o LispWorks.

Já o grupo de Coletores de Lixo formou uma empresa de consultoria e liberou o código do coletor de lixo da Harlequin como o projeto open source MPS: Memory Pool System.

O sistema parece ser um dos mais sofsticados que exista, ele esta descrito neste paper. Os autores parecem felizes com a falências de suas antigas empresas pois agora podem mostrar para o mundo as suas idéias, pois antes tudo que haviam desenvolvido eram segredos industriais.

Lisp hacks

2007-02-23T13:05:00.000-08:00

Achei no google um site com pequenos utilitários para lisp: Lisp Hacks.

Me chamou a atenção as melhorias para o defpackage, em especial o exemplo de como criar versões genéricas dos operadores artitiméticos, que é o primeiro passo para o maravilhoso mundo dos operator overloads.

Claro que a performance vai ser afetada, mas é só colocar o seu código de number crushing em outro pacote e pronto!

Mudança de filesystem

2007-01-24T21:30:00.000-08:00

Acabei de migrar o meu home de reiserfs para xfs. Fiz isso primeiro porque hoje acabei de ver um reiserfs ir para as cucuias por coisas de um único bad block, o filesystem todo, mais de 300 GB perdidos por causa de um block defeituoso. À 2 meses atrás outra instalação também teve um problema estranho.

Outro motivo para abandonar o reiserfs é que acredito que o seu desenvolvimento vai ser prejudicado depois do que aconteceu com o Hans Reiser.

Mas voltando ao XFS, ele é rápido, e não estou falando de rápido do tipo: "Olha como ele se sai bem em benchmarks", é rápido no sendido de que eu estou restaurando meu backup e computador não para devido ao IO intenso, esse é melhor tipo de de velocidade para um Desktop, a que melhora a responsiviness.

String append

2007-01-20T06:42:00.000-08:00

Esta rolando uma discução no comp.lang.lisp sobre a maneira mais rápida de concatenar string. Foram sugeridas as três alternativas abaixo:



(defun string-append0 (&rest strings)
  (declare (optimize (speed 3) (safety 0)))
  (apply #'concatenate 'string strings))

(defun string-append1 (&rest strings)
  (declare
   (optimize (speed 3) (safety 0)))
  (with-output-to-string (out)
    (loop for str in strings
         while str
       do (write-string str out))))

(defun string-append2 (&rest strings)
  (declare
   (optimize (speed 3) (safety 0)))
  (let ((output (make-array 0 :adjustable t :fill-pointer 0 :element-type 'base-char)))
    (loop for str in strings do
         (loop for char across str do
              (vector-push-extend char output)))
    output))


(defun string-append (&rest strings)
  (declare
   (optimize (speed 3) (safety 0)))
  (loop
     with len fixnum = (loop for str string in strings sum (length str))
     with output = (make-array len :element-type 'base-char )
     with  pos fixnum = -1

     for str string in strings
     while (< pos (1- len))
     do
       (loop for char across str
          do (setf (char output (incf pos)) char ))
     finally (return output)))

Executei o seguinte teste para avaliar o desempenho das implementações:


(eval-when (:execute)
  (declare (optimize ((speedy 3) (safety 0))))

  ; Cria uma list com 100 strings de 30 caracteres 
  (let ((lst (loop for i from 1 to 100
     collect
     (make-array 30 :element-type 'base-char :initial-element #\X))))

    ; Testa todas as funlções
    (dolist (f (list #'string-append0
       #'string-append1
       #'string-append2
       #'string-append))
      (format t "Running ~a~%" f)
      (time (loop repeat 1000 do (apply f lst))))))

Rodando no SBCL 1.0.0 em um Athlon 64 obtive os seguintes resultados:


Running #
Evaluation took:
  0.393 seconds of real time
  0.358946 seconds of user run time
  0.004999 seconds of system run time
  [Run times include 0.026 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  33,662,880 bytes consed.
Running #
Evaluation took:
  0.742 seconds of real time
  0.649901 seconds of user run time
  0.008999 seconds of system run time
  [Run times include 0.04 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  74,006,848 bytes consed.
Running #
Evaluation took:
  0.977 seconds of real time
  0.666898 seconds of user run time
  0.015997 seconds of system run time
  [Run times include 0.041 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  10,559,808 bytes consed.
Running #
Evaluation took:
  0.918 seconds of real time
  0.112983 seconds of user run time
  0.007999 seconds of system run time
  0 calls to %EVAL
  0 page faults and
  4,640,224 bytes consed.

E o vencedor é STRING-APPEND, a função que utiliza o concatenate ficou em segundo lugar.

Python não é Lisp

2007-01-19T18:47:00.000-08:00

Dentre as linguagens que eu considerava com bom Design, uma era o python. Porém hoje eu achei um artigo explicando como que os clusures funcionan em python, e como contornar as suas dificiências: Python Closures Pt. 2.

Depois de esse texto eu compreendi porque querem tirar o operador lambda do pyton, sem uma semantica clara para o escopo das variáveis este operador é muito pouco útil.

Na minha opnião uma das grandes vantangens do Lisp é ter a semantica muito bem definida, o que evita surpresas desagradáveis, como esta do python.

CLG funcionando

2007-01-15T18:13:00.000-08:00

Ontem eu havia baixado o CLG do CVS, porém não funcionou. Deu um erro estranho no módulo que automaticamente exporta os simbolos do pacote GTK. Escrevi um e-mail para a lista de discussão e hoje de manhã o Espen S Johnsen, autor do CLG, me respondeu dizendo que havia consertado o erro no CVS.

Mais um cvs update e fialmente consegui rodar o testgtk.lisp!!!!

Rodar o CLG era um dos desafios em Lisp que eu havia me auto-imposto, de brinde veio com binding para o cairo tb.

Pouco a pouco o problema de falta de bibliotecas no Lisp vai se resolvendo.

Linux e a décima regra de Greenspun

2007-01-12T07:47:00.000-08:00

"Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp."
Greenspun's Tenth Rule

É interssante como nos deparamos com esta regra a todo instante. Hoje estava lendo sobre problemas de inicialização de drivers no kernel do linux(LWN), o problema é que quando ocorre uma falha no carregamento do driver, os recursos alocados tem que ser desalocados de uma maneira coerente. Por isso foi proposta uma API que administra automaticamente alocação de recursos. Interessante como que desenvolver para o kernel do linux vai se tornando cada vez mais parecido com o desenvolvimento em uma linguagem de alto-nível.

Um sistema operacional feito em Lisp acaba não parecendo uma idéia tão louca quando vemos o que realmente é feito em um sistema operacional de alto-nível.

Widgets para Lisp

2007-01-01T17:54:00.000-08:00

Vou desenvolver uma aplicação gráfica em lisp e para isso estou escolhendo qual biblioteca de widgets utilizar. Tenho feito algumas experiências, e gostaria de compartinhar com vocês o que eu aprendi.

As primeiras bibliotecas que me chamaram a atenção foram as que utilizam a biblioteca Cells do Ken Tilton. A Cells cuida da propagação de valores entre instantâncias, isso permite que o valor que seja alterado na camada view seja automaticamente propagado para o model da sua aplicação, achei interessando pois essa foi uma das coisas que eu achei mais interessante no Smalltalk. Nessa categoria temos:

cells-gtk: Utiliza o gtk como widgets. Me parece o mais desenvolvido dos três, porém eu não consigo rodar ele no SBCL.

celtik: Utiliza o TK como widgets, aparentemente vai ser disponibilizado junto com o Cells 3.0, atualmente tem que ser baixado via CVS

cello: Me parece o projeto mais ambicioso, pois utilza OpenGL para desenhar as widgets, é também o menos acabado.

Apesar de simpatizar com o Cells, a única widget que funcionou direto foi o LTK, esta utiliza um pipe para enviar comandos para o TK. Vale resaltar a boa documentação. Ele implementa quase toda a API do TK, porém faltam alguns aspectos da Text Widget, mas felizmente o código e claro e da para adiciona-las facilmente.

Por fim eu testei a clg, outra biblioteca baseada na GTK, porém encontrei diversos problemas para compila-la.

Outra opção são:

lgtk - Aparentemente sem desenvolvimento ativo.

McClim - Implementação livre do sistema "padrão" de widgets do Lisp. Me parece interessante, porém meu medo é a falta de documentação e a aprência "antiquada" desta widget. Vejam este screenshot.

Ruby

2006-11-28T03:16:00.000-08:00

Estou aprendendo ruby, e estou achando ele uma linguagem muito legal. Gosto principalmente dos codeblocks, mas é interessante que por mais features que se adiciona em uma linguagem sempre fica uma que vc gosta de fora.

Algo que eu sinto muita falta é o REDUCE do lisp, veja este código em LISP:

(reduce #'max (mapcar #'parse-integer (split-sequence #Space "3 42 1")))

Não existe maneira mais elegante de splitar uma string e pegar a maior dos elementos. Ruby chega quase lá:

"3 42 1".split(" ").map {|x| x.to_i }

Consigo splitar e transformar em inteiros, porém, para achar o máximo eu tenho que usar uma variável a mais e fazer um código muito mais deselegante:


lst="3 42 1".split(" ").map {|x| x.to_i }
max=-1
lst.each do |x|
  if (x > max)
      max = x;
  end
end

print max,"n"

Uma pena.

Todos as funções de um pacote.

2006-11-24T08:55:00.000-08:00

Hoje rolou uma discussão legal na comp.lang.lisp sobre como fazer para
listar todas as funções de um pacote, uma dúvida que eu tinha já à
algum tempo. O resumo da discussão é o código abaixo:


(defun doc-pkg-fns (pkg)
(loop with home-package = (find-package pkg)
     for sym being each symbol of home-package
     when (handler-case (symbol-function sym) (undefined-function () nil))
     when (eq (symbol-package sym) home-package)
     do (format t "~a~%~a~%~%" sym
                (or (documentation sym 'function) ""))))

Para ver todas as funções, com decumetação, do pacote common-lisp digite:

(doc-pgn-fns (find-package :common-lisp))

A discussão completa esta em: c.l.l

Serialization

2006-08-21T20:44:00.000-07:00

Todo o trabalho e a discussão envolvendo serialização de objetos em diversas linguagens ocorre porque as pessoas ignoram que "code is data".

Continuations em Java.

2006-05-30T19:38:00.000-07:00

Continuation Passing Programming é um tópico que me chama à atenção de tempos em tempos. Achei um artigo na IBM que trata desse assunto para o ambiente java. A biblioteca Coccon do Apache permite programar usando continuations em java. Já tinha dado uma olhada no Coccon há uns 3 anos atrás, quando procurava uma ambiente para publicar xml's, mas na época a biblioteca estava acima da minha capacidade e me pareceu meio overkiller para oque eu queria fazer.

Atualmente estou desenvolvendo para o Tapestry que tem uma abordagem de componentes, porém o uso de continuation poderia ser combinado com o uso de componentes para se fazer um ambiente muito sofisticado para desenvolvimento web.

Matemáticos programando

2006-05-23T21:31:00.000-07:00

Trecho de uma entrevista com o criador do STL:

"Question:
What is the origin of STL? Has STL been conceived to be what it is now, that is "the" C++ Standard Library, or does it come from some other project? Could you tell us a history of STL?

Answer:
In 1976, still back in the USSR, I got a very serious case of food poisoning from eating raw fish. While in the hospital, in the state of delirium, I suddenly realized that the ability to add numbers in parallel depends on the fact that addition is associative. (So, putting it simply, STL is the result of a bacterial infection.) In other words, I realized that a parallel reduction algorithm is associated with a semigroup structure type. That is the fundamental point:
algorithms are defined on algebraic structures. It took me another couple of years to realize that you have to extend the notion of structure by adding complexity requirements to regular axioms. And than it took 15 years to make it work. (I am still not sure that I have been successful in getting the point across to anybody outside the small circle of my friends.) I believe that iterator theories are as central to Computer Science as theories of rings or Banach spaces are central to Mathematics. Every time I would look at an algorithm I would try to find a structure on which it is defined. So what I wanted to do was to describe algorithms generically. That's what I like to do. I can spend a month working on a well known algorithm trying to find its generic representation. So far, I have been singularly unsuccessful in explaining to people that this is an important activity. But, somehow, the result of the activity - STL - became quite successful."

Matemáticos programando...

O resto da entrevista esta aqui: http://www.stlport.org/resources/StepanovUSA.html

GO

2006-02-22T17:54:00.000-08:00

Lisp é o GO das liguagens de programação. Ambos tem a mesma elegância na simplicidade.

Aprendendo C#

2005-12-01T16:06:00.000-08:00

Estou aprendendo C# para um trabalho. Algumas pessoas falam que C# ~ Java, mas diria que C# ~ Java + Delphi, pois o sistema de eventos e propriedades dele me lembra muito o delphi devido ao uso de "métodos" especiais e palavras reservadas para coisas que são específicas para GUIs.

Lí em algum lugar que a Microsoft contratou levas inteiras de programadores da Borland, isso talvez explique a relação entre o C# e o Delphi. Alguns dizem que todo o dotNet surgiu das pessoas que saíram da Borland. Já Senti uma melhora "cultura microsoft" de desenvolvimento: eles não usam notação húngara!!!

From comp.lang.lisp

2005-11-11T20:05:00.000-08:00

"We are the Knights of Lambda Calculus. You must return here with a lexical closure... or else you will never pass through this code alive!"

Mais informações em: Illuminati ou Wikipedia.

LispM open source.

2005-10-03T18:50:00.000-07:00

O MIT liberou o código fonte do LispM sobre licença BSD, os arquivos estavam guardados em fitas de 9 trilhas e foram recuperados do limbo.

Esse código é a base dos Lisp Machines que surgiram nos anos 80. Duas empresas vendiam computadores que executavam diretamente código em LISP, a Symbolics e a LMI, ambas fundadas por ex-hackers do MIT. Esse código tem um importância histórica muito grande, pois foi por causa de uma brica com os caras da Symbolics que o Richard M. Stallman iniciu a GNU.

Mais comentários podem ser encontrados neste blog.

Microsoft, o passado da computação

2005-09-26T15:34:00.000-07:00

Pelo o que eu li nesse artigo , a microsft está 20 anos no passado da engenharia de software, imersa na culura de programadores dos ugle hacks. É algo impressionante e desolador.

C# 3.0

2005-09-18T16:25:00.000-07:00

Acabei de ler um artigo no slashdot sobre o C# 3.0. Dessa vez a Microsoft mandou bem, eles vão introduzir type inference , lambdas e tipos anônimos na linguagem, recursos tradicionais de LISP e ML. Quem sabe esse movimento faça com que Sun evolua realmente o Java, pois:

MeuTipoComNomeMuitoLongo x = new MeuTipoComNomeMuitoLongo()

É muito estúpido de digitar. Agora é esperar o pessoal do Mono implementar essas características.

Java

2005-08-09T15:12:00.000-07:00

Java é a linguagem que poderia ser descente, mas não sei porque o pessoal da sun insiste em fazer ela ser a pain in the ass por um série de bobagens.

Esse artigo expõe diversos pontos interessantes sobre as falhas do java.

Viaweb

2005-07-29T07:46:00.000-07:00

Achei um texto do Paul Graham, na qual ele explica melhor o funcionamento da viaweb. Ele usa continuations implementadas como closures. Interessante a abordagem para criação das páginas, elas são escritas em uma linguagem chamada RHTML, que no fundo não passa de um conjunto de macros de lisp. Interessante que eles não utilizando banco de dados para aplicação, os dados são carregados na memória e armazenados como arquivos no disco.

Symbolics

2005-07-09T12:39:00.000-07:00

Interessante a estória da Symbolics, uma empresa da época romântica da industria de informática, onde cada fabricante tinha a sua própria linguagem de programação, os meninos e os homens eram separados pelo BASIC, hahhaha.

O site da wikipedia é legal:

http://en.wikipedia.org/wiki/Symbolics

O link com a estória vista do ponto de vista do Richard Stallman também é bem interessante:

http://www.gnu.org/gnu/rms-lisp.html

Isso me faz pensar o que teria acontecido se o lisp tivesse se tornado a linguagem mainstream em vez do C. O C ganhou devido ao UNIX e devido à microsoft posteriormente ter adotado ele, ninguém comenta mas o DOS teve muita influência do UNIX, a microsoft inclusive teve uma versão do UNIX, o XENIX.

Com o lisp teriamos programas e programadores mais preocupados com programas que funcionam do que programas que funcionem 0.1% mais rápido.

Lisp com GTK

2005-07-08T19:02:00.000-07:00

O toolkit canonico do lisp é o CLIM, a implementalção free que existe é o McCLIM. Mas me pareceu muito old-fashion, com cara de Motif.

Existem alguns bidings de GTK para lisp. O que me pareceu mais sofisticado é o Cells-GTK. Ele é baseado em um framework chamado cells que me lembrou um pouco o MVC do smalltalk, principalmente a parte de ValueHolders.

Consegui rodar o demo no CMUCL. O problema que a documentação tanto do Cells-GTK quanto do Cells é muito ruim. Preciso fazer engenharia reversa nos demos.

Lisp na Web

2005-07-08T18:53:00.000-07:00

Desenvolvimento para web é um saco. Perl não é estruturado o suficiente, java exige muita digitação e é lento. Lisp me parece uma boa solução.

Existe um framework que parece ser bem sofisticado, o UncommonWeb. Dizem que ele é um framework baseado em continuations (coisa bem esotérica, digamos que é a generalização da excessões e que são utilizados para mais coisas do que somente tratar erros).

Ainda não consegui fazer ele funcionar. O que eu consegui é utilizar o mod_lisp com o tbnl. Você coloca um processo lisp para rodar e o apache se comunica com ele, de maneira similar que do que se faria com o tomcat. (Não use o cl_modlisp, me pareceu muito tosco, o tbnl me pareceu muito melhor).

Uma coisa que eu fiz que nem fudendo um programador de java consegue. Você roda o lisp usando um programa chamado detachtty. É um programa em C simples, similar ao nohup, ele desassocia o seu processo lisp do terminal, vc pode portanto deslogar e ele continua rodando em background. Só que o detachtty abre um file socket onde vc indicar, dai é só utilizar o programa attachtty para associar novamente o processo ao seu terminal.

Ou seja vc coloca o servidor para rodar e vai embora. Se ocorrer qualquer problema é só logar nele e executar qualquer comando lisp, qualquer programa, etc. Não dá para fazer isso no tomcat.

Imagina fazer um painel de controle gráfico que controla a sua aplicação WEB.

Utilizar o lisp como script language

2005-07-08T18:49:00.000-07:00

Aprendi como utilizar o lisp como uma script language, tipo perl.

Você coloca no inicio do seu script:

#!/usr/bin/sbcl --noinform

Depois modifica o .sbclrc para que ele ignore as linhas que começam com #!

$ cat >> .sbclrc
;;; If the first user-processable command-line argument is a filename,
;;; disable the debugger, load the file handling shebang-line and quit.

(let ((script (and (second *posix-argv*)
(probe-file (second *posix-argv*)))))
(when script
;; Handle shebang-line
(set-dispatch-macro-character #\# #\!
(lambda (stream char arg)
(declare (ignore char arg))
(read-line stream)))
;; Disable debugger
(setf *invoke-debugger-hook*
(lambda (condition hook)
(declare (ignore hook))
;; Uncomment to get backtraces on errors
;; (sb-debug:backtrace 20)
(format *error-output* "Error: ~A~%" condition)
(quit)))
(load script)
(quit)))

Dai dá para faze o hello world em lisp:

#!/usr/bin/sbcl --noinform
(format t "Hello World~%")

Porque lisp?

2005-07-08T18:16:00.000-07:00

O lisp sempre me atraiu, afinal é a linguagem do emacs, "The One True Editor". Outra coisa que sempre me intrigou é ouvir todos aqueles programadores fodas sempre falavam bem do lisp e eu queria entender qual a vantagem.

O primeiro passo vou ler o livro "Practical Common Lisp", que está no site

http://www.gigamonkeys.com/book/

Ótima introdução, além de ver exemplos práticos entendi o que o lisp tem de diferente das outras linguagens: as macros.

Macro em lisp é algo muito diferente das macros em C. As macros em C fazem somente substituição de texo, já as macros em lisp são programas que geram programas. Isso só é possível devido a sintaxe simples do lisp, como programas são listas eles podem ser manipulados como qualquer outro tipo de dados.

Pena o lisp ser tão pouco conhecido aqui no brasil, nos falta aqui o peso de um departamento de computação como o do MIT que ensina lisp no primeiro ano da graduação.

Existem coisas que você deve usar no lisp tornam a sua vida bem mais fácil. A primeira delas é usar o debian, ele já vem com quatro implementações de lisp. Eu estou usando o SBCL e o CMUCL. Acho que o SBCL tem mais futuro, ele é mais moderno, mas algumas coisas ainda só rodam no CMUCL.
O debian também tem diversos pacotes para o Common Lisp já empacotados.

Outra coisa, use o emacs! Ele tem um modo chamado ilisp que já vem com o debian que eu achava legal, até conhecer o SLIME. Depois que você usa ele não quer saber de nenhum outro modo de lisp.

Ele não está na sarge, mas tem um repositório não oficial com ele, é só adicionar a linha abaixo no source.list:

deb http://commonwerx.org/software/contrib/slime/deb ./

Mas nem todas as bibliotecas estão empacotadas, para ver uma lista muito completa de pacotes vá no site do cliki, ele é uma espécie de CPAN para common lisp:

http://www.cliki.net/index

Em seguida aprenda como utilizar o asdf-install, que faz o mesmo trabalho do módulo CPAN do perl.

Depois de ler o "Practical Common Lisp" uma boa escolha é ler o OnLisp do Paul Graham, também está disponível de graça na rede. Nele você aprende os tópicos avançados a linguagem.