Planeta Lisp-br

Blog under siege

2008-12-17T17:36:14+00:00

I know it is a pain for who is commenting, but I had to add the reCAPTCHA Wordpress plug-in to this blog. The spam count was already in the 300s, and increasing fast. Trackback spam is still high.

Lua Programming Gems out!

2008-12-14T22:08:22+00:00

Hot from the presses, the book is finally here. The table of contents, the front matter and the free chapter 2 are in the book homepage.

Lisp Joke

2008-12-13T17:42:27+00:00

Will code for money

2008-12-09T19:08:05+00:00

Thanks to the Financial World Crisis, my employer wants to relocate me to a place where it will spend less money paying me and with less infra-structure. As I do not intend to relocate, I therefore offer my good coding skills for money. Remember that Brazillian paying rates are lower than European and American ones! The link to my resume is at the side.

Americanas: "inconsistências"

2008-12-09T06:50:40+00:00

Há umas semanas tentei comprar um notebook das Americanas. Um dia após eu ter feito o pedido, recebo um e-mail pedindo para enviar dados a serem avaliados pela instituição financeira responsável pelo meu cartão de crédito. No mesmo dia respondi o e-mail com as informações solicitadas (com as mesmas informações que usei em compras feitas nas Americanas anteriormente).

Dois dias depois recebo um e-mail indicando que as informações haviam sido recebidas e que a análise demoraria até 36h. Depois de mais dois dias recebo um e-mail informando que o pedido havia sido suspenso devido a inconsistência de informações na sua compra e também à ausência de contato nossa Central de Atendimento. Ressalto que respondi todas as requisições de contato e pedidos de informações que a mim chegaram.

Via e-mail, tentei obter informações sobre a razão da suspensão do pedido, mas não obtive resposta.

Hoje fui ver a fatura do meu cartão de crédito e percebi que o valor da parcela da compra havia sido debitado. É claro, ficou a dúvida: se as informações eram inconsistentes para efetuar a compra, por que não eram inconsistentes para fazer a cobrança?

Tentei fazer esta pergunta para o atendimento online das Americanas, via chat. A conversa está abaixo (fui fazendo a captura das telas conforme a conversa se desenvolvia, pois temia que o texto fosse desaparecer quando o atentente desejasse -- o que de fato aconteceu).

Não consegui capturar a última tela, pois o atendente "desligou".

Fica o conselho: cautela ao comprar das Americanas.

Interpretador de COW em Chicken Scheme

2008-12-05T05:53:09+00:00

Dando seqüência à série implementações de interpretadores de linguagens que não servem para nada (iniciada com um interpretador de assembly), a seguir está a implementação de um interpretador para a linguagem COW em Chicken Scheme.

Da página da linguagem:

The COW programming language was designed with the bovine in mind. Given that cows have somewhat limited vocabulary skills, it seemed natural to incorporate only the words they know into the language. As a result, all instructions are some variation on "moo" which just so happens to be the only word they really understand.

Abaixo estão o código da implementação e um programa exemplo:

(use srfi-1)

(define *memory* (make-vector 1 0))
(define *program* #f)
(define *ip* 0) ;; instruction pointer
(define *mp* 0) ;; memory pointer
(define *register* #f)
(define instructions
  '(("moo" . 0) ("mOo" . 1) ("moO" . 2) ("mOO" . 3) ("Moo" . 4)
    ("MOo" . 5) ("MoO" . 6) ("MOO" . 7) ("OOO" . 8) ("MMM" . 9)
    ("OOM" . 10) ("oom" . 11)))

(define (sanitize-code code)
  ;; removes non-cow instructions and returns a list containing valid cow code
  (map string->symbol
       (filter (cut alist-ref <> instructions equal?)
               (flatten (map string-split code)))))

(define (get-address snippet from to)
  (let ((scope 0)
        (address #f))
    (let loop ((code snippet))
      (if (and (null? code) (not address))
          (terminate)
          (let* ((current-instr (car code))
                 (instr (cdr current-instr))
                 (pos (car current-instr)))
            (cond ((eq? instr from)
                   (set! scope (add1 scope))
                   (loop (cdr code)))
                  ((and (not (zero? scope)) (eq? instr to))
                   (set! scope (sub1 scope))
                   (loop (cdr code)))
                  ((and (zero? scope) (eq? instr to)) pos)
                  (else (loop (cdr code)))))))))

(define (MOO-address)
  (get-address (reverse (take *program* (sub1 *ip*))) 'moo 'MOO))

(define (moo-address)
  (get-address (drop *program* (+ 2 *ip*)) 'MOO 'moo))

(define (mem-get) (vector-ref *memory* *mp*))

(define (maybe-resize-mem!)
  (let ((vlen (vector-length *memory*)))
    (when (>= (add1 *mp*) vlen)
      (set! *memory* (vector-resize *memory* (add1 vlen) 0)))))

(define (mem-set! val)
  (maybe-resize-mem!)
  (vector-set! *memory* *mp* val))

(define (terminate #!optional (exit-code 0))
  (print "Terminating.")
  (exit exit-code))

(define (moo-interpreter file)
  (let* ((sane-code (sanitize-code (read-lines file)))
         (program-len (length sane-code))
         (debug? (getenv "COWDEBUG")))
    (set! *program* (map cons (iota program-len) sane-code))
    (when debug? (display "prog> ") (pp *program*))
    (let loop ()
      (when debug?
        (print "-----------------------------------")
        (print *program*)
        (display "mem> ") (pp *memory*)
        (print "*mp*> " *mp*)
        (print "*ip*> " *ip*)
        (print "*register*>  " *register*))
      (when (> *ip* program-len) (terminate))
        (if (null? *program*)
            (terminate)
            (let* ((current-instr (alist-ref *ip* *program*))
                   ;; special-instr => instructions that modify *ip*
                   (special-instrs '(MOO mOO moo))
                   (special-instr? (memq current-instr special-instrs)))
              (when (eq? current-instr 'mOO)
                (unless (memq (mem-get) (map cdr instructions))
                  (terminate))
                (set! current-instr (alist-ref (mem-get) *program*))
                (set! special-instr? (memq current-instr special-instrs)))
              (when debug?
                (display "current-instr> ")
                (display (if special-instr? "(*) " ""))
                (pp  current-instr))
              (case current-instr
                ((moo) (set! *ip* (MOO-address)))
                ((mOo) (maybe-resize-mem!) (set! *mp* (sub1 *mp*)))
                ((moO) (maybe-resize-mem!) (set! *mp* (add1 *mp*)))
                ((Moo) (if (zero? (mem-get))
                           (mem-set! (string->number (->string (read-line))))
                           (print (integer->char (mem-get)))))
                ((MOo) (mem-set! (sub1 (mem-get))))
                ((MoO) (mem-set! (add1 (mem-get))))
                ((MOO) (if (zero? (mem-get))
                           (set! *ip* (add1 (moo-address)))
                           (set! *ip* (add1 *ip*))))
                ((OOO) (mem-set! 0))
                ((MMM) (if *register*
                           (begin (mem-set! *register*)
                                  (set! *register* #f))
                           (set! *register* (mem-get))))
                ((OOM) (print (mem-get)))
                ((oom) (mem-set! (string->number (read-line)))))
              (unless special-instr? (set! *ip* (add1 *ip*)))))
        (loop))))

(define (usage #!optional (exit-code 0))
  (print "Usage: " (program-name) " <input file>")
  (exit exit-code))

(let ((args (command-line-arguments)))
  (if (null? args)
      (usage 1)
      (let ((file (car args)))
        (if (file-exists? (car args))
            (moo-interpreter file)
            (begin
              (print file ": not found.")
              (exit 1))))))

Obs.: se a variável COWDEBUG estiver definida no ambiente, o interpretador exibe informações para depuração.

Aqui está a implementação de um gerador da série de Fibonacci em COW (um dos exemplos disponibilizados no site da linguagem):


MoO
moO
MoO
mOo
[[ main loop ]]
MOO
[[ print first number ]]
OOM
[[ temp copy of first number ]]
MMM
moO
moO
MMM
mOo
mOo
[[ store second number off in the first position now ]]
moO
MMM
mOo
MMM
[[ move back to temp number ]]
moO
moO
[[ use temp to add to first and store in second in loop ]]
MOO
MOo
mOo
MoO
moO
moo
mOo
mOo
moo

Executando este exemplo com o interpretador, temos:


$ csi -s cow.scm fib.cow
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
...

Algum voluntário para implementar as Distributed Digestion eXtentions? :-)

Equivalent of and-let*?

2008-12-02T17:33:47+00:00

By this point I believe it’s clear that I am a big fan of Scheme. Lately I have seen a sharp rise of interest in Ruby in some virtual places I attend (#lisp-br, twitter, IM with coworkers etc.). I am sure Ruby is a fine language, even in spite of several complaints I hear from some of its users. After all, it has symbols, metaprogramming, blocks (a sort of closures), lambdas and more! I’d really take the time to learn it, if it wasn’t for Matz himself:

Some may say Ruby is a bad rip-off of Lisp or Smalltalk, and I admit that. But it is nicer to ordinary people.

Now that is a demotivator. But Ruby must be evolving, and that quote may be outdated. So I have thought of a question to the Ruby-lovers, that may help me make up my mind to take the time to learn it. One of the best Scheme macros is, in my opinion, and-let*, from the SRFI-2. How would one write the following in Ruby, a procedure that I wrote a couple of nights ago?

;; Tries to get session from current request
(define (get-session request)
  (and-let* ((cookies (request-cookies request))
             (p (assoc "session_id" cookies))
             (sid-str (cdr p))
             (sid (string->number sid-str))
             ((integer? sid))
             ((exact? sid))
             (sp (assq sid *sessions*)))
    (cdr sp)))

In the and-let* macro, the clauses are evaluated and the variables are bound sequentially, creating new scopes for the next expressions. If any of the forms evaluates to #f (false in Scheme), the computation is aborted, no other expressions are evaluated, and the whole form evaluates to #f. How would I write this in concise Ruby?

Paul Graham’s strategy

2008-12-02T17:05:55+00:00

I have disappeared for a while, but my excuse is that I have been coding furiously. I intend to write a lot more in the not-so-far-away future. In the meanwhile, a quick post.

From time to time I read another Paul Graham essay, usually when they are cited in some Reddit or Slashdot thread. He really writes well, and although I do not agree with everything he says, I must say I agree with most of it. “Beating the averages” was very influential on some important decisions I have made, and for a lot of other people as well.

Today I found an essay called “Six Principles for Making New Things“, in which he describes his modus operandi:

Here it is: I like to find (a) simple solutions (b) to overlooked problems (c) that actually need to be solved, and (d) deliver them as informally as possible, (e) starting with a very crude version 1, then (f) iterating rapidly.

I agree 100% with him here. There are a lot of overlooked problems out there, in search of solutions, that just seem “simple” enough. But they need to be solved and, when someone does it, everybody else wish they had thought of it. But they were there, all the time. Moreover, the initial solution does not need to be perfect, as long as it solves an immediate need well enough and the solution can be iterated rapidly, which is a very, very important point. When someone creates a market, there is soon afterwards a rush of new competitors. Coming up with a simple solution which does not evolve quickly is the recipe to lose to another faster, more dynamic, more focused team.

I already had something like Graham’s Six Principles in the back of my mind for a while. It was good to see them written by someone who has made millions of dollars selling (Lisp!) software.

Como tomar decisões

2008-11-22T02:47:42+00:00

Agora pouco, no IM:

trajber: vou pedir ajuda ao meu querido PC
trajber: mauro@trajber:~$ python
Python 2.5.2 (r252:60911, Oct 5 2008, 19:24:49)
[GCC 4.3.2] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.
>>> import random
>>> print random.randint(0,1)
trajber: 0 = ignorar
trajber: 1 = comer
trajber: ok ?
trajber: 0
>>>
trajber: foi justo…

Outro também fez algo parecido: http://twitter.com/igorrs/status/896944758

Scheme na Apple?

2008-11-19T06:18:19+00:00

Estava dando uma olhada em uma apresentação sobre o MacOSX que o Drebes divulgou em uma lista de discussão e me deparei com a seguinte tela:

Com uma rápida pesquisada, encontrei o seguinte texto:

While there is no documentation of the format of the policy file, there are several examples available in /usr/share/sandbox which give clues to what a policy can do. These policies seem to use a Scheme-like syntax and provide abilities to restrict file access (based on pathname), restrict interprocess communication (IPC) such as shared memory, restrict network access, restrict signals, restrict many process-related actions, restrict sysctls, and more.

Interessante.

Book Meme

2008-11-14T00:34:00+00:00

Time is always critical because somebody might beat you to the punch

Founders at Work, Jessica Livingston

Grab the nearest book.
Open it to page 56.
Find the fifth sentence.
Post the text of the sentence in your journal along with these # instructions.
Don’t dig for your favorite book, the cool book, or the intellectual one: pick the CLOSEST.

Chicken LiveCD na LatinoWare 2008

2008-10-28T11:34:49+00:00

Como não será possível levar a torradeira para a Latinoware 2008, levarei alguns LiveCDs de Chicken para os interessados. Serão poucas unidades (~20). Faça sua reserva na seção de comentários. :-)

Aprendendo Scala

2008-10-23T18:55:45+00: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

Chicken LiveCD 0.4

2008-10-22T04:59:11+00:00

A versão 0.4 do Chicken LiveCD está disponível em http://g3pd.ufpel.tche.br/chicken/livecd/.

Esta versão contém:

Chicken 3.4.0

mais de 300 eggs instalados

Emacs + Quack + scheme-complete

Manual em PDF

várias ferramentas e bibliotecas para desenvolvimento com Chicken

Esta versão do LiveCD é baseada no Ubuntu. Usei o Reconstructor para remasterizar o CD.

Lisp in Latinoware 2008

2008-10-20T13:31:21+00:00

There will be presentations about Lisp in the V Latin America Conference on Free Software, via call-with-hopeless-continuation.

Correctly answer a simple skill testing question

2008-10-20T12:17:38+00:00

Ainda não decidi se devo chorar ou dar risada:

Há uma thread na lista de discussão da implementação PLT com a discussão gerada por uma simples questão.

Lisp na LatinoWare 2008!

2008-10-17T14:09:49+00:00

A LatinoWare 2008, V Conferência Latino-Americana de Software Livre, que ocorrerá de 30 de outubro a 1^o. de novembro em Foz do Iguaçu, PR, contará com três apresentações especificamente sobre Lisp! Serão 3 horas consecutivas sobre parênteses no dia 31/10/2008:

15h-16h	Usando Common Lisp no Dia-a-dia	Pedro Ribeiro Kroger Junior
16h-17h	Chicken - Uma Implementação de Scheme para Aplicações Práticas	Mario Domenech Goulart
17h-18h	CL-Weblocks - Programando Aplicações Web com Blocos	Vilson Vieira da Silva Junior

A programação completa do evento está em http://lapsi.latinoware.org/index.php?page=grade.GradeEvento&id=1.

Meroon for Gambit-C

2008-10-14T03:21:35+00:00

Meroon is a Scheme object system by Christian Queinnec. It is portable, fast, CLOS-like and reflexive. The Meroon home page cites versions for several popular Scheme systems, including Gambit-C. But the links to the Gambit-C version are broken. Doing a bit of research, that actually involved some guessing, I found the Meroon Gambit-C port in Bradley Lucier’s home page. Instructions to build this Meroon port can be found in this thread in the Gambit-C mailing list.

I am not a heavy user of object orientation, but I can certainly see its value where it is worth. In the LiSP book, for instance, a beautiful interpreter and a compiler are written in OO-style, in chapter 3 and 10, respectively. Another example is writing a scene graph for a Computer Graphics application, it almost begs to be written object-oriented.

Javascript (Ajax) e HTML em Lisp

2008-10-12T18:56:49+00:00

Para testar algumas coisas refiz hoje o código do post Common Lisp e Ajax. Desta vez estou usando o patch para o HT-AJAX com suporte e jQuery. Além disso, para gerar código JavaScript uso Parenscript. Assim todo HTML e JS é produzido por s-exps:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter *dependencies*
    ‘(:asdf :hunchentoot :ht-ajax :cl-who :parenscript))
  (map nil ‘require *dependencies*))

(defpackage :ajax-test
  (:use :common-lisp :hunchentoot :ht-ajax :cl-who :parenscript))

(in-package :ajax-test)

(defparameter *local-dir* “/Users/lucindo/Documents/Lisp/web/3rdparty/”)
(defparameter *ajax-handler-url* “/ajax”)
(defparameter *ajax-processor*
  (make-ajax-processor :type :jquery
                       :server-uri *ajax-handler-url*
                       :js-file-uris “/static/jquery.js”))

(defun testfunc (command)
  (prin1-to-string (handler-case (eval (read-from-string command nil))
                                 (error (c) (format nil “~a” c)))))

(defun js ()
  (ps
   (defun command_clicked ()
     (let ((command (document.get-element-by-id “command”)))
       (with-slots (value) command
                   (ajax_testfunc_set_element “result” value))))))

(defun main-page ()
  (with-html-output-to-string
   (*standard-output* nil :prologue t)
   (:html
    (:head
     (:script :type “text/javascript” :src “/js”)
     (:title “AJAX test”)
     (fmt “~a” (generate-prologue *ajax-processor*)))
    (:body
     (:h1 “ajax test”)
     (:table :width “50%”
             (:tr
              (:td :colspan “2″
                   (:span :id “result”
                          (:i “no results yet”))))
             (:tr
              (:td :width “70%”
                   (:input :type “text”
                           :size “70″
                           :name “command”
                           :id “command”))
              (:td (:input :type “button”
                           :value “eval”
                           :onclick (ps-inline (command_clicked))))))))))

(eval-when (:load-toplevel :execute)
  (export-func *ajax-processor* ‘testfunc :method :post)
  (setf *dispatch-table*
        (list ‘dispatch-easy-handlers
              (create-folder-dispatcher-and-handler “/static/”
                                                    *local-dir* “text/plain”)
              (create-prefix-dispatcher *ajax-handler-url*
                                        (get-handler *ajax-processor*))
              (create-prefix-dispatcher “/js” ‘js)
              (create-prefix-dispatcher “/” ‘main-page))))

(defparameter *webserver* nil)

(defun start-web (&optional (port 4242))
  (setf *webserver* (start-server :port port)))

(defun stop-web ()
  (stop-server *webserver*))

Download: ajax2.lisp

Ruby sucks: parte 42

2008-10-08T15:13:05+00:00

Há algum tempo eu desisti de Ruby. Como linguagem de programação tem coisas muito legais, mas ainda é muito imatura (apesar da idade). Poderia mostrar vários exemplos de coisas estranhas em Ruby, mas hoje vai a causa de um bug que me mostraram.

Veja se o defined? não funciona de maneira não intuitiva:

lucindo@marvin:~$ irb
irb(main):001:0> defined?(cu)
=> nil
irb(main):002:0> if false
irb(main):003:1>    cu = "ruby"
irb(main):004:1> end
=> nil
irb(main):005:0> defined?(cu)
=> "local-variable"
irb(main):006:0> if defined?(cu)
irb(main):007:1>    puts "ruby cu"
irb(main):008:1> end
ruby cu
=> nil
irb(main):009:0>

Imagina se você usa isso em algo como configuração…

13949712720901ForOSX

2008-10-06T10:59:25+00:00

>Java 1.6 for OS x!!!!!

13949712720901ForOSX

ACE_Task-like em Python

2008-09-28T23:02:34+00:00

Nos últmos dias me reanimei a voltar a postar nesse blog.

Estou tentando mudar para Python como a minha principal linguagem de script, mas ainda preciso aprender a programar direito nessa linguagem. Enquanto isso não acontece, eu fico replicando código de outros lugares, como a cópia de pobre da ACE_Task abaixo:

import threading, Queue, signal

class Task(object):
    def __init__(self):
        self.queue = Queue.Queue(0)

    def __worker(self):
        while True:
            item = self.queue.get()
            self.process(item)
            self.queue.task_done()

    def __start(self):
        thread = threading.Thread(target=self.__worker)
        thread.setDaemon(True)
        thread.start()

    def activate(self, threads):
        for thread in xrange(threads):
            self.__start()
        signal.signal(signal.SIGINT, signal.SIG_DFL)

    def put(self, item):
        self.queue.put(item)

    def wait(self):
        self.queue.join()

    def process(self, item):
        pass

class task(Task):
    def __init__(self, func):
        Task.__init__(self)
        self.process = func

A única coisa pytônica do código é o decorator do final.

Bom, um exemplo de uso: digamos que você é um spammer e quer mandar vários emails. Você tem um arquivo em que cada linha tem as seguintes informações: servidor; email; subject; mensagem. Tudo separado por ponto e vírgula.

Usando o decorator acima o código ficaria mais ou menos assim (usando 100 threads):

from __future__ import with_statement
from task import task
import smtplib, sys

@task
def send_spam(item):
    server, toaddr, subject, msg = item.strip().split(‘;’)
    fromaddr = ’spammer@evil.org’
    message = (“From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s”
               % (fromaddr, toaddr, subject, msg))
    try:
        smtp = smtplib.SMTP(server)
        smtp.sendmail(fromaddr, toaddr, message)
    except Exception:
        pass

def process_file(filename):
    send_spam.activate(100)
    with open(filename) as file:
        map(lambda line: send_spam.put(line), file.readlines())
    send_spam.wait()

if __name__ == ‘__main__’:
    process_file(sys.argv[1])

Coloquei esse exemplo porque não tinha um melhor… é apenas um exemplo, não um programa de verdade, ok?

Download: task.py

To do: reescrever em Python 2.6 usando Multiprocessos

Frase do dia

2008-09-22T01:28:39+00:00

Só porque esse blog está muito parado:

Eight years to do TeX? How smart can he be? He should have used Lisp.

Kenny Tilton, sobre Donald Knuth

The need for speed

2008-09-19T21:05:59+00:00

I have found a very interesting thread in the Gambit-C Scheme mailing list. Marc Feeley tries to dismiss the myth that floating-point calculations are inherently faster in C/C++ than in Scheme, which is taken as common wisdom. The the work of Bradley Lucier is cited as a case of very fast numerical Scheme code.

Bradley himself replies, in which he explains that his code is roughly half as fast as it would have been if coded in C, but the memory bandwidth is the culprit and it does not matter anyway. An interesting part of the email is this:

I didn’t mind rewriting the level-1 BLAS code in Scheme, however, as it didn’t seem worth the trouble to get a small speedup in the entire system just to use a dot-product or saxpy written in C and called from an FFI. I have enough difficulty in getting students to admit to themselves that, yes, this system is fast (just about as fast as any expert could have written it, and probably much faster than your average graduate student could have written it) and it’s flexible (it’s only at the end of the course that some students reluctantly admit that they could not have finished their semester project in their favorite language, whether C or C++), and that the speed doesn’t arise from level-1 BLAS written in C (because they’re written in Scheme). One point that most students seem to take away from the class is that multigrid is one hell of a lot faster than conjugate gradient, and many of them have been using conjugate gradient in their own projects simply because it’s too hard to program multigrid in C or C++ (at least the first time you try it). So one gets a lot of speedup simply by being able to program more sophisticated algorithms.

There is also a toy ray-tracer written in Gambit-C, Schemeray, which was further optimised by Marc Feeley, and even more by (again) Bradley Lucier. The times are impressive, thanks to all the clever compiler tricks Gambit-C uses when generating C code, like inlining, partial code evaluation and generating one C function per Scheme module (avoiding expensive inter-module C calls).

The code generated by Gambit-C is fast enough for 99.99% of the applications out there. And this is using a strong, dynamically-typed language, with first-class closures and continuations, arbitrary-precision numbers, and the powerful macros of the Lisp family of languages. There is hardly need to use C or C++ even in the most demanding applications. The same cannot be said of Perl, Python or Ruby, whose applications usually run much slower than one created with Gambit-C. And, if the need really arises, interfacing Gambit-C with C code is extremely easy.

Call me a whiner

2008-09-08T14:08:25+00:00

But there are out there things like this:

We don’t really care about the title but we want someone good (who doesn’t?). We need someone able to model and code well (No architect who never codes). The ability to communicate well with a team is also a big plus. You don’t need to speak French (we are in France) but a reasonably good English is mandatory.

If You:

like coding 4+ hours straight

like to solve a coding problem elegantly (and are bothered if can’t)

like and read real CS books (SICP, EGB, TAOCP, etc…)

code in Haskell, Python and C++

are a gamer (this one is optional)

are interested in computer graphics (optional too)

What we offer:

interesting problems and creative freedom

quality of life (no overtime, sunny countryside, French food and low rent)

a pay in Euros

comfortable workplace, etc…

coding in Haskell, Python

The boss really codes. He likes Haskell, Python, Reddit, and wants the team to be there for the long run (i.e. happy). He also modestly wrote and posted this jobs offer.

So let me see: Haskell, games, and Computer Graphics. How sweet. Also, note the emphasis on how the boss and “architects” still code. In underdeveloped places, coding is just for drones, and bosses and “architects” can’t do it to save their lives.

Interface para manipulação de grupos no LDAP

2008-09-04T06:32:34+00:00

A seguir está uma simples, rápida e não muito elegante interface para manipulação de grupos de usuários no LDAP (Lightweight Directory Access Protocol) que usa o programa cpu por baixo dos panos. A implementação é em Chicken Scheme.

Com esta ferramenta são possíveis as seguintes operações:

Listar grupos aos quais um dado usuário pertence

Listar usuários que fazem parte de um dado grupo

Adicionar usuário a grupo

Exemplos:


$ ldap-groups.scm -h
Uso: ldap-groups.scm -h | -a <user> <group> | -l <group> | -g <user>

-a : adiciona <user> ao grupo <group> (cria <group> se nao existir)
-l : lista os usuarios do grupo <group>
-g : lista os grupos a que pertence o usuario <user>

Listando os usuários do grupo admin:


$ ldap-groups.scm -l admin
mario
joao

Listando os grupos a que pertenço:


$ ldap-groups.scm -g mario
sgpc
admin

Adicionando o meu usuário ao grupo printer:


$ ldap-groups.scm -a mario printer

O código está abaixo:

(use posix srfi-13)

(define (system-output . command)
  (let ((cmd (string-intersperse (map ->string command))))
    (read-all (open-input-pipe (sprintf "~A 2>&1" cmd)))))

(define *groups-data* #f)

(define (set-groups-data!)
  (set! *groups-data*
  ;; lista de listas (("grupo" "user1" "user2" ... "usern"))
        (let ((data (with-input-from-string
                        (cadr (string-split-fields
                               "Group Entries\n"
                               (system-output "cpu cat")
                               infix:))
                      read-lines)))
          (map (lambda (line)
                 (let ((ldata (string-split line ":")))
                   (cons (car ldata) ;; nome do grupo
                         (let ((users (cdddr ldata))) ;; usuarios
                           (if (null? users)
                               '()
                               (map
                                string-trim-both
                                (string-split (car users) ",")))))))
               data))))

(define (get-groups user)
  (let ((user-groups '()))
    (for-each (lambda (group/users)
                (when (member user (cdr group/users))
                  (set! user-groups
                        (cons (car group/users) user-groups))))
              *groups-data*)
    user-groups))

(define (group-exists? group)
  (not (not (alist-ref group *groups-data* equal?))))

(define (get-users group)
  (alist-ref group *groups-data* equal?))

(define (add-user-to-group! user group)
  (unless (group-exists? group)
    (let ((cmd (conc "cpu groupadd " group)))
      (print cmd)
      (system-output cmd)))
  (let ((cmd (conc "cpu usermod " user " -G "
                   (string-intersperse
                    (cons group (get-groups user)) ","))))
    (print cmd)
    (system-output cmd)))

(define (usage #!optional exit-code)
  (print #<#EOF
Uso: #(program-name) -h | -a <user> <group> | -l <group> | -g <user>

-a : adiciona <user> ao grupo <group> (cria <group> se nao existir)
-l : lista os usuarios do grupo <group>
-g : lista os grupos a que pertence o usuario <user>
EOF
)
  (when exit-code
    (exit exit-code)))

(let ((args (command-line-arguments)))
  (when (null? args)
    (usage 1))
  (set-groups-data!)
  (cond ((member (car args) '("-h" "--help" "-help"))
         (usage))
        ((member "-a" args)
         (add-user-to-group! (cadr args) (caddr args)))
        ((member "-l" args)
         (map print (or (get-users (cadr args)) '())))
        ((member "-g" args)
         (map print (or (get-groups (cadr args)) '())))
        (else (usage 1))))

Not luck

2008-08-27T18:13:43+00:00

There is a recurrent angst I feel every time I think I could be working daily in a decent programming language. Usually the management people believe the choice of programming language is irrelevant, but we developers know better. Languages shape our thoughts.

Today I found an interesting post about getting work using non-mainstream languages.

Well, unlike Java jobs or C# jobs or VB jobs, where one can scan the newspaper or go to dice.com, these magical jobs are not the ones I get when recruiters solicit me (three times a day). No, they appear between the cracks of the sky when it rends in two. All but one contract (that did come from dice.com) came from the company CEO pulling me aside or phoning me out of the blue from the materials I had published inside the company where I was employed, or from my web-sites on programming languages.

This basically means you must be a reference. You must blog a lot or, better yet, write even a book. When your name is said in a company meeting, somebody of the team must already have heard of you. Needless to say, this is not easy at all.

Usually and because of the exclusivity of the work it takes anywhere from at least 3 months to 2 years to secure these kinds of contracts, so the adage “Don’t quit your day job” is an appropriate one here. When I do get these contracts, however, they usually last longer (3 years) than the Java/C++/XML/web-services-code-grinder ones (that usually last around 6 months), and the peer group is much more intelligent, genteel and just plain more interesting than the code-grinding crowd. Is is harder to find these magical contracts? Yes, they are rarified air. But are they worth preparing for and then finding? Definitely.

Here we see that even after all this work, it is still very hard to find these dream jobs. You can wait as long as two years to get one, simply because in most companies the management employ Java/C#/VB drones anyway, as they are cheaper and easier to find. Only when they face really hard problems they start thinking of alternatives.

This post only reinforces what was already in the back of my mind for a while: The least hard way to earn money and be happy at the same time is to start an own business. Now if I could only move my lazy ass…

Testanto o rucksack

2008-08-17T20:53:17+00: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).

Configurando o tamanho do stack trace

2008-08-12T05:18:01+00:00

Chicken dispõe de uma opção para configurar o tamanho do relatório de chamadas de procedimentos (stack trace) a ser exibido em caso de erro. Se a configuração for omitida, o valor 8 é usado, o que significa que serão exibidas as últimas 8 chamadas de procedimento.

Para algumas aplicações, esse número pode ser muito pequeno, mas pode ser aumentado com o parâmetro -:aNUMBER, onde NUMBER é o número de chamadas a ser mostrado (http://chicken.wiki.br/Using%20the%20compiler#runtime-options).

Abaixo está um exemplo de uma situação onde o aumento do stack trace pode ser útil:

(define (l) (error 'oops))
(define (k) (l))
(define (j) (k))
(define (i) (j))
(define (h) (i))
(define (g) (h))
(define (f) (g))
(define (e) (f))
(define (d) (e))
(define (c) (d))
(define (b) (c))
(define (a) (b))

(a)

Executando este código com o interpretador, temos:


$ csi -s oops.scm
Error: oops

        Call history:

                  [e] (f)
                  [f] (g)
                  [g] (h)
                  [h] (i)
                  [i] (j)
                  [j] (k)
                  [k] (l)
                  [l] (error (quote oops))        --

Com esse relatório, não fica claro que quem originou a chamada de l foi a. Mas, se aumentarmos o tamanho do relatório:


$ csi -:a14 -s oops.scm
Error: oops

        Call history:

                        (a)
                  (a)
                  [a] (b)
                  [b] (c)
                  [c] (d)
                  [d] (e)
                  [e] (f)
                  [f] (g)
                  [g] (h)
                  [h] (i)
                  [i] (j)
                  [j] (k)
                  [k] (l)
                  [l] (error (quote oops))        --

O parâmetro -:aNUMBER também é válido para programas compilados com o compilador de Chicken (csc):


$ csc oops.scm
$ ./oops
Error: oops

        Call history:

        oops.scm: 8    f
        oops.scm: 7    g
        oops.scm: 6    h
        oops.scm: 5    i
        oops.scm: 4    j
        oops.scm: 3    k
        oops.scm: 2    l
        oops.scm: 1    error                    --

$ ./oops -:a14
Error: oops

        Call history:

        oops.scm: 14   a
        oops.scm: 12   b
        oops.scm: 11   c
        oops.scm: 10   d
        oops.scm: 9    e
        oops.scm: 8    f
        oops.scm: 7    g
        oops.scm: 6    h
        oops.scm: 5    i
        oops.scm: 4    j
        oops.scm: 3    k
        oops.scm: 2    l
        oops.scm: 1    error                    --

Chicken Web REPL

2008-08-06T09:17:15+00:00

Há algum tempo eu e o Vilson estávamos discutindo sobre REPLs na Web (não lembro o que desencadeou esse tópico -- também é possível que o tópico não tenha sido esse -- tá feio o caso da minha memória). Bem, o fato é que desta conversa surgiu a idéia de fazer um REPL via Web para Chicken. Lembrei do egg sandbox, do Chicken Playground (um ambiente chroot com uma instalação de Debian, Chicken e um monte de eggs) e fiz um Web REPL simples para Chicken.

Em seguida, o Vilson descobriu o EditArea (um editor de código em Javascript) e modificou para adicionar um suporte básico a Common Lisp. Enviou o código para mim e eu, com base nele, adicionei suporte básico a Scheme.

O resultado está em http://repl.ucpel.tche.br:8080.

Uma das funcionalidades interessantes do Web REPL é o uso de sessões HTTP para manter coisas como histórico de trechos de código submetidos ao avaliador e definições feitas na sessão. A implementação de sessões é feita com o egg http-session.

O Web REPL também usa os eggs web-scheme, ajax, spiffy-utils e spiffy (servidor web).

REPL de Chicken para acesso a bases de dados do Postgres

2008-08-06T08:26:48+00:00

A seguir está uma forma de usar o REPL de Chicken (csi) como um REPL para bases de dados do Postgres.

Com isso, tem-se um REPL que possibilita a execução de consultas SQL e código Scheme. A implementação usa o próprio REPL do sistema Chicken e alguns eggs como: postgresql (para acesso so Postgres), readline (para edição de linhas de comando, histórico) e stty (para configuração do terminal na leitura de senhas).

O programa db-repl.scm usa como argumentos não interativos (opcionais) o usuário do banco de dados, o nome do host e a base de dados, os quais devem ser fornecidos no seguinte formato:

<usuario>@<host>/<base de dados>

Quando executado, o programa pede para o usuário digitar a senha.

A associação do REPL de Chicken com a base de dados é feita através da definição de comandos do REPL (toplevel-command). Na implementação mostrada abaixo, são definidos três comandos:

tables: mostras as tabelas da base de dados.

table: mostra estrutura da tabela dada como argumento (nome e tipo das colunas e se podem ou não ser nulas).

-: executa a consulta SQL dada como argumento.

Exemplos:

csi -s db-repl.scm mario@localhost/sgpc
Senha: *****

#;1> ,tables
perms
news
users_sites
ticket_comments
ticket_attachments
obj_type
acervos
autores
videos
audios
images
objects
texts
scanners
users
wiki
sites
tickets

#;1> ,table news
news_id                       integer                       NO
user_id                       integer                       NO
site_id                       integer                       NO
timestamp                     timestamp without time zone   YES
title                         character varying(100)        NO
news                          text                          YES

#;1> ,- select * from news
(#(2
   1
   1
   #(2008 7 30 19 37 54 271625)
   "Teste."
   "teste

   === titulo")
 #(3
   1
   1
   #(2008 7 30 19 40 27 180765)
   "Outra notícia!"
   "Aqui vai o texto da notícia.

[[image:http://subversion.tigris.org/branding/images/logo.gif|Logo]]"))

Obviamente, os comandos para acesso ao banco de dados disponibilizados através do REPL podem ser estendidos. O texto PostgreSQL INFORMATION_SCHEMA fornece várias dicas de como extrair informações de bases de dados do Postgres.

Nesta implementação, o parâmetro pg-repl:conn armazena o objeto que representa a conexão com o banco de dados, de forma que ele pode ser usado pelos procedimentos do egg postgresql para a execução de consultas:


#;1> (define query  "select * from news")
#;2> (vector-ref (car (pg:query-tuples query (pg-repl:conn))) 3)
#(2008 7 30 19 37 54 271625)

O código do programa (db-repl.scm) está a seguir:

(use utils postgresql readline stty regex (srfi 13))

(define pg-repl:conn (make-parameter #f))

(define (pg-repl:query . query)
  (pg:query-tuples
   (string-intersperse (map ->string query) "")
   (pg-repl:conn)))

(toplevel-command
 '-
 (lambda ()
   (pp (pg-repl:query
        (with-output-to-string
          (cut print (read-line)))))))

(toplevel-command
 'table
 (lambda ()
   (let* ((table (string-trim-both (read-line)))
          (cols
           (pg-repl:query
            "select column_name,data_type,"
            "character_maximum_length,is_nullable "
            "from information_schema.columns "
            "where table_name = '" table "'")))
     (if (null? cols)
         (print "Tabela \"" table "\" nao existe.")
         (for-each
          (lambda (f)
            (let ((colname (vector-ref f 0))
                  (type (vector-ref f 1))
                  (size (let ((size (vector-ref f 2)))
                          (if (pg:sql-null-object? size)
                              ""
                              (conc "(" size ")"))))
                  (nullable (vector-ref f 3)))
              (print
               colname
               (make-string
                (- 30 (string-length colname)))
               type size
               (make-string
                (- 30 (string-length (conc type size))))
               nullable)))
          cols)))))

(toplevel-command
 'tables
 (lambda ()
   (for-each
    (lambda (item)
      (print (vector-ref item 0)))
    (pg-repl:query
     "select table_name from information_schema.tables "
     "where table_type = 'BASE TABLE' "
     "and table_schema not in "
     "('pg_catalog', 'information_schema')"))))

(define (pg-repl:usage #!optional exit-code)
  (print (program-name) " [<user>@<server>/<database>]")
  (when exit-code (exit exit-code)))

(let ((args (command-line-arguments))
      (user "postgres")
      (host "localhost")
      (db "template")
      (passwd #f))

  ;; Restaura o terminal em caso de termino via C-c
  (set-signal-handler! signal/int
                       (lambda (_) (stty '(echo))))

  (unless (or (null? args) (equal? "\"\"" (car args)))
    (let* ((cred (string-trim-both
                  (car args)
                  (cut memq <> '(#\space #\newline #\")))) ;"
           (@tokens (string-split cred "@"))
           (/tokens (if (null? @tokens)
                        '()
                        (string-split (cadr @tokens) "/"))))
      (if (and (null? @tokens) (null? /tokens))
          (pg-repl:usage 1)
          (begin
            (unless (null? @tokens)
              (set! user (car @tokens)))
            (unless (null? /tokens)
              (set! host (car /tokens))
              (set! db (cadr /tokens)))))))
  (display "Senha: ")
  (pg-repl:conn
   (pg:connect
    `((user . ,user)
      (dbname . ,db)
      (host . ,host)
      (password . ,(with-stty '(not echo) read-line)))))
  (current-input-port (make-gnu-readline-port))
  (gnu-history-install-file-manager
   (string-append (or (getenv "HOME") ".")
                  "/.csi.history"))
  (newline)
  (repl))

Copy & comment

2008-07-31T19:21:20+00:00

Para quem seguidamente, como eu:

1. tem preguiça de criar uma revisão no VCS para alterar algo pequeno no código (só para ver se dá certo -- se não der, volta atrás rapidinho);

2. acha muito trabalhoso usar o editor de texto para duplicar um trecho de código (i.e., copiar & colar) e comentar uma das partes.

A função a seguir (em Elisp, para Emacs) faz as tarefas do item 2 para quem se enquadra no perfil do item 1:

(defun copy&comment (begin end)
  (interactive "r")
  (save-excursion
    (copy-region-as-kill begin end)
    (goto-char end)
    (yank)
    (comment-region begin end)))

XEmacs no windows

2008-07-29T14:03:39+00: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:33:20+00: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).

Misuse of technology, XML case

2008-07-16T19:16:48+00:00

I do not have strong feelings about XML, be it for or against it. I don’t use it much because I use either S-Expressions with Scheme or Lua tables with Lua. I believe XML can be helpful, but people need to know how to use it.

I have come across an application of XML to store an animation, frame by frame, like the animated GIFs of old. Each frame is then an image, stored as an XML element. The bizarre part is that every pixel is stored as an individual element inside the frame:

<frame id="Frame001" width="180" height="240">
  <array type="Int8">
    <Int8 value="230"/>
    <Int8 value="012"/>
    .
    .
    .
  </array>
</frame>

I believe this is the most “by the book” implementation. But this is far from optimal. When inspecting the files with a text editor (yes, I needed to do that) it was very painful. Besides, the files are huge! Why not be sensible and use Base64 encoding for the image part:

<frame id="Frame001" width="180" height="240">
  TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
  IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
  dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
  dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
  .
  .
  .
</frame>

Nobody could inspect the information of previous format anyway, the files gets much smaller, one could edit them by hand (like I did to copy frames between animations). And no, the files are not being compressed because they are part of a build process.

It only remains to be seen why it is done this way. I believe it was a mixture of a non-too-intimate knowledge of the technology and a desire to use it in it “purest” form, like those people who must design their programs with all the design patterns known to man. With time they may learn that a sensible dose of pragmatism is very healthy.

A biblioteca mpfr

2008-07-15T05:18:23+00: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:40:28+00: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.