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.

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.

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.

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.

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).

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).

Awful: expressões regulares para dispatching de URLs

Há pouco fiz o commit da mais nova versão de awful (0.18) . A novidade mais significativa desta versão é o suporte a dispatching de URLs através de expressões regulares. Em outras palavras, agora é possível associar uma expressão regular a um procedimento a ser executado. Assim, se o caminho da URL da requisição bate com a expressão regular, o procedimento é invocado com o caminho como argumento.

Abaixo está um exemplo simples que ilustra o que a nova versão pode fazer:

(use awful srfi-1 regex)

(define-page (regexp "/add/.*")
  (lambda (path)
    (let ((numbers (filter-map string->number (string-split path "/"))))
      (number->string (apply + numbers)))))

Se acessarmos o servidor executando o código acima através da URL http://host:port/add/1/2/3 o resultado exibido será 6.

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

Arc challenge em awful

Há dois anos, Paul Graham propôs o seguinte desafio (arc challenge):

Write a program that causes the url said (e.g. http://localhost:port/said) to produce a page with an input field and a submit button. When the submit button is pressed, that should produce a second page with a single link saying "click here." When that is clicked it should lead to a third page that says "you said: ..." where ... is whatever the user typed in the original input field. The third page must only show what the user actually typed. I.e. the value entered in the input field must not be passed in the url, or it would be possible to change the behavior of the final page by editing the url.

Abaixo está uma implementação para o arc challenge em awful:

(use awful html-utils spiffy-request-vars)

(define-session-page "said"
  (lambda ()
    (with-request-vars $ (said)
      (cond (said
             ($session-set! 'said said)
             (link "said" "click here"))
            (($session 'said)
             => (lambda (said)
                  (++ "You said: " said)))
            (else (form (++ (text-input 'said)
                            (submit-input))
                        action: "said"
                        method: 'post))))))

Para testar o programa, basta executar:

$ awful arc-challenge.scm

E acessar http://localhost:8080/said

Cálculo de fatorial através de redirecionamentos de páginas

Abaixo está uma aplicação absurdamente inútil e sem sentido usando awful: cálculo de fatorial através de redirecionamentos de páginas.

Para calcular o fatorial de 5, por exemplo, basta executar o servidor com a aplicação:

$ awful awful-fatorial.scm

e acessar http://localhost:8080/?n=5 (a entrada de dados é feita através da variável n).

O código está a seguir:

(use awful html-tags html-utils)

(root-path ".")

(define-page (main-page-path)
  (lambda ()
    (let* ((n ($ 'n 0 string->number))
           (current ($ 'current n string->number))
           (accum ($ 'accum 1 string->number))
           (finished? (< current 2)))
      (html-page
       (if finished?
           (<h1> n "! = " accum)
           "")
       headers: (if finished?
                    ""
                    (<meta> http-equiv: "refresh"
                            content: (conc "0;url=?n=" n
                                           "&accum=" (* current accum)
                                           "&current=" (sub1 current)))))))
  no-template: #t)

Suporte a múltiplos bancos de dados para Awful

A partir da versão 0.10, awful passa a oferecer suporte a múltiplos bancos de dados. Atualmente há suporte para PostgreSQL (através da extensão postgresql) e SQLite3 (através da extensão sqlite3 ou sql-de-lite).

Há uma extensão para cada tipo de base de dados: awful-postgresql, awful-sqlite3 e awful-sql-de-lite. No caso de SQLite3, pode-se optar por usar tanto a extensão sqlite3 ou sql-de-lite (duas extensões diferentes para acesso a bases SQLite3).

A forma de acesso a bases de dados continua praticamente a mesma: através do procedimento $db, o qual faz uso das facilidades oferecidas por awful (conexão transparente, fechamento automático). A única diferença é que agora é necessário carregar a extensão relativa ao tipo de base de dados que pretende-se acessar (e.g., (use awful awful-postgresql)) e usar enable-db como um procedimento sem argumentos, não um parâmetro com argumento booleano, como antes.

Abaixo está um exemplo completo de uma aplicação que gera uma página HTML com uma tabela contendo dados de nome e endereço da tabela users de uma base de dados PostgreSQL:

(use awful awful-sql-de-lite html-utils)

(enable-db)

(db-credentials "db.db")

(define-page (main-page-path)
  (lambda ()
    (tabularize ($db "select name, address from users"))))

Para publicar esta página, basta executar (supondo que o código acima está no arquivo users.scm):

$ awful users.scm

(ficará disponível em http://localhost:8080).

Se um dia for necessário migrar essa base de dados para PostgreSQL, basta usar (use awful-postgresl) em vez de (use awful-sql-de-lite) e ajustar a configuração de credenciais para acesso ao banco (no caso de SQLite3, a credencial é o caminho para o arquivo com a base de dados). Se a estrutura da base de dados não for modificada, e se forem usadas consultas SQL portáveis, o código Scheme não precisará ser alterado.

Opcionalmente, a página pode ser compilada:

$ csc -s users.scm
$ awful users.so

Simples assim. :-)

Programação para a Web com Awful

Há uns dias comecei a desenvolver mais uma tentativa de tornar a programação para a Web mais "fácil". O resultado é uma extensão para o sistema Chicken (versão 4) que fornece as seguintes funcionalidades:

• Interfaces simples para o uso de bases de dados Postgresql


• Suporte a Ajax através da biblioteca JQuery


• Acesso fácil às variáveis de requisições HTTP (tanto da query string (método GET) quando do corpo da requisição (e.g., método POST)


• Flexibilidade: há vários parâmetros de configuração


• A compilação de páginas para código nativo para a plataforma alvo é fácil


• Disponibilidade de um visualizador de sessão


• Disponibilidade de um REPL que pode ser acessado através do navegador (via HTTP) para a depuração de aplicações para a web

Tentei fazer uma documentação razoável, que cobrisse boa parte da implementação. Ela está em http://chicken.wiki.br/eggref/4/awful. Na documentação podem ser vistos exemplos de aplicações simples que demonstram algumas das funcionalidades.

Sobre o nome: é só um nome. :-) Em http://chicken.wiki.br/eggref/4/awful#the-name há algumas possíveis interpretações caso AWFUL fosse uma sigla.