Chicken 4.8.0

Foi lançada hoje a versão 4.8.0 do compilador Chicken.  Muitas correções de bugs e melhorias.  A lista completa de novidades pode ser vista no arquivo NEWS.

O destaque fica para o mecanismo de análise de fluxo adicionado ao compilador, o qual permite a detecção de problemas de tipagem em tempo de compilação e a reescrita de código visando aumento de desempenho.

paste.call-cc.org (pastiche)

Hoje foi anunciado o serviço de pasting em call-cc.org (o servidor do projeto Chicken), disponibilizado através de http://paste.call-cc.org. Em linhas gerais, o serviço permite colar trechos de código para que outras pessoas possam ver. É bem útil em discussões via IRC.

paste.call-cc.org executa pastiche, uma aplicação para a web desenvolvida por Christian Kellermann. É feita em Chicken Scheme, usando awful.

Chicken no Twitter

Chicken entrou no moderno mundo da web social com uma conta no twitter.

Primeiro esboço de R7RS

Ontem foi anunciado o primeiro esboço [PDF] da nova versão da especificação de Scheme.

O comitê responsável por preparar a nova versão da especificação decidiu dividi-la em duas partes: uma básica e outra com funcionalidades opcionais que podem não ser necessárias ou adequadas em alguns contextos. O documento anunciado é referente à parte básica (small language).

Felizmente, R7RS baseia-se em R5RS, e não em R6RS. O texto preliminar da nova especificação é de leitura agradável, não sendo tão "denso" quanto o das versões anteriores.

Novas versões para awful e extensões de suporte a bancos de dados

Há pouco foram lançadas versões novas das extensões awful, awful-sql-de-lite, awful-sqlite3 e awful-postgresql.

Os destaques da nova versão de awful são as melhorias significativas para possibilitar a instalação de múltiplos aplicativos em um mesmo virtual host, uma interface sobre spiffy-request-vars e a correção de um bug crítico devido ao reuso de threads feito pelo servidor web Spiffy.

As notas sobre a nova versão de awful (0.31) estão abaixo:

* Added a tiny wrapper around spiffy-request-vars, adding the
   with-request-variables macro and exporting
   spiffy-request-vars's converters.
* Updated JQuery from version 1.5.1 to 1.5.2.
* Better support for multiple applications under the same virtual
  host (add-request-handler-hook! and remove-request-handler-hook!)
* $db checks if database access is enabled via (enable-db) and
  throws an error if it is not.
* Fixed critical bug regarding to parameters and thread reuse by Spiffy
* Fixed redirect-to but introduced in version 0.29

As novas versões das extensões de suporte a sistemas de bancos de dados exportam um novo procedimento para permitir o chaveamento entre bases de diferentes bancos. Assim, o uso de múltiplos sistemas de bancos de dados (e múltiplas bases de dados) em awful fica facilitado.

Alinhamento de astros

Uma coincidência: atualmente as duas mais expressivas implementações de compilador de Scheme->C (Chicken e Gambit) e um dos mais importantes compiladores de C (GCC) estão na mesma versão: 4.6.

A expectativa é que Chicken quebre esse alinhamento nos próximos dias com o lançamento da versão 4.7.

Hoje a versão release candidate para 4.7.0 foi atualizada no branch prerelease do repositório git do compilador.

Também hoje foi lançado o tarball de desenvolvimento, versão 4.6.7, com as funcionalidades que farão parte da versão 4.7.0.

Awful 0.29

Há pouco foi lançada a versão 0.29 de awful. Nada de muito revolucionário nesta nova versão, mas correção de pelo menos um bug crítico e novas funcionalidades/atualizações menores. O changelog para a versão 0.29 está abaixo:

* Updated JQuery from version 1.5.0 to 1.5.1.
* ajax and periodical-ajax bugfix (for situations when they
  are used simultaneously, or periodical-ajax and add-javascript).
* The default URI for ajax-library is now protocol-relative
  (thanks to Peter Bex).
* Added the javascript-position parameter.

REPL ilustrado

O REPL (Read, Eval, Print, Loop), vulgar e erroneamente conhecido como interpretador (existem compiladores com ambiente interativo), é uma das ferramentas mais indispensáveis para programadores. É o tipo de coisa que, depois que nos acostumamos a usar, é difícil viver sem.

Abaixo está uma implementação simplificada e graficamente comentada em Chicken Scheme que ilustra o conceito:






O código acima é executável:

$ csi -s repl.scm
(define (fatorial n) (if (< n 2) 1 (* n (fatorial (- n 1)))))
#<unspecified>
(fatorial 6)
720

Awful 0.28 e awful-ssl

Hoje foi lançada a versão 0.28 de awful. A nova versão apresenta correções de bugs, soluções para algumas limitações e algumas novas funcionalidades.

Também foi lançada a versão inicial da extensão awful-ssl, a qual permite o uso de awful com SSL de forma fácil.

accents-substitute

Seguidamente tenho a necessidade de remover acentos de textos em português. Há umas semanas fiz uma extensão para Chicken chamada accents-substitute substituir caracteres acentuados pelos correspondentes sem acento (ou com entidades de HTML).

A extensão aceita textos em Latin1 (ISO-8859-1) ou UTF-8, havendo um módulo para cada codificação, ambos provendo o mesmo procedimento: accents-substitute (nome inspirado em string-substitute, da extensão regex).

Para facilitar o uso no dia-a-dia, fiz um pequeno script que usa o procedimento {{accents-substitute}}. Abaixo estão alguns exemplos de uso:

$ accents-substitute --help
Usage: accents-substitute [ --encoding= ] [ --mode= ] [ input file ]

Default values:
   mode: ascii
   encoding: utf8

$ cat lisp-br
Lisp-BR é um projeto que tem por objetivo divulgar linguagens de
programação da família Lisp no Brasil e formar uma comunidade de
usuários que tenham vontade de aprender não só uma nova forma de
programar, mas também uma nova maneira de pensar!

$ cat lisp-br | accents-substitute 
Lisp-BR e um projeto que tem por objetivo divulgar linguagens de
programacao da familia Lisp no Brasil e formar uma comunidade de
usuarios que tenham vontade de aprender nao so uma nova forma de
programar, mas tambem uma nova maneira de pensar!

$ accents-substitute --mode=html lisp-br
Lisp-BR é um projeto que tem por objetivo divulgar linguagens de
programação da família Lisp no Brasil e formar uma comunidade de
usuários que tenham vontade de aprender não só uma nova forma de
programar, mas também uma nova maneira de pensar!

O código da ferramenta de linha de comando está a seguir:

#!/bin/sh
#| -*- scheme -*-
exec csi -s $0 "$@"
|#

(use
 (rename
  accents-substitute-latin1
  (accents-substitute accents-substitute-latin1))
 (rename
  accents-substitute-utf8
  (accents-substitute accents-substitute-utf8)))

(use posix regex (srfi 1 13))

(define (command-line-argument option args)
  ;; Return the argument associated to the command line option OPTION
  ;; in ARGS or #f if OPTION is not found in ARGS or doesn't have any
  ;; argument.
  (let ((val (any (cut string-match (string-append option "=(.*)") <>) args)))
    (and val (cadr val))))

(define (usage #!optional exit-code)
  (print "Usage: " (pathname-strip-directory (program-name))
         " [ --encoding=<utf8|latin1> ] [ --mode=<ascii|html> ] [ input file ]")
  (print "\nDefault values:\n"
         "    mode: ascii\n"
         "    encoding: utf8")
  (when exit-code (exit exit-code)))

(let* ((args (command-line-arguments))
       (mode (command-line-argument "--mode" args))
       (encoding (command-line-argument "--encoding" args))
       (paramless-args (remove (cut string-prefix? "--" <>) args))
       (accents-substitute accents-substitute-utf8))

  (when (or (member "-h" args) (member "--help" args))
    (usage 0))

  (when (and encoding (not (member encoding '("utf8" "latin1"))))
    (print "'" encoding "' is not a valid encoding.")
    (exit 1))

  (when (and mode (not (member mode '("ascii" "html"))))
    (print "'" mode "' is not a valid mode.")
    (exit 1))

  (when (equal? encoding "latin1")
    (set! accents-substitute accents-substitute-latin1))

  (let ((port (if (null? paramless-args)
                  (current-input-port)
                  (open-input-file (car paramless-args)))))
    (let loop ()
      (let ((line (read-line port)))
        (unless (eof-object? line)
          (print (accents-substitute line mode: (and mode (string->symbol mode))))
          (loop))))
    (unless (null? paramless-args)
      (close-input-port port))))

Adicionei este exemplo de aplicação à seção Examples da documentação de accents-substitute.

Awful no Windows ("That's too awful")

Com a correção da extensão sendfile (por David Krentzlin) para Windows, awful passa a funcionar também no sistema das telas azuis.



As correções ainda não foram oficialmente lançadas (i.e., ainda não estão disponíveis para serem instaladas via chicken-install), mas podem ser obtidas em http://code.call-cc.org/svn/chicken-eggs/release/4/sendfile/trunk/ (usuário: anonymous, sem senha).

Migração de site estático para awful: tratando requisições por index.html

Até pouco tempo atrás a minha página pessoal era totalmente estática. Depois que comecei a desenvolver awful achei que seria meio vergonhoso se a minha própria página não usasse o software que produzo. Então resolvi refazê-la usando awful (eu poderia simplesmente jogar os arquivos estáticos para o servidor web disponibilizá-los, mas não teria graça).

Um problema que ocorreu na migração do site estático para o com use de awful foi a ausência de arquivos index.html. Várias páginas eram disponibilizadas e referenciadas através um arquivo index.html, e esses arquivos não existem mais na nova estrutura com awful. A solução que adotei foi redirecionar os acessos aos arquivos index.html para o nome do "diretório" que os contém (na verdade não são diretórios, mas URIs associadas a procedimentos em Scheme).

Por exemplo, antes havia http://parenteses.org/mario/index.html. Hoje há um procedimento associado a http://parenteses.org/mario.

Com a possibilidade de associar procedimentos a URIs que casa com uma expressão regular, fazer com que http://parenteses.org/mario responda por http://parenteses.org/mario/index.html se torna bem fácil:

(use awful)

(define-page (regexp "/mario/.*index.html")
  (lambda (path)
    (redirect-to (string-chomp path "index.html"))))

Assim, todas as requisições por recursos /index.html disponíveis no caminho /mario/ serão redirecionadas para /.

Awful 0.26

Há pouco lancei a versão 0.26 de awful. A principal novidade é a integração de um editor em javascript para o web REPL (o texto anterior é sobre isso).


Houve algumas modificações para tornar o web REPL mais útil para desenvolvimento interativo, como a possibilidade de redefinir e eliminar definições de páginas em tempo de execução.

Coloquei em http://wiki.call-cc.org/video/awful-guess.ogv um vídeo mostrando o desenvolvimento de um simples jogo de adivinhação de números, com o uso de ajax e do web REPL.

Em http://parenteses.org/jogos há versões mais elaboradas de jogos no mesmo estilo.

Awful fancy web REPL

Estou pensando em adicionar um editor de código em Javascript ao web REPL de awful. A idéia é facilitar a prototipação rápida, execução de testes, depuração e correção de problemas de forma fácil e com o servidor em execução.

A versão de desenvolvimento de awful contém um código inicial para isso. Abaixo está um screencast do que está implementado até agora.



O arquivo do vídeo, com uma qualidade significativamente melhor do que o mostrado acima, pode ser obtido em http://parenteses.org/mario/misc/fancy-web-repl.ogv (~6.1MB).

O editor em Javascript que estou utilizando é o Codemirror.

Awful 0.25

Há pouco foi lançada a versão 0.25 de awful. A seguir são descritas as novidades.

O servidor awful admite novos parâmetros de linha de comando: --development-mode, --ip-address e --port. Os parâmetros --development-mode e --port servem, respectivamente, para fazer com que o servidor escute nos dados endereço IP e porta.

O parâmetro --development-mode ativa o modo de desenvolvimento de awful. Neste modo, funcionalidades como o Web REPL e o Session inspector são automaticamente ativadas. O caminho /reload também é automaticamente criado para que as aplicações possam ser recarregadas sem que seja necessário reiniciar o servidor. No modo de desenvolvimento, mensagens de erro das aplicações são exibidas no cliente (e.g., navegador). Abaixo está um exemplo (erro.scm):

#!/usr/bin/awful

(use awful)

(define-page (main-page-path)
  (lambda ()
    (++ "Oops " 'erro)))

Para executar no modo de desenvolvimento:

$ awful --development-mode erro.scm

Ao acessar http://localhost:8080/ a mensagem de erro do screenshot abaixo é exibida no navegador, seguida de um link para o Web REPL.



Quando executado em modo de desenvolvimento, o parâmetro development-mode? tem como valor #t.

Outra novidade é o parâmetro awful-response-headers o qual permite ajustar os campos do cabeçalho de resposta para o cliente. Abaixo está um exemplo de um procedimento para associar URIs a respostas JSON:

#!/usr/bin/awful

(use awful)

(define (define-json path body)
  (define-page path
    (lambda ()
      (awful-response-headers '((content-type "text/json")))
      (body))
    no-template: #t))

(define-json (main-page-path)
  (lambda ()
    "{a: 1}"))

A menos que explicitamente fornecido, awful calcula automaticamente o tamanho da resposta e o atribui ao campo Content-Length.

Hoje também disponibilizei um pequeno texto com instruções sobre como instalar awful em sistemas Unix[-like].

Awful 0.24

Há pouco foi lançada a versão 0.24 de awful. As novidades que mais se destacam, além de algumas pequenas melhorias e da correção de alguns bugs que ocorriam em casos especiais, há o suporte inicial a armazenamento de identificadores de sessão em cookies (via spiffy-cookies) e o suporte a redirecionamentos de forma fácil (procedimento redirect-to).

A seguir está um exemplo de definição de um redirecionador:

(define-page "/mario"
  (lambda ()
    (redirect-to "http://parenteses.org/mario")))

A definição do redirecionador pode ser encurtada com o uso de cut:

(define-page "/mario" (cut redirect-to "http://parenteses.org/mario"))

Também aproveitei para dar uma embelezada no web REPL e no inspetor de sessão (screenshots abaixo).

10 anos de Chicken!

Há dez anos foi publicado o anúncio da primeira versão pública de Chicken: http://groups.google.com/group/comp.lang.scheme/msg/edfb2da16fd89fae

Em http://web.archive.org/web/20000824034645/http://www.anu.ie/felix/chicken.html está a página do projeto, como era na época.

Awful scripts

Uma dica rápida para executar aplicações web em awful como scripts em sistemas Unix[-compatíveis]: usando a linha com shebang.

Dessa forma, basta executar o arquivo com a aplicação web como se fosse um arquivo executável qualquer:

$ cat hello-world.scm
#! /usr/bin/awful

(use awful)

(define-page (main-page-path)
  (lambda ()
    "Hello, world!"))

$ ./hello-word.scm

Sintaxe para definição de "curried procedures"

A definição de curried procedures é bastante usual em Scheme. Consiste em fazer com que o valor produzido por um procedimento seja outro procedimento.

Abaixo está um exemplo de um criador de objetos que respondem a mensagens:

(define (make-obj)
  (lambda (message)
    (case message
      ((hello) "Hello!")
      ((bye) "Bye bye!")
      (else (error "Unknown message.")))))

O código acima já está com uma sintaxe simplificada para definições de procedimentos. A forma mais longa seria:

(define make-obj
  (lambda ()
    (lambda (message)
      (case message
        ((hello) "Hello!")
        ((bye) "Bye bye!")
 (else (error "Unknown message."))))))

Não está na especificação da linguagem, mas algumas implementações oferecem a possibilidade de usar uma sintaxe mais simplificada para a definição de curried procedures:

(define ((make-obj) message)
  (case message
    ((hello) "Hello!")
    ((bye) "Bye bye!")
    (else (error "Unknown message."))))

Das implementações em que testei, Chicken, Guile, MIT Scheme e PLT admitem essa sintaxe para definição de curried procedures. Ypsilon e Gambit não admitem.

Scheme sem parênteses

Para aqueles que não usam Scheme só por causa dos parênteses: seus problemas acabaram! Basta substituir os parênteses por colchetes.

[define [fatorial n]
  [if [< n 2]
      1
      [* n [fatorial [- n 1]]]]]

[display [fatorial 5]]
[newline]

Exemplos com algumas implementações:

Chicken:

$ csi -s fatorial.scm 
120

Gambit:

$ gsi fatorial.scm 
120

PLT:

$ mzscheme -f fatorial.scm 
120

Ypsilon:

$ ypsilon fatorial.scm 
120

Embora [ e ] sejam caracteres reservados em R5RS, muitas implementações os utilizam como sinônimos para parênteses. É comum a prática de uso de colchetes para associações entre variáveis e valores em formas let. Exemplo:

(let ([a 3]
      [b 4]
      [c 5])
   (+ a b c))

Eu, particularmente, não costumo usar colchetes como sinônimo de parênteses, mas já vi muito código que usa.