Kodumaro

Média harmónica

2012-01-22T07:02:00.007-03:00

Já que falávamos de variâncias e médias, um dos cálculos mais belos de média é a média harmónica.

Vou roubar ~~a explicação~~ o exemplo da Wikipédia por pura preguiça… :-/

[update]
Roubar a explicação não… roubei o exemplo. Para a explicação deixei o apontador para o artigo na Wikipédia – mais preguiçoso ainda!
[/update]

Você se lembra do colégio, quando tinha de calcular a velocidade média percorrida por um carro, certo? Imagine que um carro faz uma viagem de x horas, tendo percorrido metade do tempo a 40Km/h e a outra metade a 60Km/h.

Calcular a velocidade média é bem fácil, não?

Então o carro percorreu a distância a uma velocidade média de 50Km/h, tornando fácil calcular, por exemplo, a distância: se o carro andou por 3h, percorreu 150Km.

Porém imagine que a proposição do problema não fosse quanto ao tempo, mas quanto à distância…

O carro percorreu metade do percurso (não do tempo) a 40Km/h e outra metade a 60Km/h. Qual a velocidade média?

Para obter esse resultado, precisamos da média harmónica:

Então é o equivalente a percorrer todo o trajeto a 48Km/h.

Isso também se aplica a diversos outros ramos, como a matemática financeira: se um investidor aplica um mesmo valor em compra de ações todos os meses, no final o preço médio das ações será a média harmónica dos preços das ações em cada mês.

Mãos à massa

Conversamos até agora sobre matemática, agora é hora de ver o código! Usarei novamente Scheme.

Vamos nos concentrar primeiro no cálculo do denominador. Novamente apelaremos para map/reduce.

O map será usado para inverter cada um dos elementos, para tanto usaremos a função lambda (λx.(1/x))x_i:

(map (lambda (x) (/ 1 x)) *list*)

Feio isso, precisaremos de um somatório desses elementos, portanto usaremos reduce novamente com #'apply e #'+:

(apply +
       (map (lambda (x) (/ 1 x)) *list*))

O numerador é fácil, é a quantidade de elementos, ou tamanho da lista:

(length *list*)

Basta dividirmos um pelo outro e, quase sem querer, já temos o cálculo da média harmónica!

(define harmonic-mean
  (lambda (*list*)
    (/
      (length *list*)
      (apply +
             (map (lambda (x) (/ 1 x)) *list*)))))

Se quiser testar com os valores do exemplo (40Km/h e 60Km/h):

(let ((params '(40 60)))
  (display (harmonic-mean params))
  (newline))

[update]
Ainda esperando o pessoal do Prettify corrigir o syntax highlighting para LISP.
[/update]

[]’s
Cacilhας, La Batalema

Dissecando a variância

2012-01-16T23:08:00.005-03:00

Este artigo dá seguimento ao artigo sobre variância amostral.

A variância pode ser entendida como a média aritmética dos quadrados dos desvios de cada elemento da população.

O desvio de um elemento é a diferença entre o elemento e seu valor esperado. Quando lidamos com um conjunto, o valor esperado é a média dos elementos.

Então o desvio do elemento x_i é x_i - x.

A variância populacional pode ser descrita como:

Na maioria dos casos, não se tem disponível todos os elementos de um conjunto, mas apenas uma amostra. Nesses casos, calculamos a variância de amostra ou variância amostral.

A diferença no cálculo é que, em vez de dividirmos pelo número total de elementos da amostra no cálculo da média, dividimos pelo número total menos um, o que aumenta o resultado do desvio padrão, compensando não conhecermos todos os elementos do conjunto.

Então o cálculo muda para:

Em Erlang, para calcular o somatório dos desvios, primeiros usamos list comprehension para gerar uma lista dos quadrados desvios:

[math:pow(Xi - Xm, 2) || Xi <- List]

O que este código diz é: retorne a lista dos quadrados (math:pow/2) das diferenças entre cada elemento (Xi) da lista (Xi <- List) e sua média (Xm, calculado anteriormente).

Depois ele usa math:sum/1 para gerar um somatório e retorna a divisão do resultado do somatório pelo tamanho da lista menos um (Num / Demon).

Volte ao artigo anterior para ver como fica o código.

Em Scheme, a lógica é quase a mesma, mas em vez de list comprehension, é usado map/reduce. O #'map roda a função anónima (lambda) em cada elemento, extraindo os quadrados dos desvios.

[update]
Troquei o link para map/reduce, que apontava para um arcabouço do Google, quando as referências reais seriam encontradas no segundo parágrafo do texto referenciado.
[/update]

A função usada foi (λx.(x - x)²)x_i, ou: (lambda (x) (expt (- x xm) 2)) em LISP.

Para o reduce (#'apply) é usado somatório (#'+), aplicado ao conjunto resultante.

Novalmente, volte ao artigo anterior para ver o código.

[]’s
Cacilhας, La Batalema

Variância

2012-01-15T20:06:00.005-03:00

Uma das operações mais importantes e necessárias da matemática é a variância de amostra. É usada, por exemplo, para o cálculo do desvio padrão e da regressão linear.

Usando linguagens funcionais, a implementação fica muito mais elegante.

Erlang

Em Erlang, a função para o cálculo da variância toma o seguinte formato:

variance(List) ->
    Xm = mean(List),
    Num = lists:sum([math:pow(Xi - Xm, 2) || Xi <- List]),
    Denom = length(List) - 1,
    Num / Denom.

É preciso ainda definir a função de média, mean/1:

mean(List) ->
    lists:sum(List) / length(List).

LISP

Em Scheme a implementação é um pouco mais verbosa, mas ainda assim elegante.

Segue o código em R⁵RS:

(define variance
  (lambda (*list*)
    (let ((xm (mean *list*)))
      (/
       (apply +
              (map (lambda (x) (expt (- x xm) 2)) *list*))
       (- (length *list*) 1)))))

Também precisamos implementar a média:

(define mean
  (lambda (*list*)
    (/
     (apply + *list*)
     (length *list*))))

Paradigma imperativo

Para comparação, segue a implementação de variância em uma linguagem imperativa, C:

double variance(int length, double *list) {
    double x_mean = mean(length, list);
    double sum = 0;
    int i;

    for (i=0; i<length; ++i)
        sum += pow(list[i] - x_mean, 2.);

    return sum / (length - 1);
}

É preciso incluir o cabeçalho math.h. Segue a implementação da função mean():

double mean(int length, double *list) {
    double sum = 0;
    int i;

    for (i=0; i<length; ++i)
        sum += list[i];

    return sum / length;
}

Perceba a mudança de estado, o que não ocorre nos códigos funcionais.

Escolhi C em vez de Python, porque Python também suporta bem o paradigma funcional, enquanto C é quase necessariamente imperativa.

[]’s
Cacilhας, La Batalema

Racket

2011-10-17T15:48:00.019-03:00

Outro dia procurando por um bom interpretador/compilador para R⁶RS, encontrei algo muito mais interessante…

Encontrei o RAD-IDE Racket, antigo DrScheme.

O interessante do Racket é que, além de ser um interpretador e compilador de R⁵RS e R⁶RS, também suporta – aliás, por padrão – uma linguagem de programação baseada em Scheme, também chamada Racket – antiga PLT Scheme –, muito poderosa; também traz um ambiente de desenvolvimento chamado DrRacket.

Quando você escreve um script em Scheme, a primeira linha indica a versão que você pretende usar:

#!r4rs

Ou:

#!r5rs

Ou:

#!r6rs

Se o interpretador suportar a versão, ela será usada. Já no caso do Racket, outras opções são suportadas, como o padrão:

#lang racket

Para a linguagem padrão.

[update 2011-10-18]
Um script R⁶RS começa sempre com um import, por exemplo:
#!r6rs
(import (rnrs))
Você pode ter as funções de R⁶RS em um código Racket (PLT), basta usar:
#lang racket
(require rnrs)
O módulo rnrs traz toda a funcionalidade de R⁶RS.

Outra coisa legal da linguagem Racket é que, em vez de lambda, você pode usar λ (⌘\ / C-\).
[/update]

E até mesmo:

#lang planet jaymccarthy/c

Para linguagem de programação C – uma opção de C interpretado!

Para tanto você precisa ter em seu ~/.racketrc o seguinte conteúdo:

#lang racket
(require (planet jaymccarthy/c:1:2))

Para instalar o módulo C, você pode executar no widget de definições (⌘D no Mac OS X, C-d no Windows e no GNU/Linux):

> (require (planet "main.rkt" ("jaymccarthy" "c.plt" 1 2)))

[update 2011-10-18]
Eu acho que você não precise instalar o módulo, basta colocar sua chamada em ~/.racketrc e, na primeira execução, o módulo será automaticamente baixado e instalado.

Só não posso afirmar com certeza porque eu já havia instalado ele antes.

No Windows, o arquivo é racketrc.rktl e deve ficar no diretório de perfil do usuário.
[/update]

Programação visual

Para facilitar a vida de quem precisa desenvolver aplicações gráficas, você pode usar o MrEd Designer.

Para instalá-lo, execute no widget de definições do DrRacket:

> (require (planet orseau/mred-designer:3:7))

Para iniciar o processo, use (recomendo criar um alias):

bash$ gracket -e '(require (planet orseau/mred-designer:3:7))'

Olá Mundo!

Vamos criar um programa simples. Primeiro abra o MrEd Designer.

[update 2011-10-19]
Troquei os nomes dos widgets pelos nomes usados no código Racket.
[/update]

Na janela Hierarchy selecione project-XXX.

Na janela MrEd Designer, na seção Containers, clique no primeiro botão, frame%.

Vai surgir uma janela pequena e, na hierarquia do projeto, um frame% (frame-XXXX) sob o projeto.

Na janela Hierarchy selecione o frame% que apareceu e repare que a janela Properties mudou.

Em Properties, mude o valor de label (que está Frame) para Olá Mundo! e clique em Save & Update Preview.

Veja que o título da janela mudou.

Agora, ainda com o frame% selecionado, na janela MrEd Designer, na seção Controls, clique no primeiro botão, message%. Repare que surgiu um elemento message% (message-XXXX) na hieraquia, sob o frame%.

Selecione o novo elemento e mude o label (em Properties) para Olá Mundo!.

Clique em Choose Font… e escolha uma fonte maior, sugiro Arial Bold 20, e clique em Ok.

Clique novamente em Save & Update Preview.

Selecione de novo o frame% em Hierarchy e, em MrEd Designer → Controls, clique no segundo botão, button%.

Surgirá um elemento button% (button-XXXX) sob o frame%. Selecione-o.

Mude o label para Ok e a fonte para Arial 14. Clique em Save & Update Preview.

Agora, na janela MrEd Designer, no menu File clique em Save Project – ou pressione ⌘S / C-s. Escolha o diretório e salve como ola.

Depois clique em File → Generate Scheme File… – ⌘F5 no Mac. Salve como ola.ss no mesmo diretório onde você salvou o projeto.

Repare que você terá dois arquivos: ola.*.med (o projeto) e ola.ss (o código).

Abra agora o arquivo ola.ss no DrRacket:

bash$ drracket ola.ss

Procure a seguinte linha:

(button-XXXX-callback (lambda (button control-event) (void))))

Onde XXXX é uma sequência de dígitos decimais.

Mude para:

(button-XXXX-callback (lambda (button control-event) (displayln "Olá Mundo!"))))

Veja a linha 8 do script:

;;; Call (project-XXX-init) with optional arguments to this module

Acrescente a linha sugerida ao final do arquivo:

(project-XXX-init)

Salve o arquivo – ⌘S / C-s – depois rode/corra o programa – ⌘T / C-t – e veja a mágica.

Para executar o script sem precisar levantar o DrRacket, use o comando:

bash$ gracket ola.ss

Se preferir tornar o script executável, acrescente a primeira linha:

#!/usr/bin/env gracket

Outros recursos

Você pode encontrar uma série de módulos interessantes no PLaneT, como facilidades web, conexão a banco de dados, bzlib, Plan9, JSON, etc.

Sobre construção de aplicações web, leia Continue: Web Applications in Racket.

[]’s
Cacilhας, La Batalema

R.I.P. Dennis Ritchie

2011-10-15T09:22:00.003-03:00

Artigo original nas Reflexões de Monte Gasppa e Giulia C..

No mesmo mês em que morreu o mago da distorção da realidade, também nos deixa Dennis Ritchie, criador das linguagens de programação B (baseada em APL) e C e cocriador do sistema operacional UNIX.

Se Steve Jobs esteve envolvido direta ou indiretamente com cada avanço tecnológico que não fosse voltado para resolver problemas da própria máquina, salvo raríssimas exceções, Dennis Ritchie foi o criador da linguagem de programação – e dos conceitos envolvidos – usada como base para quase todas as linguagens modernas, além de ter participado ativa e diretamente da criação do sistema operacional que serve de base para todos os sistemas atuais que funcionam.

A parte mais triste é ver todo o bafafá em cima do falecimento de Jobs, mas nada se fala de Ritchie, tão importante quanto. Ou pior… vi programadores que não sabem quem foi Dennis Ritchie!

Como eu disse, um programador que não conheça Dennis Ritchie, Dijkstra e Knuth precisa mudar de profissão ou tomar muita porrada.

[]’s
Cacilhας, La Batalema

Falsa indução ou a falácia da metodologia infalível

2011-09-14T22:52:00.014-03:00

Reza a lenda que um código bem testado é um código sem bugs.

Além de não acreditar em código sem bugs, ainda há um problema com a definição de «bem testado».

Hoje em dia os evangelistas das novas ~~velhas~~ metodologias de programação defendem que a experiência profissional seja secundária – quiçá irrelevante – caso as metodologias agile sejam corretamente aplicadas, e uma das regras de outro é entupir o código de testes.

Porém quantidade não é qualidade. Não adianta encher o código de testes se você não tem feeling sobre o que testar – e feeling só se adquire com experiência profissional.

Há uma série de armadilhas prontas para pegar os incautos que se creem blindados pelas metodologias.

Uma armadilha comum é a falsa indução.

Por exemplo, tenho um código que calcula a raiz quadrada e trinta testes para ele, todos passando:

bash$ nosetests
..............................
----------------------------------------------------------------------
Ran 30 tests in 0.013s

OK

No entanto, quando eu tento alguns valores:

bash$ python
Python 2.6.1 (r261:67515, Jun 24 2010, 21:47:49) 
[GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from sqr import sqr
>>> sqr(16) # 4
7
>>> sqr(25) # 5
7
>>> sqr(144) # 12
45
>>> sqr(225) # 15
27
>>> sqr(256) # 16
58

Valores completamente loucos! Isso porque o código caiu em uma falsa indução:

# coding: UTF-8

from math import ceil

__all__ = ['sqr']

def sqr(num):
    d = 10 ** int(ceil(len(str(num)) / 2.))
    return (num % d) + (num // d)

É claro que uma boa metodologia, como TDD, é um ferramenta poderosíssima nas mãos de um programador experiente, mas pode se tornar uma arma de autodestruição nas mãos de um novato com excesso de confiança.

Então repito o conselho de um autor que escreveu, mais ou menos isto: não aprenda a programar em dez horas ou em dez dias; aprenda a programar em dez anos.

[]’jn
Cacilhας, La Batalema

PS: Você pode baixar os testes de http://cacilhas.info/falsa-inducao/tests.py. Repare que se substituir:

from sqr import sqr

por:

from math import sqrt as sqr

os testes continuam passando.

Prolog

2011-07-12T13:06:00.004-03:00

Certamente Prolog não é meu forte… nunca fiz nada útil em Prolog e não conheço a linguagem tanto quanto gostaria, mas já tive meu samadhi.

Prolog é uma linguagem de programação declarativa de propósito geral, voltada para inteligência artificial e linguística computacional.

Seu nome significa programmation en logique e foi criada no começo da década de 1970 por um grupo liderado por Alain Colmerauer em Marseille, França.

Predicados e domínio

A programação Prolog consiste em definir um conjunto de verdades chamadas fatos e relações entre os fatos, chamadas regras.

De um modo geral, fatos e regras são chamados predicados e o conjunto de predicados do programa é chamado domínio do problema.

Um fato define uma afirmação, uma verdade:

flor(cravo).

Esta linha de código está dizendo «cravo é uma flor», e é um predicado do domínio.

Regra é um predicado condicional:

gosta(ana, X) :- flor(X).

Ana gosta de X se X for uma flor, ou de forma mais precisa: se Ana gosta de X implica que X é um flor, ou seja, leia :- como implica em.

Lembre-se que implicância é uma operação não recíproca.

Consultas

O uso de Prolog se dá através de consultas (queries). Por exemplo, salve as duas linhas acima no arquivo ana.pro, execute o interpretador e digite:

| ?- [ana].
compiling ~/ana.pro for byte code...
~/ana.pro compiled, 2 lines read - 419 bytes written, 14 ms

(1 ms) yes
| ?- gosta(ana, cravo).

yes
| ?- gosta(ana, gato).

no

Tipos

Prolog possui quatro tipos: átomo, termo composto, número e lista. Um fato precisa ser um átomo ou um termo composto.

Átomo: é uma constante. Representado por uma sequência de letras, números e underscore iniciada por uma letra minúscula ou uma sequência entre plicas. Ex.: cravo, 'ana.pro', 'Cacilhας, La Batalema'.

Termo composto: é uma estrutura complexa. Consiste em um funtor seguido por um ou mais parâmetros entre parêntesis. O funtor deve ser um átomo, os parâmetros podem ser de quaisquer tipos. Ex.: gosta(ana, gato).

Número: exatamente o que diz. É representado por dígitos numéricos e ponto (para ponto flutuante.) Ex.: 123, 3.1415.

Lista: é uma sequência de elementos de outros tipos. Os delimitadores de início e fim são [] e os elementos são separados por vírgulas. O símbolo pipe (|) por ser usado para representar resto da lista. Ex.: [a, b, c], [abc | SX] (SX é uma lista).

String: é um tipo especial de lista que contém apenas números inteiros entre 0 e 255. Ex.: "ABC" ≡ [65, 66, 67].

Incógnita

O equivalente a variável em Prolog é a incógnita, que consiste em um valor desconhecido, porém constante, representado por uma sequência similar ao átomo, mas iniciada por uma letra maiúscula.

Por exemplo, em:

gosta(ana, X) :- flor(X).

X é uma incógnita. A solução das consultas feitas acima é obtida encontrando o valor de X, o que é responsabilidade do programa.

Exemplo

Um exemplo clássico de Prolog é a implementação de fatorial:

factorial(0, 1).

factorial(N, F) :-
    N > 0,
    N1 is N - 1,
    factorial(N1, F1),
    F is N * F1.

O que o código diz é que o fatorial de 0 é 1 e se o fatorial de N é F implica que:

N é maior que 0 (já está coberto pelo predicado anterior);
N1 é igual a N menos 1;
O fatorial de N1 é F1;
E F é igual a N vezes F1.

Uso:

| ?- [factorial].
compiling ~/factorial.pro for byte code...
~/factorial.pro compiled, 7 lines read - 941 bytes written, 14 ms

(1 ms) yes
| ?- factorial(5, X).

X = 120 ?

yes

Um bom exemplo também é a implementação da solução da torre de Hanói, mas vai fritar seu cérebro:

hanoi(N) :- move(N, esquerda, direita, central).

move(1, X, Y, _) :-
    write('mova o disco da torre '),
    write(X),
    write(' para a torre '),
    write(Y),
    nl.

move(N, X, Y, Z) :-
    N > 1,
    M is N - 1,
    move(M, X, Z, Y),
    move(1, X, Y, _),
    move(M, Z, Y, X).

É claro que isso não é nem o começo. O objetivo é apenas causar água na boca.

[]’s
Cacilhας, La Batalema

Decoradores em Lua

2011-03-13T23:08:00.010-03:00

Um recurso extremamente útil em Python é o uso de decoradores.

Por exemplo, um decorador que memoíze o resultado de uma função:

def memo(func, buffer={}):
    def wrapper(*args):
        if args in buffer:
            response = buffer[args]
        else:
            response = buffer[args] = func(*args)
        return response

    return wrapper

Assim funções como o cálculo recursivo da sequência de Fibonacci se tornam menos custosas:

@memo
def fibonacci(n):
    if n < 2:
        return 1
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)

Observação: memoização consome muita memória!

É possível ver que, em Python, decoradores são extremamente fáceis de se implementar e usar, o que permite usos bastantes complexos, como a orientação a aspecto.

Lua também suporta decoradores, mas de uma forma um pouco menos intuitiva, mais complexa e totalmente macetada.

Para a criação de decoradores em Lua, é usada a sobrecarga do operador de concatenação, como sugerido na literatura de referência.

Para criarmos então o decorador de memoização, precisamos de uma metatabela que sobrecarregue o operador:

local mt = {
    __concat = function(self, func)
        return function(...)
            local response
            local args = serialize(...)
            if self[args] then
                response = self[args]
            else
                response = func(...)
                self[args] = response
            end
            return response
        end
    end,
}

A função serialize() não existe, então temos de criá-la:

local function serialize(...)
    local response = ""
    local i, v
    for i, v in ipairs {...} do
        response =
            response .. "[" .. ("%g"):format(i) .. "] = " ..
            ("%g"):format(v) .. ", "
    end
    return response
end

Agora criamos o decorador:

function memo()
    return setmetatable({}, mt)
end

Isso tudo pode ser colocado em módulo, chamado memo.lua por exemplo. Na última linha do módulo coloque:

return memo

Agora, para usar o decorador:

require "memo"

fibonacci =
    memo() ..
    function(n)
        if n < 2 then
            return 1
        else
            return fibonacci(n - 2) + fibonacci(n - 1)
        end
    end

O uso do decorador está na linha: memo() .. – a sintaxe não é tão elegante quanto a de Python – @memo –, mas funciona da mesma forma, inclusive a criação de cadeias de decoradores.

A criação de decoradores em Lua também não é tão intuitiva e simples quanto em Python, em função da diferença de filosofias entre as duas linguagens, mas com o hábito se torna um recurso poderoso.

[]’s
Cacilhας, La Batalema

Álgebra Booleana e falácias

2011-02-05T16:15:00.009-03:00

Outro dia eu estava conversando com um amigo meu sobre um problema que nos incomoda bastante, que é o fato das pessoas não conhecerem nem o mínimo de lógica aplicada. Nem mesmo as operações básicas.

Em função disso as pessoas são enganadas pelas mais triviais das falácias, como acidente, afirmação do consequente, negação do antecedente, Red Herring e pressuposição aplicada a conjuntos de axiomas.

Vejo tais falácias chulas nos mais diversos textos, geralmente usados para defender ideias da moda. Pensando nisso, eu e meu amigo decidimos que eu deveria escrever este artigo explicando o básico da Álgebra Booleana, que também é totalmente relevante para programadores.

Pensamento binário

A Álgebra Booleana é baseada no concento de verdades: cada proposição é uma afirmação que pode ser verdadeira ou falsa e é representada em sua forma mais simples por uma letra maiúscula.

Quando uma proposição aparece sozinha, assume-se que ela é verdadeira.

Por exemplo:

Indica que a proposição A é verdadeira.

O operador ¬ indica negação, então:

¬A

Indica que a negação da proposição A é verdadeira, ou seja, que a proposição A é falsa.

Operações booleanas

Assim como na Álgebra Elementar, a Álgebra Booleana possui operações, chamadas operações lógicas.

As operações mais conhecidas são: E lógico (∧), OU lógico (∨), OU exclusivo (⊕), implicação (→) e equivalência (↔), além da negação (¬), que já vimos.

E lógico

A operação E lógico relaciona duas proposições e a expressão formada é verdadeira se as duas proposições forem verdadeira, caso contrário é falsa.

A tabela é:

+---+---+-----+
| A | B | A∧B |
+---+---+-----+
| V | V |  V  |
| V | F |  F  |
| F | V |  F  |
| F | F |  F  |
+---+---+-----+

Ou seja, a seguinte afirmação:

    A∧¬B

Indica que tanto A quanto ¬B são verdadeiros, ou, de modo mais simples, que A é verdadeiro e B é falso.

OU lógico

A operação OU lógico relaciona duas proposições e a expressão resultante é verdadeira se qualquer uma das duas proposições for verdadeira, caso contrário é falsa.

+---+---+-----+
| A | B | A∨B |
+---+---+-----+
| V | V |  V  |
| V | F |  V  |
| F | V |  V  |
| F | F |  F  |
+---+---+-----+

Por exemplo:

    A∨B

Indica que A é verdadeiro, B é verdadeiro ou ambos são, não permitindo que saibamos qual dos casos, nos obrigando a apelar a outra expressão para descobrir.

Então:

    A∨B
    ¬A

Sabemos então que A não é verdadeiro, restando apenas uma opção para validar a expressão, que é quando B é verdadeiro. Podemos escrever isso da seguinte forma:

    A∨B
    ¬A
  ├ B

O sinal ├ significa «cocluímos que…». Então, se A ou B é verdadeiro e A é falso, concluímos que B é verdadeiro.

Falácia do OU lógico

Repare na tabela que dizer que um dos elementos é verdadeiro não garante que o outro seja verdadeiro ou falso, ou seja, tanto V∨F quanto V∨V são verdadeiros. Daí concluir:

    A∨B
    A
  ├ ¬B

É um erro!

Por exemplo, digamos que sabemos que alguém nadou na piscina, pois as bordas estavam molhadas. As suspeitas são Pedro e João. Sabemos que Pedro nadou na piscina, logo deduzimos que João não nadou.

Ora! O fato de Pedro ter nadado na piscina não significa que João não tenha nadado também.

OU exclusivo

Esta operação é o OU a que estamos mais habituados na linguagem comum. Ou uma proposição é verdadeira, ou outra, mas não as duas:

+---+---+-----+
| A | B | A⊕B |
+---+---+-----+
| V | V |  F  |
| V | F |  V  |
| F | V |  V  |
| F | F |  F  |
+---+---+-----+

Geralmente não tem consequências maiores, a menos quando o OU lógico é confundido com o OU exclusivo, como na falácia anterior.

Implicação

A implicação é a operação lógica mais explorada pelos maliciosos que pretendem enganar os desavisados.

Funciona da seguinte forma: se a primeira proposição for verdadeira, a segunda também será, caso contrário nada se sabe da segunda proposição.

A tabela diz o seguinte:

+---+---+-----+
| A | B | A→B |
+---+---+-----+
| V | V |  V  |
| V | F |  F  |
| F | V |  V  |
| F | F |  V  |
+---+---+-----+

Então a conclusões que podemos tirar são:

    A→B
    A
  ├ B

    A→B
    ¬B
  ├ ¬A

Afirmação do consequente

É quando se usa a consequência para afirmar o antecedente:

    A→B
    B
  ├ A

Veja na tabela que tanto V→V quanto F→V são verdadeiros, assim afirmando o consequente não é possível dizer nada do antecedente. É uma falácia!

Por exemplo (da Wikipédia): onde há carros, há poluição. Portanto, se há poluição, deve haver carros.

Negação do antecedente

É quando se usa a negação do antecedente para negar a consequência:

    A→B
    ¬A
  ├ ¬B

Veja na tabela que tanto F→V quanto F→F são verdadeiros, então se o antecedente for falso, nada se sabe da consequência.

Por exemplo: se o rio for fundo, é possível que haja crocodilos. Como o rio não é fundo, não deve haver crocodilos.

Equivalência

A equivalência diz que as duas proposições são falsas ou que as duas são verdadeiras:

+---+---+-----+
| A | B | A↔B |
+---+---+-----+
| V | V |  V  |
| V | F |  F  |
| F | V |  F  |
| F | F |  V  |
+---+---+-----+

Seu perigo é quando a operação de implicação é confundida com ela.

Acidente

Acidente consiste em tomar o todo pela parte. Se há religiosos fanáticos, então todo religioso é fanático; ou: se há ateus não fanáticos, então nenhum ateu é fanático. Conclusões erradas.

As operações envolvidas são um pouco mais complexas, ∃ (existe) e ∀ (para todo). Não vou entrar nesse mérito, já que foge ao escopo do artigo.

Red Herring

Consiste em distrair o interlocutor com afirmações (geralmente verdadeiras) que não têm relação de consequência com a conclusão.

    A
    B
    C
    D
  ├ E

Por exemplo: este prédio sofre muita infiltração devido à grande quantidade de pinturas de paisagem oceânica pelas paredes.

Costuma ser muito usada em combinação com as falácias de afirmação do consequente e de negação do antecedente, para que o interlocutor se distraia e não as perceba.

Pressuposição de axiomas

A pressuposição é a falácia onde uma verdade não comprovada é pressuposta para validar uma consequência:

    A→B
  ├ B

Mas geralmente é óbvia demais, então é usada com conjuntos de axiomas.

Axiomas são afirmações que se intervalidam, garantindo que ou todas são corretas, ou todas são falsas:

    A→B
    B→C
    C→D
    D→A
  ├ A

É interessante lembrar que, ao contrário do que os defensores ferrenhos da onisciência da Ciência Humana dizem, o conhecimento científico oficial é baseado mais em conjuntos de axiomas – e até alguns postulados – do que em observação e prática.

--

Fica então a dica: não se deixe enganar por falácias!

Você pode encontrar mais sobre falácias na Wikipédia.

E a Álgebra Booleana é amplamente utilizada na programação.

[]’s
Cacilhας, La Batalema

Flask

2010-11-27T19:01:00.015-03:00

Há diversos frameworks em Python para Web, Django, Zope, web2py, Pyramid e TurboGears e Pylons.

Venho aqui para falar de um microframework chamado Flask.

Simples, flexível e poderoso, é capaz de manter desde o projeto mais simples até CMS no estilo Django ou grandes aplicações como em Pylons.

A instalação é também extremamente simples, já que se encontra no PyPI:

bash$ easy_install Flask

Como exemplo vou mostrar uma aplicação ao estilo Flask, registrando as URLs com decorador route, mas para aplicações mais complexas sugiro criar um arquivo url_rules.py que importe o objeto aplicação e use o método add_url_rule em vez do decorador.

Nossa aplicação simples exibirá o conteúdo dos arquivos em /proc/ dos sistemas Unix (por falta de ideia melhor).

Podemos começar importanto os recursos necessários:

from flask import Flask, make_response

Flask: classe da aplicação
make_response: função capaz de criar um objeto de resposta HTTP

Para a leitura dos arquivos e diretórios vamos precisar do módulo os:

import os

Vamos agora criar duas funções, uma que retorne a listagem de arquivos para um diretório e outra que retorne o conteúdo de um arquivo:

def list_dir(path):
    filelist = os.listdir(path)
    filelist.sort()
    return '\n'.join(filelist)


def read_file(path):
    data = 'NO DATA'
    with open(path, 'r') as fd:
        data = fd.read()
    return data

Agora é possível criar a aplicação:

app = Flask(__name__)
app.debug = True

Podemos então criar uma função que receba o caminho do arquivo/diretório a ser lido e retorne para o navegador.

Caso seja necessário editar os cabeçalhos ou lidar com qualquer peculiaridade do objeto de resposta HTTP, é possível instanciá-lo manualmente. Caso contrário, retornar uma simples string já faz com que ela seja entendida como o conteúdo do objeto.

Se uma tupla for retornada, o primeiro valor será o conteúdo e o segundo o status de retorno.

Sabendo disso, podemos definir a função:

@app.route('/<path:filename>/')
def read_proc(filename):
    real_path = os.path.join('/proc', filename)
    data = 'NO DATA'

    try:
        if os.path.isfile(real_path):
            data = read_file(real_path)

        elif os.path.isdir(real_path):
            data = list_dir(real_path)

        else:
            return 'NOT FOUND', 404

        # Criando HTTP response apenas para editar headers
        response = make_response(data)
        response.headers['Content-Type'] = 'text/plain'
        return response

    except IOError:
        # Você não pode ler este arquivo/diretório!
        return 'BAD REQUEST', 400

A rota indica que o argumento filename receberá como parâmetro toda a URL passada (path: indica uma string com /).

Para a raiz da aplicação, poderíamos usar as funções redirect e url_for, por exemplo:

@app.route('/')
def index():
    return redirect(url_for('read_proc', filename='cpuinfo'))

O que redirecionaria para a URL referente à função read_proc, passando 'cpuinfo' como parâmetro, mas faz mais sentido retornar o resultado da função:

@app.route('/')
def index():
    return read_proc('')

Agora só falta colocar a aplicação para rodar:

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Execute o script e acesse no navegador: http://localhost:5000/ – você verá a listagem do diretório /proc/.

Acesse no navegador: http://localhost:5000/cpuinfo/ e você verá o conteúdo do arquivo /proc/cpuinfo.

Pretendo em uma próxima oportunidade demonstrar com construir uma estrutura mais complexa usando um arquivo com roteamente em vez de decorador.

Para mais diversão, leia a documentação e fascine-se também com a quantidade de vezes que a expressão «you don’t have to deal with that» se repete.

[]’s
Cacilhας, La Batalema

Torne-se excelente

2010-09-02T22:00:00.003-03:00

Este é um artigo que meu amigo Argentino me apresentou, do Klaus Wuestefeld, autor do manifesto da Computação Soberana.

O artigo original – ou pelo menos o endereço que me foi apresentado – se encontra no GitHub e aconselho todos a lerem.

Mas antes, no artigo original os comentários tenderam para discussão sobre a importância do curso superior. O foco do texto não é esse! Não é criticar a faculdade ou sua importância. O foco é mais na prioridade que damos às coisas.

Em outras palavras: um curso académico é importante, mas possui menor prioridade do que a experiência profissional, ainda mais na Computação, curso que no Brasil ainda não está academicamente bem definido e em muitas faculdades tende a ser regido por interesses empresariais no lugar de pelo conhecimento.

Segue o artigo:

Torne-se excelente

Seja realmente bom em alguma coisa. Não fique só choramingando ou querendo progredir às custas dos outros. Não pense que, porque você sentou 4 anos numa faculdade ouvindo um professor falar sobre software, você sabe alguma coisa. Jogador de futebol não aprende a jogar bola tendo aula. Ele pratica. Instrumentistas geniais não aprendem a tocar tendo aula. Eles praticam. Pratique. Chegue em casa depois do trabalho e da aula e pratique. No final de semana, pratique.

Crie seu próprio vírus, seu proprio jogo, seu proprio SO, seu proprio gerenciador de janelas, seu proprio webserver, sua propria VM, qualquer coisa. Várias coisas.

Não precisa ser só programação. Pode ser networking, vendas, etc. Só precisa ser bom mesmo. Tenha paixão pela coisa.

As melhores práticas do mercado são polinizadas primeiro nos projetos de software livre. Aprenda com eles.

Discípulo, Viajante, Mestre: Primeiro seja um discípulo, tenha mestres locais, aprenda alguma coisa com alguem realmente bom, qualquer estilo. Depois viaje, encontre outros mestres e aprenda o estilo deles. Por fim, tenha o seu estilo, tenha discípulos, seja um mestre.

Vou fazer o curso da Mary Poppendieck em SP semana que vem e quando tiver o curso de Scrumban do Alisson e do Rodrigo quero fazer também.

«Torne-se excelente» também pode ser chamado de «Melhoria Continua» ou Learning.

Não seja deslumbrado

Desenvolvimento de software é a mesma coisa há 60 anos: modelo imperativo. Há 30 anos: orientação a objetos. Bancos de dados relacionais: 30 anos. («Web», por exemplo, não é uma tecnologia ou um paradigma. É meramente um conjunto de restrições sobre como desenvolver e distribuir seu software).

Não corra atras da ultima buzzword do mercado. Busque a essência, os fundamentos.

Busque na Wikipédia e Grokke: determinismo, complexidade de algoritmos O(), problema de parada de Turing. Pronto, pode largar a faculdade. Falando sério.

Trabalhe com software livre. Não dê ouvidos a grandes empresas, grandes instituições ou grandes nomes só porque são grandes.

Você acha que vai aprender mais, ter mais networking e mais chance de alocação no mercado trabalhando em par comigo no Sneer por um ano, 8h por semana, ou passando 4 anos na faculdade, 20h por semana, pagando sei lá quanto por mês?

Você acha que vai aprender mais trabalhando em par com o Bamboo 6 meses na linguagem Boo e na engine do Unity ou fazendo um ano de pós em «a buzzword da moda»?

«Não seja deslumbrado» também é conhecido como Coolness.

Mantenha-se Móvel

Com a demanda que temos hoje no mercado, se você é desenvolvedor de software e não consegue negociar um contrato com uma empresa onde você é pago por hora e pode trabalhar quantas horas quiser com um mínimo de meio período, você precisa rever a sua vida.

É melhor ter dois empregos de meio período que um de período integral, porque você pode largar um deles a qualquer momento.

Você nunca vai conseguir nada melhor se não tiver tempo, se não tiver disponibilidade pra pegar algo melhor quando aparecer.

Você sustenta seus pais e 7 irmãos? Não. Então pare de ser ganancioso e medroso no curto prazo, para de pagar facu, mestrado, pós, MBA, sei-lá-o-quê e vai aprender e empreender.

Trabalhe remoto. Não é o mais fácil, mas é perfeitamente possível.

Não fique reclamando que está trabalhando demais. Aumente seu preço e trabalhe menos.

Emparceire-se Promiscuamente

Participe de dojos, de congressos, de projetos de software livre. Tenha amigos, colegas, conhecidos. Seja conhecido. Não faça ruído em seis projetos e doze fóruns. Ajude de verdade em um ou dois projetos de cada vez. Ao longo do tempo, você terá ajudado em varios projetos, trabalhado em várias empresas.

Mentalidade de Abundância

Ajude seus amigos sem cobrar (a «camaradagem» do Vinícius). Dê palestras gratuitas. Cursos gratuitos. Participe de projetos de software livre.

Pare as vezes uma tarde pra receber um amigo seu e explicar seu projeto. Vá visitar seus amigos nos projetos deles. Viaje com algum amigo seu pra visitar um cliente dele, só pra conversar e fazer companhia.

Você tem um espaço onde dá cursos? É uma Aspercom, Caelum da vida? Chama os brothers para dar curso. Porra, bola um modelo em que as pessoas podem se inscrever para cursos variados, pagando um sinal, e mantém tipo uma agenda pré-combinada: «Será numa terça e quinta à noite, avisadas com duas semanas de antecedencia». Se rolar, beleza, se depois de meses não der quórum, devolve o sinal. Pode ser curso de Prevayler, de Kanban, de Scrum, de Lean, de Comp Soberana, de Restfulie, de Cucumber, de Rails, de Teste Automatizado Mega-Avançado, qualquer coisa.

Chame amigos seus pra dar curso em dupla com você. Divida clientes. Divida projetos, mesmo que não precise de ajuda.

Dizia o pai de um brother meu de infância: «Tudo que custa dinheiro é barato».

Busque modelos de custo zero

Trabalhe em coisas que tem custo administrativo/ burocrático/ manutenção zero. Por menos ganho que tragam, depois de prontas, estarão tendo uma relação custo/benefício infinitamente vantajosa.

Ganhe notoriedade

Faça coisas massa. Participe de projetos de software livre. Dê palestras gratuitas. Promova eventos (dojos, debates, grupos de usuários, etc).

By Dairton Bassi:
Não tenha medo!

Meta a cara. Arrisque empreender. Arrisque inovar. O que você tem a perder? No máximo um emprego, mas isso pode ser revertido facilmente em um mercado aquecido como o atual. O pior que pode acontecer é não dar certo. Mesmo assim você terá aprendido muito mais do que batendo cartão.

Saia da zona de conforto. Se o seu trabalho estiver fácil e sob controle, isso significa que ele não está mais agregando para a sua evolução técnica e pessoal.

Não desperdice a chance de trocar de função se a nova oportunidade for mais desafiadora. Isso fará você crescer tecnicamente e o preparará para desafios maiores ainda. Conhecer pessoas novas é tão importante quanto manter-se em contato com código.

Não se detenha por insegurança ou pela sensação de despreparo. Como você acha que vai ganhar experiência em alguma coisa se sempre adiá-la?

[]’s
Cacilhας, La Batalema

Blogagem Coletiva em repúdio ao AI5 Digital – 31/08

2010-08-31T10:24:00.000-03:00

Veja também no blog do gutocarvalho.net:

Blogagem Coletiva em repúdio ao AI5 Digital – 31/08

Amigos, os adoradores do AI5Digital e da ditadura, os amantes do vigilantismo, os defensores dos direitos econômicos em detrimento dos direitos civis que formam o tripé do atraso, estão se movimentando para aprovar o famigerado e monstruoso AI5Digital que há muito deveria ter sido fulminado, destruído e acabado.

A turma do Grande Irmão: Azeredo, Febraban, Fecomercio e outros do mesmo quilate estão fazendo uma força tremenda para nos empurrar o AI5Digital guela abaixo de qualquer forma, vamos aos fatos:

A mídia continua repetindo o Mantra da Irracionalidade contra a Internet

No dia 05/08/10 O Deputado Pinto Itamaraty do PSDB apresentou parecer favorável ao AI5Digital, ignorando todos os argumentos e movimentos sociais dos últimos três anos.

Seis dias depois aparece uma matéria dizendo que os Deputados buscarão acordo para votar a lei de crimes na Internet.

E agora um evento para lá de esquisito organizado pela revista Decision Report, uma publicação que parece estar à serviço do Azeredo e do vigilantismo, se anuncia para o dia 31/08 com o título oportuno (para o tripé do atraso) de: Crimes Eletrônicos – A urgência da lei. O curioso e que este evento conta com 19 palestrantes para falarem em 2:30h, o que dá um pouco mais de 7 minutos para cada um.

Por estas e por outras que estamos convocando uma blogagem coletiva para o dia 31/08/10, justamente no dia do tal evento à serviço do Azeredo e do AI5digital, vamos fazer uma blogagem coletiva contra o AI5Digital para lembrar a todos que queremos a Internet como um espaço livre e democrático!!!

Fonte:
http://meganao.wordpress.com/2010/08/27/blogagem-coletiva-de-repudio-ao-ai5-digital/

Participe do MEGANÃO, acesse agora:

http://meganao.wordpress.com/o-mega-nao/quem-esta-participando/

[]’s
Cacilhας, La Batalema

Paradigmas de programação

2010-08-26T22:24:00.018-03:00

Muito mais empolgante do que aprender uma nova linguagem de programação é aprender um novo paradigma de programação.

A parte mais louca é perceber como o paradigma funciona. Isso acontece de modo intuitivo, muito parecido com como quando se aprende uma língua nova: nada faz sentido no começo, tudo é muito mecânico; de repente um estalo e tudo faz sentido!

Há muitos paradigmas de programação, já andei falando disso antes, mas muitos são variações dos mesmos tipos básicos: paradigmas imperativo, funcional e declarativo.

Programação imperativa

É o primeiro paradigma com o qual a maioria dos programadores trava contato.

Na programação imperativa, o programa se parece com uma receita de bolo: uma sequência de ordens, chamadas comandos ou instruções (statements em inglês), que devem ser executadas.

A partir desse conceito, derivam diversos paradigmas secundários. O principal é a programação estruturada ou procedimental (procedural em inglês), onde os comandos são organizados em grupos, chamados funções, que podem ser evocados em momentos diferentes.

As funções podem receber ou não parâmetros, que alteram seu comportamento, e podem retornar valores. Em algumas linguagens, quando o grupo de comandos não recebe parâmetros nem retorna valores, ele é chamado subrotina.

Para exemplificar o funcionamento da programação imperativa, vamos implementar fatorial em C – mais simples impossível.

Para quem não sabe, fatorial consiste em uma função recursiva cuja parada é:

0! = 1

E o passo é:

n! = n * (n - 1)!

Outra forma de entender é reiterativamente:

n! = 1 * 1 * 2 * 3 * … * (n - 2) * (n - 1) * n

Vamos implementar a função reiterativa em C para ilustrar melhor o paradigma:

#include <stdlib.h>
#include <stdio.h>

int factorial(int);


int main(int argc, char **argv) {
    printf("O fatorial de 5 é %d\n", factorial(5));
    return EXIT_SUCCESS;
}


int factorial(int x) {
    int result = 1;
    int i;
    for (i=1; i<=x; ++i)
        result *= i;
    return result;
}

Cada comando é uma ordem dada ao sistema: atribua 1 à variável result; para cada i de 1 até o valor do argumento x, multiplique o valor de result pelo valor de i; retorne o valor de result.

São ordens dadas ao sistema.

[update 2011-07-24]
Na programação imperativa, é muito comum a manipulação de alterações de estado, daí o uso de variáveis – contentores (ou slots) que podem sofrer alterações de valor ao longo da existência do processo em execução.
[/update]

Orientação a objetos

Orientação a objetos não passa de um variante da programação imperativa, mas um variante digno de citação.

Na orientação a objetos, as ordens não são dadas a um sistema abstrato, mas objetos recebem as ordens e as executam.

O conceito de objeto é bem genérico: qualquer coisa pode ser um objeto, um número, uma janela na tela, uma coleção…

Na orientação a objetos as ordens dadas a um objeto são chamadas mensagens e a definição de como o objeto reage a cada mensagem é chamada método.

O exemplo será a versão recursiva de fatorial implementada em Smalltalk:

!Integer methodsFor: 'mathematical functions'!

    factorial
        self = 0 ifTrue: [↑ 1].
        self > 0 ifTrue: [↑ self * (self - 1) factorial].
        self error: 'Not valid for negative integers'.
    !
!!


Transcript
    show: 'O fatorial de 5 é ';
    show: 5 factorial printString;
    cr.

[update 2011-07-16]
Atualizei o código em Smalltalk segundo implementação da máquina virtual Pharo.
[/update]

O princípio é parecido com o anterior, mas em vez de dar uma ordem ao sistema – calcule o fatorial de 5 –, é dada ao próprio número – número 5, qual seu fatorial?

Observação: a orientação a objetos pode ser aplicada também à programação funcional.

Programação funcional

Enquanto na programação imperativa ordens são dadas ao sistema ou a objetos, no paradigma funcional são definidas funções, como as matemáticas, e o programa nasce da interação entre as funções: o resultado de umas funções é passado como parâmetro para outras.

[update 2011-07-24]
Na programação funcional, o estado do sistema tende a ser constante, havendo apenas a troca de informação por parâmetros. Assim é comum que não haja variáveis, mas incógnitas constantes, que não sofrem (ou não devem sofrer) alteração de valor ao longo da execução do programa.
[/update]

O mesmo exemplo, fatorial, em Common Lisp:

(defun factorial ((x integer))
    (if (zerop x)
        1
        (* x (factorial (- x 1)))))


(format t "~%O fatorial de 5 é ~A~&" (factorial 5))

O conceito é ligeiramente difente: a função factorial, que recebe um parâmetro inteiro nomeado x, é definida como o resultado da função if; a função if recebe como primeiro parâmetro o resultado da função zerop, que é verdadeiro quando x é igual a zero; o segundo parâmetro de if, 1, é o resultado caso o primeiro parâmetro seja verdadeiro; o terceiro parâmetro é o resultado caso seja falso; o terceiro parâmetro é o resultado da função de multiplicação. Entendendo até aqui, o resto é autoexplicativo.

[update 2011-06-19]

Bônus!

Fatorial em Scheme:

(define (factorial x)
  (if (zero? x)
    1
    (* x (factorial (- x 1)))))

(display "O fatorial de 5 é ")
(display (factorial 5))
(newline)

E em Erlang:

-module (fact).
-export([factorial/1]).

factorial(0) -> 1;
factorial(X) -> X * factorial(X - 1).

Salve como fact.erl. No prompt:

1> c("fact.erl").
{ok,fact}
2> fact:factorial(5).
120

[/update]

Programação declarativa

Este paradigma é um dos mais complicados para pescar…

[update 2011-07-24]
Na programação declaração o código diz o que o programa deve fazer, não como.
[/update]

O programa consiste em uma lista de declarações de verdades.

Nos paradigmas anteriores havia variáveis, que sofriam atribuições. Na programação declarativa há incógnitas, que não sofrem atribuições! O valor de cada incógnita é constante e inicialmente desconhecido. O que o programa faz é cruzar as consultas (queries) com as declarações que formam o conjunto verdade para deduzir o valor das incógnitas.

O exemplo consiste no fatorial implementado em Prolog:

factorial(0, 1).

factorial(N, F) :-
    N > 0,
    N1 is N - 1,
    factorial(N1, F1),
    F is N * F1.

O que este conjunto verdade diz é que o fatorial de 0 é 1 e que o fatorial de N é F quando:

N é maior que zero;
N1 é N menos 1;
o fatorial de N1 é F1;
e F é igual a N vezes F1.

Para a consulta:

| ?- [factorial].
fatorial.pro compiled, 7 lines read - 869 bytes written, 7 ms
(1 ms) yes
| ?- factorial(5, X),
write('O fatorial de 5 é '),
write(X),
nl.

Para entender como funciona, há um applet em Java em um tutorial que demonstra o chinês. É só encontrar o applet na página, ir clicando em Step e ver acontecer.

~~A linguagem declarativa da vez é Erlang.~~

[update 2011-06-19]
Na época deste artigo, em vez de estudar Erlang, perguntei por aí e fui informado que Erlang seria uma linguagem declarativa. Agora que tomei vergonha na cara e estudei um pouco, descobri que é uma linguagem funcional, extremamente similar a Haskell.

Para experimentar Erlang, há o applet Try Erlang.
[/update]

[]’s
Cacilhας, La Batalema

Diversão com ANTLR

2010-08-16T22:24:00.004-03:00

ANTLR – Another Tool for Language Recognition – é uma ferramenta para construção de analisadores léxico (lexer) e sintático (parser) de linguagens formais para JVM.

A grosso modo, é uma ferramenta para implementação de linguagens de programação.

E ANTLRWorks é um IDE gráfico para ANTLR.

Para entender como funciona ANTLR, vou explicar o exemplo do próprio sítio. Então instale o ANTLRWorks e mãos à obra!

Avaliador de expressões

Quando iniciar o ANTLRWorks, crie uma gramática chamada Expr.g.

O código já vai aparecer com a seguinte linha:

grammar Expr;

A ideia aqui é criar um interpretador que avalie expressões matemáticas simples, inclusive com variáveis.

Para suportar variáveis, precisamos de algum lugar para armazenar seus valores. Para isso usamos Java:

@header {
    import java.util.Map;
    import java.util.HashMap;
}

@members {
    Map<String, Integer> memory = new HashMap<String, Integer>();
}

Isso criará o contentor memory, que é um mapa de chaves string e valores inteiros.

ANTLR funciona definindo regras. Nossa primeira regra é programa (prog) e precisamos defini-la:

prog:   stat+;

Então nosso programa é um grupo (+) de comandos (stat), o que nos leva à próxima regra.

Definimos comando como:

stat:   expr NEWLINE { System.out.println($expr.value); }
    |   ID '=' expr NEWLINE
        { memory.put($ID.text, new Integer($expr.value)); }
    |   NEWLINE
    ;

Calma, vou explicar!

Um comando pode ser uma expressão (expr) seguida de uma mudança de linha (NEWLINE). Neste caso, será impresso na saída padrão (System.out) o valor da expressão ($expr.value);

Um comando também pode ser (| significa OU) um identificador (ID) seguido de um sinal de igual ('='), uma expressão e uma mudança de linha. Neste caso o valor da expressão ($expr.value) será armazenado no contentor memory na chave igual ao texto do identificador ($ID.text).

Um comando ainda pode ser uma mudança de linha, que não fará nada.

Agora precisamos definir uma série de regras: expr, NEWLINE e ID. Vamos começar por expr:

expr returns [int value]
    :   e=multExpr { $value = $e.value; }
        (   '+' e=multExpr { $value += $e.value; }
        |   '-' e=multExpr { $value -= $e.value; }
        )*
    ;

Quer dizer que expr retorna um valor inteiro (int value) e consiste de uma expressão múltipla (multExpr) seguido de nenhuma, uma ou mais repetições (*) do que estiver entre parêntesis. O valor retornado é igual ao valor da expressão múltipla.

A atribuição e= é necessária por haver mais de uma ocorrência de multExpr.

Entre parêntesis tempos o sinal de adição ('+') seguido de uma multExpr ou (|) um sinal de subtração ('-') seguido de uma multExpr. No primeiro caso o valor da multExpr é adicionado ao valor retornado, no segundo é subtraído.

A regra multExpr é definida como:

multExpr returns [int value]
    :   e=atom { $value = $e.value; } ('*' e=atom { $value *= $e.value; })*
    ;

Uma multExpr retorna um valor inteiro e consiste de um ou mais atómicos (atom). Os valores dos atómicos são multiplicados.

Definindo um atómico:

atom returns [int value]
    :   INT { $value = Integer.parseInt($INT.text); }
    |   ID
        {
            Integer v = memory.get($ID.text);
            if (v != null) $value = v.intValue();
            else System.err.println("undefined variable " + $ID.text);
        }
    |   '(' expr ')' { $value = $expr.value; }
    ;

Então um atómico pode ser um inteiro (INT, o valor é o corpo do inteiro: $INT.text), um identificador (ID, o valor é o relacionado à chave no contentor memory – se não existir, gera um erro) ou o resultado de uma expressão (expr), que deve estar entre parêntesis.

Falta definir as regras ID, INT e NEWLINE:

ID  :   ('a'..'z'|'A'..'Z')+;
INT :   '0'..'9'+;
NEWLINE:    '\r'? '\n';

Ou seja: identificador é uma sequência de letras, inteiro uma sequência de números e mudança de linha é CRLF ou LF.

Para finalizar, para ignorar espaços em branco:

WS  :   (' '|'\t')+ { skip(); };

Testando

Para testar, clique em Debug e preencha a caixa Text com:

x = 1
y = 2
3 * (x + y)

Os parêntesis e a mudança de linha na última linha são importantíssimos!

Clique Ok e divirta-se acompanhando o debugger! Repare que, ao final da execução, vai mostrar 9 na aba Output.

[]’s
Cacilhας, La Batalema

Por que as empresas teimam em contratar programadores mercenários?

2010-06-09T22:15:00.007-03:00

Recentemente li The Python Paradox, de Paul Graham, e sua tradução O Paradoxo Python no #!SouNerd.

O texto faz todo sentido: quem aprende a fazer qualquer coisa por gosto tende a fazer melhor do que quem aprende a fazer por dinheiro. É uma verdade.

Assim, quem aprende a programar porque gosta de programar tende a programar melhor do que quem aprende para ganhar dinheiro e a grande maioria de quem aprende a programar Java só o faz por dinheiro (claro que há lá suas exceções), enquanto quem aprende linguagens mais exóticas o faz por prazer.

Então por que as empresas teimam em contratar programadores mercenários?

Pensando sobre isso e observando a comunidade, pensei em uma resposta…

Eu vejo três tipos de programadores, como três vértices de um triângulo cromático, e cada um está em uma região dessa área, mais próximo ou distante de cada vértice.

Esses três tipos são: amador, mercenário e empolgado (por falta de palavra melhor).

Mercenário

O mercenário é aquele que quer dinheiro e lucro é tudo o que o impulsiona. Geralmente não tem escrúpulos e faz tudo o que lhe mandam. Seu mantra é: «Pagando bem, que mal tem?»

Quem é 100% mercenário geralmente acaba largando a profissão por algo que dê mais dinheiro, mas basta estar um pentelésimo mais para o centro do triângulo que permanece na profissão.

Normalmente aprende uma linguagem que dê muitas opções de emprego – e que, por consequência, tenha de competir com muita gente –, como Java, C# ou PHP, e rejeita todas as demais. Quando as trata como inferiores, é apenas para tentar justificar a própria incompetência, resultante da falta de gosto pelo que faz.

Amador

O amador é aquele que gosta de verdade do que está fazendo, ele ama programar, daí amador.

Quem é 100% amador quase sempre se perde aprendendo coisas inúteis e não consegue ganhar dinheiro porque muitas vezes perde o foco do que precisa fazer, distraindo-se com besteiras.

Normalmente aprende linguagens bem diferentes, que poucos sabem, como Lisp, Smalltalk ou Fortran – talvez LOLCODE –, e não é incomum que aprenda uma penca de linguagens, nesse caso, também os hypes, como Python e Ruby.

Empolgado

O empolgado é aquele que vai atrás de algum hype, linguagem da moda. Há uns anos eram de Java, mas os empolgados da atualidade querem Python e/ou Ruby.

Quem é 100% empolgado sabe tudo que acontece na comunidade, mas quase nada de programação. Conhece todas as metodologias em alta, sabe todos os macetes e design patterns de sua linguagem que precisa para impressionar os iniciantes, mas não é lá muito eficiente. É tão preocupado com a auto-imagem e o que acontece na comunidade que se esquece que há todo um background a ser aprendido por trás da Computação.

**

Felizmente (quase) ninguém é 100% alguma coisa.

Depois de toda esta dissertação, por que diabos as empresas mais engessadas preferem os mercenários?

Por causa de seu mantra! Basta pagar o que o mercenário acha muito – o que muitas vezes é quase nada pra empresa – e ele faz qualquer coisa que mandarem, torna-se um cão bem adestrado. Essas empresas não querem eficiência, querem obediência.

O que as empresas não veem é que esses cães não são tão ágeis quanto os gatos que pulam pelos telhados: aqueles que, apesar de em nenhum extremo, se encontram mais próximos do vértice do amador.

Na verdade as metodologias ágeis não são práticas de trabalho, mas técnicas sociais para atrair programadores que, apesar de ainda um pouco mercenários, sejam muito mais amadores – ser um pouco empolgado também ajuda, já que as linguagens hype facilitam pela grande mobilidade da comunidade. As empresas mais espertas e as start-up viram isso e usam as metodologias ágeis para criar equipes enxutas e mais eficientes do que qualquer equipe de mercenários jamais conseguirá ser.

[]’s
Cacilhας, La Batalema

DISQUS e perda dos comentários

2010-05-28T21:40:00.001-03:00

Gente,

Devido a uma proliferação absurda de spams nos comentários do Kodumaro, implementei o serviço DISQUS para gerência dos mesmos.

Infelizmente, parece que todos os comentários antigos se perderam. =(

Peço desculpas a todos, a implementação foi uma necessidade e a perda dos comentários um efeito colateral indesejado.

[]’s
Cacilhας, La Batalema

Parrot VM

2010-04-22T21:56:00.009-03:00

Parrot VM é a máquina virtual criada com base nas linguagens de programação Python e Perl que proporciona o ambiente para a criação, a implementação e o uso de linguagens de programa. As linguagens suportadas pela máquina virtual estão listadas na página do projeto, com destaque para a curiosa e elegante linguagem tutorial Squaak.

Um dos exemplos de Squaak é factorial.sq:

# Copyright (C) 2008, Parrot Foundation.
# $Id: factorial.sq 36833 2009-02-17 20:09:26Z allison $

print("Please enter number: ")
x = read()

sub factorial(n)
    ## test for < 2 because all numbers are represented by
    ## floating-point numbers, and equality checks on those
    ## do not work (yet?)
    if n < 2 then
        return 1
    else
        return n * factorial(n - 1)
    end
end

print("factorial of ", x, " is: ", factorial(x))

Voltando à Parrot VM, ela possui uma linguagem própria, um assembly.

Seguem aqui dois exemplos de seu assembly. Ambos gravam o que é digitado pelo usuário em um arquivo (test.text) e depois exibem o conteúdo do arquivo. Simples.

O objetivo de dois códigos é mostrar como pode ser feita a escrita e leitura em arquivo usando descritor de arquivo, de modo totalmente procedimental (como em C), e usando manipulador de arquivo, lançando mão da orientação a objetos.

Descritor de arquivo (procedimental)

.sub 'main' :main
    .local string filename
    .local string line
    .local pmc STDIN
    .local pmc fd

    filename = 'test.text'
    STDIN = getstdin

    # Writing operation
    fd = open filename, 'w'
    print "> "
    line = readline STDIN
    print fd, line
    close fd

    # Reading operation
    fd = open filename, 'r'
    line = read fd, 10240
    print line
    close fd
.end

Manipulador de arquivo (OO)

.sub 'main' :main
    .local string filename
    .local string line
    .local pmc STDIN
    .local pmc file_handle

    filename = 'test.text'
    STDIN = getstdin
    file_handle = new 'FileHandle'

    # Writing operation
    file_handle.'open'(filename, 'w')
    file_handle.'encoding'('utf-8')
    print "> "
    line = readline STDIN
    file_handle.'print'(line)
    file_handle.'close'()

    # Reading operation
    file_handle.'open'(filename, 'r')
    line = file_handle.'readall'()
    print line
    file_handle.'close'()
.end

[]’s
Cacilhας, La Batalema

Coleções com Smalltalk

2010-04-11T09:50:00.009-03:00

Dando seguimento a uma série de artigos sobre GNU Smalltalk, este artigo demonstra alguns recursos de coleção (arrays e dicionários).

A classe base para coleções é Collection, filha de Iterable. As demais classes, como Array, Dictionary, Bag e Set, são herdeiras diretas ou indiretas de Collection.

Para criar um instância vazia de qualquer subclasse de Collection, você pode usar a mensagem #new.

`Array`

Há duas sintaxes para instanciação de Array, uma literal e outra programável.

A sintaxe literal suporta apenas dados literais: inicia-se com #(, os elementos são separados por blanks (espaços, tabulações, mudanças de linha) e é fechado com ).

Por exemplo:

#(1 2 3)

A limitação dessa sintaxe é que ela só suporta valores literais, não suporta qualquer forma de código (bloco, variável, construtor, etc…). Portanto, não é recomendável.

A sintaxe recomendada para criação de array com código é {}, pois a sintaxe literal suporta apenas literais. A sintaxe com suporte a código se inicia com {, os elementos são separados por ponto (.) seguido de blank e é fechado por }.

Por exemplo:

| anArray b |

b := 2.
anArray := {
    1.
    b.
    [3] value.
}.

O principal seletor para leitura de elementos em um array é #at:ifAbsent:, que recebe como primeiro parâmetro o índice e como segundo um bloco que retorna o valor em caso se ausência.

Por exemplo:

anArray at: 2 ifAbsent: [0]

Retorna o elemento de índice 2 ou, em caso de não existir, retorna zero ([0] value).

`Dictionary`

Essa classe representa um dicionário ou hash, ou seja, uma coleção de pares chave-valor.

Por exemplo:

| aDict |

aDict := Dictionary from: {
    #a -> 1.
    #b -> 2.
    #c -> 3.
}.

Se usar Squeak ou Pharo, a mensagem de criação é #newFrom: em vez de #from:.

Também aceita a mensagem #at:ifAbsent:, que recebe como primeiro parâmetro a chave e como segundo um bloco que retorna o valor em caso de ausência. Ainda responde à mensagem #at:, que recebe apenas a chave e, em caso de ausência, levanta uma exceção NotFound.

A mensagem para inserir um novo par é #add::

aDict add: (#d -> 4).

Para alterar o valor de uma chave use #at:put::

aDict at: #a put: 5.

Também funciona para adicionar novo par.

Para remover um par pela chave basta usar a mensagem #removeKey::

aDict removeKey: #a.

À mensagem #keys responde uma lista – uma instância de Set, de fato – das chaves dos pares, já o seletor #keysAndValuesDo: executa um bloco para cada par:

aDict keysAndValuesDo: [ :key :value |
    Transcript
        show: key printString;
        tab;
        show: value printString;
        cr.
].

`Set`

Set é um array onde cada elemento é único, ou seja, não se repete. Para criar uma instância de Set:

| aSet |

aSet := #(1 2 3 4 5) asSet.

Para remover um elemento, use a mensagem #remove: e para adicionar #add:. Se o elemento adicionado já existir, nada acontece.

Para listar o conteúdo há a mensagem #do::

aSet do: [ :e |
    Transcript show: e printString; cr.
].

`Bag`

Bag é exatamente o que o nome diz: um saco de elementos. Você pode ir jogando o que quiser lá dentro e os elementos vão sendo armazenados desordenadamente.

| aBag |

aBag := #(1 2 3 4 5) asBag.

Os principais seletores são #add:, #remove: e #do:, que funcionam de modo similar aos seletores de Set, mas permite duplicação de elementos.

Conclusão

Há uma série de outras classes filhas de Collection, como OrderedCollection, SortedCollection e LinkedList, e muitos outros seletores úteis.

Para mais informações, execute gst-blox, acesse Smalltalk→Class Hierarchy Browser. Na nova janela, clique em Class→Search e faça uma busca por Collection.

De classe em classe, navegue pelos métodos e veja como cada classe responde a cada mensagem.

[]’s
Cacilhας, La Batalema

PS: Referência: M206 Computing: An Object-oriented Approach

Quem ama BLOXeia!

2010-04-04T15:51:00.004-03:00

GNU Smalltalk é a implementação Smalltalk da Free Software Foundation para o sistema operacional GNU.

Para interface gráfica, ele oferece o módulo BLOX. Sua IDE pode ser iniciada pelo comando:

bash$ gst-blox

Caso queira navegar pelas classes de sua própria imagem – dev.im por exemplo –, use:

bash$ gst-blox -I dev.im

Este artigo apresentará um exemplo extremamente simples de uso programático do BLOX para criar interface gráfica com o usuário, baseado no código encontrado no tutorial oficial.

Primeiro vamos criar a imagem contendo o módulo BLOX:

bash$ gst-load -iI blox-sample.im Blox

Crie um arquivo fonte blox-sample.st onde vamos trabalhar.

Declare as variáveis que usaremos:

| win con lab bt |

Agora crie a janela principal com o título Example e seu container:

" Main window "
win := BLOX.BWindow new: 'Example'.
con := BLOX.BContainer new: win.

Para definar as dimensões da janela e a callback do botão de fechamento:

" Main window's geometry and close button "
win
    width: 200 height: 50;

    callback: [
        BLOX.Blox terminateMainLoop.
        true.
    ] message: #value.

A callback encerrará o ciclo principal. Callbacks de janelas precisam ter a última saída true (quando a janela deve ser fechada) ou false (quando a janela não deve ser fechada).

Podemos então configurar a geometria padrão para widgets filhos:

" Geometry management "
con
    setVerticalLayout: true;
    defaultHeight: 50;
    defaultWidth: 200.

Agora, para criar um rótulo (label) e um botão:

lab := BLOX.BLabel new: con label: 'Waiting...'.
bt := BLOX.BButton new: con label: 'Click me'.

O rótulo exibirá seu texto centralizado, com fundo azul e cor de texto branco:

" Label setup "
lab
    alignment: #TopCenter;
    backgroundColor: #blue;
    foregroundColor: #white.

A callback que responde ao evento clique no botão:

" Button callback "
bt
    callback: [
        lab label: 'HELLO WORLD!'.
    ] message: #value.

Para exibir a janela:

" Show window "
win map.

Por último devemos iniciar o ciclo principal (mainloop):

" Start mainloop "
BLOX.Blox dispatchEvents: win.

Se quiser, é possível exibir uma mensagem indicando o fim do programa:

Transcript
    show: 'Finished';
    cr.

Resta apenas executar a aplicação:

bash$ gst -I blox-sample.im -f blox-sample.st

Outra opção ao BLOX é Gtk+.

[]’s
Cacilhας, La Batalema

SUnit

2010-04-03T16:26:00.006-03:00

Smalltalk possui um ótimo arcabouço de teste unitário chamado SUnit – Smalltalk Unit Test Suite. Porém sua documentação é um tanto fraca.

Segue aqui um pequeno tutorial de uso do SUnit. Veja que não é necessariamente a forma correta de usá-lo. Usaremos GNU Smalltalk.

Imagine que queremos implementar um método em Integer que retorna se o número é primo ou não. Podemos primeiro criar um test case para verificar seu funcionamento.

Para isso, crie um arquivo test-is-prime.st e defina a seguinte classe:

TestCase subclass: #TestIsPrime
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Unit Test'
!

A classe TestIsPrime é filha de TestCase e, para nosso fim atual, não precisará de atributos.

Precisaremos de um método de classe que execute os testes, para que não precisemos criar uma TestSuite:

!TestIsPrime class methodsFor: 'running'!

    run
        (self testSelectors) do: [ :test |
            self run: test.
        ].
    !
!

Podemos agora criar a categoria accessing para os testes:

!TestIsPrime methodsFor: 'accessing'!

O primeiro teste pode ser para determinar se números negativos retornam um erro quando se tenta determinar sua primalidade:

testNegative
    self should: [ -1 isPrime ] raise: ArithmeticError.
!

Não esqueça de indentar!

[update 2010-04-04]
A indentação aqui tem objetivo exclusivo de manter a clareza do código.
[/update]

O método #should:raise: executa um bloco e asserta que uma exceção será levantada, neste caso ArithmeticError.

Podemos fazer o mesmo para zero:

testZero
    self should: [ 0 isPrime ] raise: ArithmeticError.
!

Já para o número um, é preciso assertar que ele não é primo, ou seja, retorne falso:

testOne
    self shouldnt: [ 1 isPrime ].
!

O método #shouldnt: executa um bloco esperando pelo retorno falso.

Mas quando chegarmos ao dois, ele é primo:

testTwo
    self should: [ 2 isPrime ].
!

O método #should: executa um bloco esperando pelo retorno verdadeiro.

Você pode fazer isso indefinidamente se quiser:

testSomeOtherValues
    self should: [ 3 isPrime ].
    self shouldnt: [ 4 isPrime ].
    self should: [ 5 isPrime ].
    self shouldnt: [ 6 isPrime ].
    self should: [ 7 isPrime ].
    self shouldnt: [ 8 isPrime ].
    self shouldnt: [ 9 isPrime ].
    self shouldnt: [ 10 isPrime ].
    self should: [ 11 isPrime ].
!

Quando cançar, encerre a lista de métodos da categoria com a linha:

Ou, se preferir ser mais explícito:

!!

No final, adicione uma linha para executar os testes:

TestIsPrime run.

Para rodar os testes, copie a imagem contendo seu código para, por exemplo, test.im e acrescente o SUnit com o seguinte comando:

bash$ gst-load -I test.im SUnit

Agora, com a imagem preparada, você pode executar os testes:

bash$ gst-sunit -I test.im -f test-is-prime.st

Se tudo correr bem, nada acontecerá, caso contrário você poderá receber uma mensagem do tipo:

TestIsPrime>>#testSomeOtherValues ..
FAILURE: Assertion failed

Onde TestIsPrime>>#testSomeOtherValues significa que falhou o teste contido no método #testSomeOtherValues da classe TestIsPrime.

[]’s
Cacilhας, La Batalema

Python é capa da TIdigital de Março

2010-03-05T15:23:00.004-03:00

Gente,

Segunda-feira todo mundo correndo pras bancas!

Em março, Python em foco na revista TIdigital.

Fonte: PythOn Rio.

[]’s
Cacilhας, La Batalema

MongoDB

2010-02-27T14:44:00.001-03:00

Há atualmente na Computação uma onda de adoção de bancos de dados não-relacionais, comumente chamados NoSQL.

O foco principal dos bancos NoSQL atuais é a orientação a documentos, uma variação hash da orientação a objetos e alternativa aos RDBMSs, que dominaram a orientação dos gerenciadores de banco de dados por décadas.

O principal banco NoSQL é o CouchDB, DBMS do Projeto Apache baseado em Erlang, porém há uma alternativa bem mais simples e aparentemente tão poderosa quanto: MongoDB.

MongoDB combina os melhores funcionalidades de orientação a documentos, hashes e RDBMSs. É um banco de dados orientado a documentos, escalável, livre de esquema, de alto desempenho e código aberto escrito em C++.

Este artigo dá continuidade ao artigo nas Reflexões de Monte Gasppa e Giulia C. sobre a instalação do MongoDB. Aqui você poderá ver um pouquinho do uso de um banco de dados orientado a documentos.

Este artigo é baseado na documentação oficial e entende que você instalou o MongoDB segundo descrito nas Reflexões de Monte Gasppa e Giulia C..

Conexão na base de dados

Para conectar na base basta usar o comando mongo:

bash$ mongo
MongoDB shell version: 1.2.2
url: test
connecting to: test
type "help" for help
>

Caso você tenha configurado uma porta alternativa em /srv/mongodb/etc/mongodb.conf, você pode especificar isso na linha de comando do cliente:

bash$ mongo --port 27018

Você também pode se conectar a um servidor remoto, caso ele esteja habilitado para conexão externa, usando a flag --host.

Para escolher qual base de dados usar, o comando é use:

> use mydb

Autorização

Você pode se autorizar na linha de comando com as opções -u (usuário) e -p (senha), ou já do prompt do interpretador:

> use admin
> db.auth('admin', 'ra35EG/dz');

Comandos básicos

A linguagem de interação com MongoDB é Javascript, mas há alguns comandos úteis no interpretador.

Para listar comandos úteis:

> help

Listar recursos uteis da base atual:

> db.help();

Listar recursos uteis de uma coleção (levemente equivalente a tabela de um banco relacional), no exemplo foo:

> db.foo.help();

Para listar as bases instaladas:

> show dbs

Para listar as coleções da base atual:

> show collections

Listar usuários da base atual:

> show users

Criar usuário na base atual:

> db.addUser('admin', 'ra35EG/dz');

Autenticar-se:

> db.auth('admin', 'ra35EG/dz');

Listar o conteúdo de uma coleção:

> db.foo.find();

Apagar uma coleção:

> db.foo.drop();

Apagar a base de dados atual:

> db.dropDatabase();

Armazenamento de dados

Repare que o MongoDB é livre de esquema, portanto uma coleção pode conter estruturas de dados radicalmente diferentes, sempre no formato JSON.

Por exemplo, vamos inserir dois dados distintos na coleção foo da base mydb:

> use mydb
> var j = { name: 'mongo' };
> var t = { x: 3 };
> db.foo.save(j);
> db.foo.save(t);
> db.foo.find();
{ "_id" : ObjectId("4b8949d9cd50237b8573833b"), "name" : "mongo" }
{ "_id" : ObjectId("4b8949dbcd50237b8573833c"), "x" : 3 }

Você não precisa predefinir a coleção, que é criada automaticamente no salvamento da primeira estrutura. O campo _id é criado automaticamente e é a chave primária.

Para apagar o objeto j:

> j = db.foo.findOne({ name: 'mongo' });
> db.foo.remove(j);

Para apagar todos os objetos basta remover a coleção:

> db.foo.drop();

Vamos usar um pouco mais de lógica:

> for (var i=0; i<100; ++i) db.foo.save({ x: i, y: i*i });

Esse loop cria cem registros, com x variando de zero a noventa e nove e y igual a seu quadrado:

> db.foo.find();
{ "_id" : ObjectId("4b894c05cd50237b8573833e"), "x" : 0, "y" : 0 }
{ "_id" : ObjectId("4b894c05cd50237b8573833f"), "x" : 1, "y" : 1 }
{ "_id" : ObjectId("4b894c05cd50237b85738340"), "x" : 2, "y" : 4 }
{ "_id" : ObjectId("4b894c05cd50237b85738341"), "x" : 3, "y" : 9 }
{ "_id" : ObjectId("4b894c05cd50237b85738342"), "x" : 4, "y" : 16 }
{ "_id" : ObjectId("4b894c05cd50237b85738343"), "x" : 5, "y" : 25 }
{ "_id" : ObjectId("4b894c05cd50237b85738344"), "x" : 6, "y" : 36 }
{ "_id" : ObjectId("4b894c05cd50237b85738345"), "x" : 7, "y" : 49 }
{ "_id" : ObjectId("4b894c05cd50237b85738346"), "x" : 8, "y" : 64 }
{ "_id" : ObjectId("4b894c05cd50237b85738347"), "x" : 9, "y" : 81 }
{ "_id" : ObjectId("4b894c05cd50237b85738348"), "x" : 10, "y" : 100 }
{ "_id" : ObjectId("4b894c05cd50237b85738349"), "x" : 11, "y" : 121 }
{ "_id" : ObjectId("4b894c05cd50237b8573834a"), "x" : 12, "y" : 144 }
{ "_id" : ObjectId("4b894c05cd50237b8573834b"), "x" : 13, "y" : 169 }
{ "_id" : ObjectId("4b894c05cd50237b8573834c"), "x" : 14, "y" : 196 }
{ "_id" : ObjectId("4b894c05cd50237b8573834d"), "x" : 15, "y" : 225 }
{ "_id" : ObjectId("4b894c05cd50237b8573834e"), "x" : 16, "y" : 256 }
{ "_id" : ObjectId("4b894c05cd50237b8573834f"), "x" : 17, "y" : 289 }
{ "_id" : ObjectId("4b894c05cd50237b85738350"), "x" : 18, "y" : 324 }
{ "_id" : ObjectId("4b894c05cd50237b85738351"), "x" : 19, "y" : 361 }
has more

Consultas (queries)

É possível fazer consultas simples ou bem complexas assim como em modelos relacionais usando MongoDB.

Vamos obter uma contagem de objetos:

> db.foo.find().count();
100

Só os cinco primeiros objetos:

> db.foo.find().limit(5);
{ "_id" : ObjectId("4b894c05cd50237b8573833e"), "x" : 0, "y" : 0 }
{ "_id" : ObjectId("4b894c05cd50237b8573833f"), "x" : 1, "y" : 1 }
{ "_id" : ObjectId("4b894c05cd50237b85738340"), "x" : 2, "y" : 4 }
{ "_id" : ObjectId("4b894c05cd50237b85738341"), "x" : 3, "y" : 9 }

Agora os cinco seguintes:

> db.foo.find().skip(5).limit(5);
{ "_id" : ObjectId("4b894c05cd50237b85738343"), "x" : 5, "y" : 25 }
{ "_id" : ObjectId("4b894c05cd50237b85738344"), "x" : 6, "y" : 36 }
{ "_id" : ObjectId("4b894c05cd50237b85738345"), "x" : 7, "y" : 49 }
{ "_id" : ObjectId("4b894c05cd50237b85738346"), "x" : 8, "y" : 64 }
{ "_id" : ObjectId("4b894c05cd50237b85738347"), "x" : 9, "y" : 81 }

Para obter o elemento com valor de x vinte e quatro:

> var e = db.foo.findOne({ x: 24 });
> print(e.y);
576
> print(tojson(e));
{ "_id" : ObjectId("4b894c05cd50237b85738356"), "x" : 24, "y" : 576 }

Consultas avançadas

Vamos complicar um pouco…

Para obter todos os registros com x maior que cinquenta:

> db.foo.find('this.x > 50');
{ "_id" : ObjectId("4b894c05cd50237b85738371"), "x" : 51, "y" : 2601 }
{ "_id" : ObjectId("4b894c05cd50237b85738372"), "x" : 52, "y" : 2704 }
{ "_id" : ObjectId("4b894c05cd50237b85738373"), "x" : 53, "y" : 2809 }
{ "_id" : ObjectId("4b894c05cd50237b85738374"), "x" : 54, "y" : 2916 }
{ "_id" : ObjectId("4b894c05cd50237b85738375"), "x" : 55, "y" : 3025 }
{ "_id" : ObjectId("4b894c05cd50237b85738376"), "x" : 56, "y" : 3136 }
{ "_id" : ObjectId("4b894c05cd50237b85738377"), "x" : 57, "y" : 3249 }
{ "_id" : ObjectId("4b894c05cd50237b85738378"), "x" : 58, "y" : 3364 }
{ "_id" : ObjectId("4b894c05cd50237b85738379"), "x" : 59, "y" : 3481 }
{ "_id" : ObjectId("4b894c05cd50237b8573837a"), "x" : 60, "y" : 3600 }
{ "_id" : ObjectId("4b894c05cd50237b8573837b"), "x" : 61, "y" : 3721 }
{ "_id" : ObjectId("4b894c05cd50237b8573837c"), "x" : 62, "y" : 3844 }
{ "_id" : ObjectId("4b894c05cd50237b8573837d"), "x" : 63, "y" : 3969 }
{ "_id" : ObjectId("4b894c05cd50237b8573837e"), "x" : 64, "y" : 4096 }
{ "_id" : ObjectId("4b894c05cd50237b8573837f"), "x" : 65, "y" : 4225 }
{ "_id" : ObjectId("4b894c05cd50237b85738380"), "x" : 66, "y" : 4356 }
{ "_id" : ObjectId("4b894c05cd50237b85738381"), "x" : 67, "y" : 4489 }
{ "_id" : ObjectId("4b894c05cd50237b85738382"), "x" : 68, "y" : 4624 }
{ "_id" : ObjectId("4b894c05cd50237b85738383"), "x" : 69, "y" : 4761 }
{ "_id" : ObjectId("4b894c05cd50237b85738384"), "x" : 70, "y" : 4900 }
has more

Outra opção é usar o operador condicional $gt:

> db.foo.find({ x: { $gt: 50 } });

Da mesma forma outros operadores. Por exemplo, todos os elementos com x entre vinte e três e vinte e seis, inclusive:

> db.foo.find('23 <= this.x && this.x <= 26');

Ou:

> db.foo.find({ x: { $gte: 23, $lte: 26 } });

Os principais operadores são:

$lt – menor que
$gt – maior que
$lte – menor ou igual a
$gte – maior ou igual a
$ne – diferente de
$in – está em (recebe uma lista)
$nin – não está em
$mod – resto igual a (recebe uma lista onde o primeiro valor é o divisor e o segundo o resto)
$exists – contém ou não o atributo
$not – negação de uma condição

Ordenação

A ordenação é feita usando o método sort. Por exemplo, para ordenar de modo descrescente pelo atributo y:

> db.foo.find().sort({ y: -1 });

Expressões regulares

Quando há campos com valor string, é possível usar expressões regulares:

> db.foo.find({ name: /^mon.o$/i });

Índices

Quando você faz muitas consultas baseadas em um determinado atributo, é interessante criar um índice para ele. Por exemplo, se quisermos criar um índice para nosso atributo x:

> db.foo.ensureIndex({ x: 1 });

Obs.¹: o atributo _id possui índice por padrão.

Obs.²: é possível criar índices compostos.

Agregação

Não vou entrar nesse mérito, mas é possível criar agregações, como GROUP_BY de SQL. Para tanto veja a documentação oficial.

Módulos de conexão com linguagens de programação

Há módulos para várias linguagens, que podem ser encontrados na lista de APIs.

O módulo que pude e me fascinou foi para Python. Sua instalação usando easy_install foi muito simples:

bash$ sudo easy_install -U pymongo

E seu uso extremamente fácil devido à similiaridade entre dicionários de Python e JSON. A única reclamação que faço é o fato do método db.auth() do MongoDB ter sido traduzido como db.authenticate() em Python, o que me fez perder alguns segundos tentando entender por que não funcionava.

**

Espero que este artigo seja mais do que útil e incite o uso dessa intrigante ferramenta.

[]’s
Cacilhas, La Batalema

Kodumaro no Twitter

2010-02-25T14:38:00.002-03:00

Kodumaro agora no Twitter!

@kodumaro

A conta será usada para divulgar novos artigos e para troca de ideias com os leitores.

[]’s
Cacilhas, La Batalema

FizzBuzz (No Stairway to Heaven)

2010-01-14T21:13:00.007-03:00

Hoje um amigo meu veio falar comigo de uma brincadeira velha – e que eu não conhecia – chamada FizzBuzz.

[update 2010-01-15]
Sugestão de apontador do Cesar Barros: If something is worth doing….

A propósito, atualizei o código Lisp.
[/update]

A brincadeira consiste em imprimir uma sequência de números, tradicionalmente de 1 a 100. Porém os números múltiplos de 3 devem ser substituídos por fizz e os números múltiplos de 5 por buzz. Os números que são divisíveis por 3 e por 5 devem ser substituídos por fizzbuzz.

No Stackoverflow você pode encontrar as versões mais loucas, como LOLCODE, Brainf*ck, Ook, assembly de 8051, 6502 e Linux IA-32, Hebreu Estruturado, Cobol e Forth, como destaque para o poético código em Perl.

Aqui quero postar algumas soluções que achei interessantes.

**

Em Haskell:

putStr (concat [if (mod x 15)==0 then "fizzbuzz\n" else if (mod x 3)==0 then "fizz\n" else if (mod x 5)==0 then "buzz\n" else (show x) ++ "\n" | x <- [1..100]])

Em Python:

print "\n".join('fizzbuzz' if x%15==0 else 'fizz' if x%3==0 else 'buzz' if x%5==0 else str(x) for x in xrange(1, 101))

Em Perl:

print +(fizz)[$_%3] . (buzz)[$_%5] || $_, $/ for 1..100;

Em Common Lisp:

(format t "~{~A~%~}" (loop for x from 1 to 100 collect (if (zerop (mod x 15)) "fizzbuzz" (if (zerop (mod x 3)) "fizz" (if (zerop (mod x 5)) "buzz" x)))))

[]’s
Cacilhas, La Batalema

Ajude a mostrar a PythonBrasil na PyCon 2010

2010-01-08T23:07:00.003-03:00

Meu amigo Henrique Bastos publicou hoje um artigo entitulado Ajude a mostrar a PythonBrasil na PyCon 2010.

A proposta é muito legal e já preenchi o formulário para reunir informações sobre a Comunidade Python no Brasil.

Segue uma reprodução do artigo:

Salve Pythonistas!

De 19 a 21 de fevereiro será realizada a PyCon, em Atlanta nos Estados Unidos. Como alguns de vocês já sabem, participarei do evento apresentando a palestra #78 entitulada «Small acts make great revolutions».

Esta apresentação será uma evolução da palestra relâmpago que fiz na PythonBrasil[5] em Caxias do Sul, onde tento difundir os conceitos por trás das iniciativas que vêm movimentando a comunidade no Rio de Janeiro.

No entanto, falar só do que acontece no Rio me parece muito pouco para uma oportunidade dessas. Quero muito aproveitar a PyCon para mostrar o grande desenvolvimento da Comunidade Python no Brasil. Pessoasfantásticas estão fazendo as coisas acontecerem em Terras Brasilis. E a exemplo do que fiz no FISL 10, pretendo continuar na linha de tentar evidenciar que na nossa comunidade, o todo é muito maior do que a soma das partes. Mas para isto, eu preciso da ajuda de vocês.

Para poder falar com propriedade sobre a Comunidade Python no Brasil, precisamos traçar o perfil do nosso grupo. Por isso, preparei um rápido questionário online que ajudará a levantar informações sobre nossa comunidade. Ele está disponível em: http://henriquebastos.wufoo.com/forms/vamos-divulgar-nossa-comunidade-python-na-pycon/

É muito importante que o maior número de pythonistas respondam à pesquisa. Isso vai ajudar muito! Portanto, não economizem nos retweets e espalhem o link da pesquisa por todas as listas de email no Brasil, relacionadas com Python.

Além disso, também estou buscando links para boas fotos em alta resolução, como as tiradas na escadaria da PUC-RS durante o FISL 10 e as fotos «aéreas» da PythonBrasil[4] na UVA etc. Basta publicarem os links para as fotos nos comentários deste post ou me enviar por email.

Obrigado à todos, e vamo que vamo!

[]’s!

Já andei tuitando e divulguei nas Reflexões de Monte Gasppa e Giulia C. também. Convido todos então a ler o artigo e preencher o formulário, ajudando assim o Henrique a revelar e expor a Comunidade Python no Brasil ao Mundo!

[]’s
Cacilhas, La Batalema

Seaside

2009-12-22T19:28:00.006-03:00

Seaside é um arcabouço (framework) para desenvolvimento de aplicações web para Smalltalk. É descrito pelo próprio autor como um arcabouço herético, por quebrar todas as regras dos guru~~don~~s atuais.

Pessoalmente gosto muito de coisas heréticas ou subversivas. Sou um apaixonado por subversão. =D

Olhando a documentação, podemos ver que Seaside é suportado pelas máquinas virtuais Cincom VisualWorks, GNU Smalltalk, VA Smalltalk, Squeak e seus derivados Pharo e GLASS.

GNU Smalltalk

A máquina virtual recomentada é Squeak, da qual gosto muito e que é ótima para aplicações desktop, no entanto Squeak é uma plataforma muito pesada, consome muitos recursos da máquina, por isso, para Seaside, optei por uma plataforma mais leve: GNU Smalltalk.

GNU Smalltalk sofre porém de um mal extremamente irritante: a sintaxe da linguagem é muito irregular – para ser eufémico.

Teoricamente GNU Smalltalk suportaria a sintaxe correta de Smalltalk-80, mas não funciona bem assim… ele é muito chato e levanta erros de sintaxe para códigos perfeitamente corretos, mas que diferem do que o GNU Smalltalk espera de Smalltalk-80. Então é preciso experimentar algumas formas diferentes – mas regulares – de fazer as coisas antes de encontrar uma que funcione (às vezes ele implica até com nomes de argumentos).

Vou usar aqui a sintaxe Smalltalk-80 precisa – e que funciona no GNU Smalltalk –, mas colocarei o mesmo código na sintaxe peculiar do GNU Smalltalk ao final deste artigo apenas por curiosidade.

Preparação da imagem

Para criar a imagem para nosso exemplo usei o comando:

bash$ gst-load -iI seaside.im Seaside Seaside-Development Seaside-Examples

Isso cria uma imagem seaside.im com os pacotes Seaside (Seaside em si), Seaside-Development (ferramentas de desenvolvimento) e Seaside-Examples (exemplos).

Usei então o exemplo de componente da própria documentação: MyCounter.st.

O método de classe #canBeRoot diz se o componente pode ser registrado como uma aplicação autónoma ou não.
Na inicialização (#initialize) o atributo count é zerado.
O método #states retorna uma coleção de estados que podem ser retrilhados (backtracked).
O método #renderContentOn: é usado para renderizar a página.
Ao final a mensagem #registerAsApplication: registra o componente como aplicação.

O código fica então (se copiar e colar, substituia ↑ por ^):

" See: http://www.gnu.org/software/smalltalk/manual/html_node/Seaside.html "

Seaside.WAComponent subclass: #MyCounter
    instanceVariableNames: 'count'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Seaside Examples'
!

!MyCounter class methodsFor: 'testing'!

    canBeRoot
        ↑true
    !

!

!MyCounter methodsFor: 'initializing'!

    initialize
        super initialize.
        count := 0.
    !

!

!MyCounter methodsFor: 'accessing'!

    states
        ↑{ self }
    !

!

!MyCounter methodsFor: 'rendering'!

    renderContentOn: html
        html heading: count.
        html anchor
            callback: [ count := count + 1 ];
            with: '++'.
        html space.
        html anchor
            callback: [ count := count - 1 ];
            with: '--'.
    !

!

MyCounter registerAsApplication: 'mycounter'.

Para carregar o componente na imagem usei o comando:

bash$ gst -I seaside.im -S MyCounter.st

Rodar a aplicação

O seguinte comando levanta a máquina virtual no modo servidor:

bash$ gst-remote -I seaside.im --daemon

Depois disso você poderá ver a máquina virtual ouvindo na porta 12345/TCP:

bash$ netstat -ln4 | grep 12345
tcp        0      0 0.0.0.0:12345           0.0.0.0:*               LISTEN

É possível obter o PID do processo da máquina virtual com seguinte comando:

bash$ gst-remote --pid

Porém o Seaside não está rodando. Para rodar o serviço web use o comando:

bash$ gst-remote --start=Seaside

É possível também iniciar a máquina virtual já rodando o Seaside com o seguinte comando:

bash$ gst-remote -I seaside.im --daemon --start=Seaside

Por padrão o serviço web Seaside estará escutando na porta 8080/TCP.

Para acessar a aplicação que acabamos de criar use o endereço http://localhost:8080/seaside/mycounter.

Parar a aplicação

Para parar a aplicação use o comando:

bash$ gst-remote --stop=Seaside

Repare que, apesar do serviço web ter parado, a máquina virtual continua rodando. Para pará-la:

bash$ gst-remote --kill

Para comparação

A título de comparação, segue o código usando a sintaxe ~~bizarra e esdrúxula~~ peculiar do GNU Smalltalk:

Seaside.WAComponent subclass: MyCounter [
    | count |
    
    <category: 'Seaside Examples'>
    <comment: nil>

    MyCounter class >> canBeRoot [
        <category: 'testing'>
        ^true
    ]


    initialize [
        <category: 'initializing'>
        super initialize.
        count := 0
    ]

    states [
        <category: 'accessing'>
        ^{ self }
    ]

    renderContentOn: html [
        <category: 'rendering'>
        html heading: count.
        (html anchor)
            callback: [count := count + 1];
            with: '++'.
        html space.
        (html anchor)
            callback: [count := count - 1];
            with: '--'
    ]
].

MyCounter registerAsApplication: 'mycounter'.

[]'s
Cacilhas, La Batalema

Mais sobre reiteração

2009-12-06T12:42:00.013-03:00

A reiteração ou iteração é um dos mais efetivos algoritmos para para processamento de sequências, mas sua eficiência não se limita a processamento de conjuntos prontos, essa técnica de algoritmo também pode ser usada para processamento de amostragens em plena coleta.

Vamos a um algoritmo bem simples, a média aritmética:

O algoritmo reiterativo pode ser expresso da seguinte forma:

(defun mean ((a-list list))
  (/
    (apply #'+ a-list)
    (length a-list)))

Agora imagine que você tem o registro contínuo do comportamento de um dado específico ao longo do tempo e gostaria de manter sua média sem preocupação como os valores em si (acho um caso pouco provável, mas…).

Se reparando bem, há dois dados importantes para o cálculo da média aritmética: a própria média e a quantidade de elementos. Basta que a função receba esses valores além dos novos valores que serão usados para atualizar a média anterior.

Assim é possível armazenar apenas a média atual e a quantidade de elementos avaliados:

(defun update-mean ((the-mean hash-table) (a-list list))
  (let ((*count* (+ (gethash 'count the-mean) (length a-list))))
    (setf (gethash 'mean the-mean)
      (/
        (+
          (apply #'+ a-list)
          (* (gethash 'mean the-mean) (gethash 'count the-mean)))
        *count*))
    (setf (gethash 'count the-mean) *count*)
    the-mean))

Então, além de receber a lista com os dados mais recentes (segundo parâmetro), a função recebe como primeiro parâmetro um hash com os dados de média anteriores.

O formato inicial do hash deve ser:

#s(hash-table :test fasthash-eql (count . 0) (mean . 0))

Ou seja, 'mean zero (0) e 'count zero (0). O hash será atualizado e retornado:

(setq *mean*
  (make-hash-table
    :initial-contents (list
      (cons 'count 0)
      (cons 'mean 0))))

Na próxima falarei em variância on-line.

[]'s
Cacilhas, La Batalema

Ideias poderosas por trás de uma piada

2009-11-04T19:41:00.006-03:00

Ricardo Bánffy fez uma piada de 1º de abril no ano passado lançando um suposto framework em Lisp chamado Kanamit.

No entanto a parte da piada é somente o terceiro tópico do texto e o Bánffy aproveitou o ar de piada para rasgar o verbo e dizer umas verdades sem medo.

Como concordo quase 100% com o texto, decidi reproduzi-lo aqui de forma séria:

Eu sempre gostei de escrever aqui sobre linguagens «exóticas». Já houve um tempo em que Python era exótico. Hoje Python é mainstream. Ruby, idem. Há até suporte a Rails no NetBeans 6 e para Python no Visual Studio. Não dá pra ser muito mais mainstream do que isso.

Nem todas as linguagens exóticas que eu conheci deram certo. Smalltalk, por exemplo, continua sendo aquela linguagem muito sofisticada, anos-luz à frente do Java, mas que quase ninguém usa. Smalltalk tem ideias poderosas demais. A ideia de rodar dentro de uma máquina virtual, de todo o código poder ser examinado e modificado «ao vivo», do compilador incremental, do class browser, do late-binding, das mensagens... Tudo isso era demais pras cabecinhas da maioria dos programadores que só conseguem entender Visual Basic ou PHP e olha lá.

Mas «Visual Basic e PHP resolvem todos os meus problemas», dizem eles. Claro. Se tudo o que eles conhecem se resume a isso, eles não imaginam sequer que existam outros tipos de problema. É uma limitação de capacidade expressiva: eles não têm as ferramentas intelectuais necessárias para expressar as classes de problemas que outras ferramentas expressam e resolvem.

Não se pode pensar em uma lâmpada fluorescente se tudo o que você conhece são pedras lascadas e peles de urso.

Uma outra linguagem muito além do seu tempo é o Lisp. Além do seu tempo porque, se ela é uma coisa poderosa hoje comparada ao que temos hoje, imaginem em 1960 quando ela foi inventada…

Por muito tempo, havia implementações de Lisp para computadores desktop, mas, com processadores de 16 bits e menos de um megabyte de RAM, essas máquinas serviam apenas como brinquedos. Você podia fazer um loop e imprimir 10 vezes «fulano é bobo», mas não muito mais do que isso.

Naquele tempo, para se rodar programas em Lisp, você precisaria de uma Lisp machine, um computador dedicado, com um processador único capaz de coisas que nenhum outro processador da época – ou de hoje – era capaz de fazer. Eram incrivelmente caras.

Mas as implementações de brinquedo eram o bastante para abrir as cabeças dos jovens computólogos (antes deles se chamarem assim). Lisp e Scheme (um dialeto de Lisp) são usados como ferramenta didática em todos os bons cursos de ciência da computação. Se no seu curso não tem, pare de perder tempo e peça seu dinheiro de volta. Não sei quanto é a mensalidade, mas é certo que o curso vale menos.

E, claro, hoje em dia, temos computadores amplamente capazes de rodar boas implementações de Lisp. Meu notebook consegue emular uma Lisp machine da Texas Instruments (uma Micro-Explorer) mais depressa do que ela era originalmente.

Artigo original: O Kanamit Web Framework.

[]'s
Cacilhas, La Batalema

Mais sobre programação funcional

2009-10-21T22:01:00.008-03:00

Aproveitando o ensejo do artigo anterior sobre programação funcional, gostaria de puxar mais este artigo sobre três algoritmos tradicionais: sequência de Fibonacci, fatorial e quick sort.

Fatorial

Fatorial é um dos algoritmos recursivos mais tradicionais da Matemática. É também um dos algoritmos mais simples:

Sua implementação tanto em Haskell quanto em Common Lisp descreve exatamente esse algoritmo.

Em Haskell:

factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * (factorial (n - 1))

Em Common Lisp:

(defun factorial ((n integer))
  (if (zerop n)
    n
    (* n (factorial (- n 1)))))

Já em Scheme a coisa pode complicar… se o interpretador (uso guile) tiver sido compilado com suporte a bignum, tudo bem, se não, é preciso fazer uma pequena mágica, multiplicando os resultados do maior para o menor:

(define (factorial n)
  (define (loop k l)
    (if (zero? k)
      l
      (loop (- k 1) (* k l))))
  (loop n 1))

Sequência de Fibonacci

A Sequência de Fibonacci é uma progressão natural iniciando por 1, 1 e progredindo ao passo de que cada elemento é a soma dos dois anteriores:

É uma sequência recursiva em árvore binária, o pesadelo dos programadores. =D

Mas como já foi muito estudada, há diversas formas de implementá-la sem usar código recursivo, como algoritmo reiterativo, potência de matrizes e função fechada.

A seguinte implementação em Haskell utiliza recursão e lista infinita:

fib :: [Integer]
fib = 1 : 1 : zipWith (+) fib (tail fib)

Já em Common Lisp foi uma boa ideia usar reiteração, muito mais elegante do que seria possível em qualquer linguagem imperativa:

(defun fib (index)
  (check-type index (integer 0 *))
  (loop
    for a = 1 then b
    and b = 1 then (+ a b)
    repeat index
    finally (return a)))

Quick sort

O algoritmo de ordenação quick sort é a exceção das exceções: um algoritmo de ordenação recursivo em árvore binária, o que deveria ser o pior dos casos, no entanto é um dos métodos de ordenação mais rápidos e eficientes que conhecemos.

O princípio é o seguinte: toma-se um elemento qualquer da lista, tradicionalmente o primeiro, então separa-se a lista em duas, uma de elementos menores que o tomado e outra de elementos maiores. Aplica-se a mesma ordenação quick sort a cada uma das novas listas e concatena-as com o elemento tomado no meio.

Em Haskell isso pode ser descrito assim:

qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (x:xs) = qsort lesser ++ [x] ++ qsort greater
    where
        lesser =  [e | e <- xs, e < x]
        greater = [e | e <- xs, e >= x]

Em Common Lisp o princípio é o mesmo, mas com aquele monte de parêntesis característicos de Lisp:

(defun qsort ((a-list list))
  (if (< (length a-list) 2)
    a-list
    (let ((x (pop a-list)))
      (concatenate 'list
        (qsort
          (loop for e in a-list
            if (< e x)
              collect e))
        (list x)
        (qsort
          (loop for e in a-list
            if (>= e x)
              collect e))))))

**

Espero que este artigo tenha sido interessante e cause curiosidade aos leitores sobre programação funcional.

[]'s
Cacilhas, La Batalema

Oddwording de novo

2009-10-16T21:46:00.012-03:00

Em maio de 2007 publiquei um artigo sobre a implementação do algoritmo oddwording em diversas linguagens de programação.

Para relembrar, segue o código em Haskell:

module Main where

import IO


main = mainloop


mainloop :: IO ()
mainloop = do
    ph <- readString
    if ph == ""
        then
            return ()
        else do
            let nph = oddword ph
            putStrLn nph
            mainloop


readString :: IO String
readString = do
    putStrLn "Digite uma frase: "
    putStr "> "
    hFlush stdout
    s <- getLine
    return s


oddword :: String -> String
oddword s = listToStr $ invodd $ strToList s


strToList :: String -> [String]
strToList "" = []
strToList s = (take spi s) : (strToList (drop (incr spi) s))
    where spi = nextspace s


incr :: Int -> Int
incr = (+ 1)


nextspace :: String -> Int
nextspace "" = 0
nextspace (x:xs) =
    if x == ' '
        then
            0
        else
            1 + (nextspace xs)


listToStr :: [String] -> String
listToStr [] = ""
listToStr (x:xs) = x ++ " " ++ (listToStr xs)


invodd :: Ord a => [[a]] -> [[a]]
invodd [] = []
invodd (x:xs) = x : (inveven xs)


inveven :: Ord a => [[a]] -> [[a]]
inveven [] = []
inveven (x:xs) = (inv x) : (invodd xs)


inv :: Ord a => [a] -> [a]
inv [] = []
inv (x:xs) = (inv xs) ++ [x]

<update ressaca>
Havia esquecido de forçar o flush de STOUT na função readString. Corrigido!
</update>

No entanto ficou faltando uma linguagem excepcionalmente importante, Lisp.

Lisp (LISt Processing) é uma família de linguagens funcionais concebida por John McCarthy em 1958, baseada no cálculo lambda. As principais linguagens da família Lisp são Common Lisp, Scheme e Emacs Lisp.

O código acima será reimplementado abaixo em Common Lisp.

Observação: os blocos de código deverão ser escritos em arquivo na ordem inversa em que aparecem aqui, ou seja, digite cada bloco no arquivo em linhas acima do bloco digitado anteriormente.

Ciclo principal

O ciclo principal será a função mainloop. Sua lógica de funcionamento é a seguinte:

Pegar uma string digitada na entrada padrão;
Se a string for vazia, sair do programa;
Aplicar o algoritmo oddwording;
Exibir na tela o resultado;
Recomeçar o ciclo.

A função fica assim:

(defun mainloop ()
  (loop do
    (format t "~&~a~%"
      (oddword (*exit-if-empty* (*read-string*))))))

Lendo uma linha da entrada padrão

Para ler uma linha da entrada padrão, devemos exibir um prompt, ler a entrada digitada pelo usuário e remover os espaços em branco do começo e do fim:

(defun *read-string* ()
  (format t "~&Digite uma frase:~%> ")
  (string-trim " " (read-line)))

Saindo caso a string esteja vazia

Caso nada tenha sido digitado, o programa encerra. Para isso é preciso avaliar a string, encerrando o processo se apropriado, caso contrário retornar a string:

(defun *exit-if-empty* ((a-string string))
  (if (string= a-string "")
    (exit)
    a-string))

Descrição do algoritmo em alto nível

Podemos agora definir em alto nível o algoritmo oddwording:

Transformar a string em uma lista de palavras;
Inverter somente o conteúdo dos elementos de índice ímpar da lista;
Transformar novamente a lista de palavras em uma string.

(defun oddword ((a-string string))
  (list-to-str (invodd (str-to-list a-string))))

String para lista

Para transformar uma string em uma lista, basta quebrada em cada ocorrência de espaço (#\Space):

(defun str-to-list ((a-string string))
  (loop
    for i = 0 then (1+ j)
    as j = (position #\Space a-string :start i)
    collect (subseq a-string i j)
    while j))

Lista para string

Para transformar uma lista de palavras em uma string única, é preciso concatenar todos os elementos da lista, sem esquecer de acrescentar espaços entre eles:

(defun list-to-str ((a-list list))
  (string-trim " "
    (apply #'concatenate 'string
      (loop for e in a-list
        collect (concatenate 'string e " ")))))

Inversão dos elementos ímpares

Só faltou inverter os elementos de índice ímpar da lista. Nada mais simples: pegar cada elemento, se o índice for ímpar, inverter:

(defun invodd ((a-list list))
  (loop
    for x in a-list
    and i from 0
    collect (if (oddp i)
      (reverse x)
      x)))

Fazendo funcionar

Para que tudo aconteça, no final do arquivo acrescente uma chamada à função principal:

(mainloop)

E execute o arquivo com o comando clisp (aconselho o uso dos parâmetros -K full e -q).

**

Lisp tem uma abordagem extremamente elegante e clara, aproveita o paradigma funcional perfeitamente e seus programas podem ser retroalimentados recursivamente para obter-se um comportamento de aprendizado, apreciado no desenvolvimento de IA.

[]'s
Cacilhas, La Batalema

<update 2009-10-20>
Adicionada tipagem aos argumentos das funções e removido código redundante.
</update>

IDEs em ambiente GNU/Linux

2009-10-06T21:20:00.005-03:00

Semana passada escrevi um artigo sobre alguns ambientes de desenvolvimento integrado e editores de texto, alguns deles RAD. No entanto o artigo ficou muito longo, daí tive a ideia de quebrá-lo em três partes.

Publiquei em meu blog Reflexões de Monte Gasppa e Giulia C., mas agora, pensando bem, acho que cabe pelo menos uma referência aqui no Kodumaro.

As três partes do artigo são:

A quem se interessar, boa leitura!

[]'s
Cacilhas, La Batalema

Dev in Rio 2009

2009-08-21T11:00:00.001-03:00

Gente,

Notícia fresquinha no blog do Henrique Bastos:

Dev in Rio 2009: EU VOU!

Finalmente o Rio de Janeiro ganhou um grande evento de tecnologia focado no que é mais importante: Pessoas!

É com muito orgulho que apresentamos o Dev in Rio 2009, uma conferência bombástica sobre desenvolvimento de software que acontecerá no próximo dia 14 de setembro no Centro de Convenções SulAmérica, no Rio de Janeiro!

O Dev in Rio 2009, contará com palestrantes nacionais e internacionais que falarão sobre Java, Ruby e Ruby on Rails, Python, Django, Open Source, Joomla!, Métodos Ágeis, e muito mais. Nomes como Fábio Akita, Vinícius Manhães Teles, Jacob Kaplan-Moss, Guilherme Silveira, Nico Steppat, Ryan Ozimek e Jeff Patton agitarão um dia inteiro de muita tecnologia e diversão. Veja a programação detalhada no site da Dev in Rio 2009.

Mas não é só isso. Como eu disse no início, este é um evento focado em pessoas. Toda a organização do evento está voltada para promover ao máximo a interação e integração entre os presentes.

Por isso, o Dev in Rio 2009 contará com uma Arena DojoRio onde participantes e palestrantes poderão programar lado à lado, experimentando diversas linguagens e técnicas, buscando juntos as melhores formas de desenvolver software.

O evento está sendo organizado por mim (Henrique Bastos) em parceria com o meu amigo Guilherme Chapiewski, contando com todo o apoio dos membros da PythOnRio, DojoRio e #Horaextra.

A realização está sendo coordenada pelas nossas experientes amigas da Arteccom. E tê-las ao nosso lado já garante que este será um evento para marcar o circuito carioca.

Você não pode perder esta incrível oportunidade de participar desse mega evento, interagir com grandes nomes do cenário mundial de tecnologia, conhecer pessoas interessantes que compartilham a paixão pelo desenvolvimento de software, e ainda por cima começar sua semana só na terça-feira. Inscreva-se já!

Nos vemos por lá!

[]’s!

[]'s
Cacilhas, La Batalema

Ponteiro opaco

2009-07-01T19:01:00.004-03:00

Muitas vezes programadores de C++ e Java confundem encapsulamento com ocultação, o que não é a intenção da orientação a objetos.

No entanto, o contrário da ocultação, a exposição, também não é desejável para o encapsulamento, pois causa uma confusão entre interface e implementação.

Em C++, a declaração de uma classe força a exposição de sua estrutura privada. Um exemplo bem simples:

class X {
    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        int value;
}

Neste exemplo insanamente simples, é possível ver a estrutura privada da classe X, o que no caso não é um problema muito sério, mas em casos ligeiramente mais complexos, é possível corromper o encapsulamento.

Uma forma de resolver o problema é usando um design pattern¹ chamado ponteiro opaco ou Pimpl.

A ideia é que a classe de interface seja apenas uma moldura (wrapper) para a classe de implementação. A classe de implementação é declarada no corpo da classe de interface, mas nada é exposto ali.

A classe de implementação vai ser finalmente implementada no arquivo onde os métodos da classe de interface são implementados. Os métodos da classe de interface então simplemente chamam os métodos da classe de implementação.

Voltemos ao exemplo… o arquivo de cabeçalho de nossa classe (x.h por exemplo) passa a ser:

class X {
    class Ximpl;

    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        Ximpl *pimpl;
}

Como é possível ver, nada da implementação está exposto.

Então a classe de implementação é finalmente definida no arquivo de implementação (x.cc):

class X::Ximpl {
    public:
        Ximpl(int);
        ~Ximpl();

        int get(void) const;

    private:
        int value;

}

O resto do código fica:

X::X(int value): pimpl(new X::Ximpl(value)) {
    // Nada mais a fazer
}

X::Ximpl::Ximpl(int value): value(value) {
    // Nada mais a fazer
}

X::~X() {
    delete this->pimpl;
}

X::Ximpl::~Ximpl() {
    // Nada mais a fazer
}

X::get(void) const {
    return this->pimpl->get();
}

X::Ximpl::get(void) const {
    return this->value;
}

É claro que é um pattern extremamente desconfortável, pois é preciso implementar cada método duas vezes, uma para a classe de interface, outra para a classe de implementação… e há sim formas melhores de fazer isso.

Mas Pimpl funciona, é uma saída viável e pode salvar sua vida. =D

[update 2009-08-01]Sugestão de leitura de 0xc0de: Compilation Firewalls.[/update]

[]'s
Cacilhas, La Batalema

¹ Design patterns: antes que me crucifiquem por usar esta expressão fora do mundinho pequeno de Java, a definição de design pattern é «um jeito formal de documentar a solução para um problema de desenvolvimento», o que define corretamente ponteiro opaco.

Variaridade

2009-06-28T19:10:00.010-03:00

Uma função ~~variádica~~ variária – em inglês variadic, variable arity, aridade¹ variável – é aquela que suporta uma quantidade variável de parâmetros.

Muitas linguagens suportam funções variárias, aliás de forma bem simples. Python usa o operador * para indicar quantidade variável de parâmetros, Lua usa o operador ... e Common Lisp o operador &rest.

Outras linguagens podem ser ainda mais simples, como por exemplo Perl, onde toda função é variária e os parâmetros são recebidos na lista @_, tradicionalmente capturados por shift.

Já Java não suporta funções verdadeiramente variárias devido a sua limitação forçada de tipagem, no entanto é possível simular com o uso de Object e casting («vazamento» na falta de uma tradução melhor):

void myFunction(Object... args) {
    // Código do método
    …
}

Funções variárias em C/C++

C/C++ usa o cabeçalho stdarg.h para suporte a funções variárias.

O exemplo apresentado na Wikipédia é bastante simples: uma função printargs que recebe uma quantidade arbitrária de números inteiros, encerrando com -1 (ou qualquer número negativo em nosso exemplo), e os exibe na saída padrão.

Precisamos incluir dois cabeçalhos em C++, cstdarg para suporte a funções variária e cstdio para exibir o resultado:

#include <cstdio>
#include <cstdarg>

Ou, em C:

#include <stdio.h>
#include <stdarg.h>

A assinatura da função fica assim:

void printargs(int arg1, ...) {

Para acesso aos parâmetros múltiplos é usado um objeto va_list:

    va_list args;

A função va_start() inicializa o objeto. Ela recebe dois parâmetros: o objeto va_list e o nome do último argumento antes da lista:

    va_start(args, arg1);

Portanto é preciso haver pelo menos um argumento antes da lista variável. Podemos então exibir o primeiro parâmetro, recebido no argumento arg1:

    printf("%d", arg1);

A função va_arg() retorna o argumento seguinte. Ela recebe como parâmetros o objeto va_list e o tipo do parâmetro da lista a ser recuperado.

O tipo precisar ser plenamente promovido, ou seja, ponteiro, inteiro, ponto flutuante ou precisão dupla. Outros tipos, como char precisam sofrer casting, como por exemplo (não faz parte do código de printargs):

char c = static_cast<char>(va_arg(va, int));

Continuando o código, podemos agora reiterar sobre os resultados de va_arg() até encontrarmos o valor de parada negativo:

    int arg;
    while((arg = va_arg(args, int)) >= 0)
        printf(" %d", arg);

Após o fim da reiteração dos parâmetros obtidos do objeto va_list através de va_arg(), é preciso encerrar o objeto:

    va_end(arg);
    printf("\n");
}

Caso você queira restringir o formato de entrada da função, isso é possível usando __attribute__ em sua declaração. Por exemplo, se a função log() recebe o nível de log como primeiro parâmetro, uma string de formatação como segundo parâmetro (2) e os parâmetros variáveis a partir do terceiro (3), com formato similar ao da função printf(), isso é feito com a seguinte assinatura:

extern void
log(int level, cons char *fmt, ...)
__attribute__((format(printf, 2, 3)));

As opções para format() são printf, scanf, strftime e strfmon. Veja Declaring Attributes of Functions da documentação do GCC.

[]'s
Cacilhas, La Batalema

¹Aridade: em Matemática é o número de operandos de uma função.

Um «Olá Mundo!» pequenininho

2009-05-14T19:03:00.001-03:00

Como este blog estava muito parado, resolvi postar um «Olá Mundo!» com janela de duas linhas em Tcl/Tk:

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

Se preferir, pode ser criado um script autoexecutável acrescentando o hash-bang:

#!/bin/sh
#\
exec wish "$0" "$@"

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

[]'s
Cacilhas, La Batalema

Sobre APIs

2009-03-19T00:01:00.012-03:00

Umas das coisas mais importantes em programação, sem a qual ninguém consegue desevolver, é API.

API – Interface de Programação de Aplicativos – é o conjunto de recursos de que o programador dispõe para desenvolver suas aplicações.

Este artigo faz uma comparação – na verdade, mais uma demonstração – de cinco APIs muito usadas: IEEE 1003, STL, OpenStep, GLib e Java.

Para a demonstração será usado um trecho de código para ler a primeira linha de um arquivo.

Por que não a API do Windows?

Antes de começar, é preciso esclarecer por que não a API do Windows.

O objetivo de uma API é oferecer um ambiente homogêneo de programação, para que o programador não seja obrigado a reaprender a mesma coisa diversas vezes. Para facilitar isso, muitas APIs ainda podem ser usadas em diversas linguagens diferentes, outras em apenas uma.

No entanto uma API que funciona apenas em um único sistema operacional – ou ainda no grupo de sistemas operacionais de uma única empresa – não está fazendo seu trabalho, por mais usado que esse(s) sistema(s) possa ser.

Assim a API do Windows não faz mais do que se espera da interface de um sistema operacional.

É claro que é necessário que o Windows possua uma API, mesmo que seja exclusivamente para conexão de outras APIs mais universais.

IEEE 1003 (POSIX)

O padrão POSIX, definido pela IEEE, oferece uma interface completa para sistemas compatíveis com UNIX. Alguns exemplos são IBM AIX, Solaris, GNU (e daí também Linux), BSD, Mac OS X, MS Xenix e muitos outros.

O trecho de código em C para ler a primeira linha de um arquivo:

FILE *fd = fopen(filename, "r");

if (fd) {
    while (!eof(fd)) {
        char buf;
        fread(&buf, sizeof(char), 1, fd);
        printf("%c", buf);
        if (buf == '\n')
            break;
    }

    fclose(fd);
}

Observação¹: é preciso incluir o cabeçalho stdio.h ou, em C++, cstdio:

#include <stdio.h>

Observação²: a variável filename é do tipo const char *.

Observação³: foi preciso procurar ocorrência do carácter \n pois POSIX não ofereça uma função de alto nível para ler uma linha.

Observação⁴: o padrão POSIX é completamente procedimental – as demais APIs citadas aqui são orientadas a objetos –, sendo um pouco desajeitado para algumas operações.

STL

A linguagem de programação C++ possui uma biblioteca padrão própria bastante completa chamada STL – Standard Library.

Para o exemplo, é preciso incluir o cabeçalho fstream para a manipulação de arquivo e o cabeçalho iostream para a exibição dos dados na tela:

std::ifstream fd(filename);

if (fd.is_open()) {
    char buf[1024];
    fd.getline(buf, 1023);

    std::cout << buf << std::endl;
    fd.close();
}

Observação¹: como citado acima, é preciso incluir pelo menos o cabeçalho fstream ao manipular arquivos:

#include <fstream>

Observação²: a variável filename precisa ser do tipo const char * – std::ifstream não suporta std::string.

OpenStep

A empresa NeXT de Steve Jobs, ora adquirida pela Apple, abriu a API de seu sistema operacional em 1992 num acordo com a SUN Microsystems, sob o nome de OpenStep, o que permitiu, além da criação de aplicações de terceiros para NeXTSTEP, também o desenvolvimento de outros sistemas operacionais compatíveis com sua API e APIs de programação para sistemas já existentes, tornando-os compatíveis com OpenStep.

Exemplos de sistemas compatíveis com essa API são Mac OS X e GNUstep (portável para Windows e qualquer plataforma compatível com POSIX).

A API OpenStep funciona exclusivamente em Objective-C, apesar de haver alguns portes para outras linguagens, como C++, Smalltalk e Guile Scheme.

Vamos ao exemplo em Objective-C:

id fd = [NSFileHandle fileHandleForReadingAtPath: filename];

if (fd != nil) {
    char buf = 0;
    [fd seekToEndOfFile];
    unsigned long long eof = [fd offsetFile];
    [fd seekToFileOffset: 0];

    while (([fd offsetInFile] < eof) && (buf != '\n')) {
        [[fd readDataOfLength: 1] getBytes: &buf length: 1];
        printf("%c", buf);
    }

    [fd closeFile];
}

Observação¹: é preciso importar o cabeçalho Foundation.h:

#import <Foundation/Foundation.h>

Observação²: a variável filename precisa ser do tipo NSString.

Observação³: eu não conheço um método para ler uma linha de um arquivo em OpenStep, portanto usei um esquema similar ao usado acima em POSIX.

GLib

A GLib começou como parte do toolkit gráfico Gtk+ na versão 2.0, tendo evoluído para se tornar uma API multiplataforma orientada a objetos completa e independente da interface gráfica.

Você pode usar GLib em qualquer sistema POSIX e em Windows.

A maior curiosidade da GLib é que ela deixa explícita o equívoco – ou a falácia – de quem crê que não seja possível programar orientado a objetos em uma linguagem não orientada a objetos: é escrita em C e completamente orientada a objetos.

Aliás a base da GLib é o GObject que, curiosamente, não é compatível com a estrutura de orientação a objetos de C++ e outras linguagens clássicas, apesar de haver portes para C++ e outras.

O exemplo a seguir é um trecho de código em Vala, linguagem criada expecificamente para a GLib:

var file = File.new_for_path(filename);

if (file.query_exists(null)) {
    try {
        var fd = new DataInputStream(file.read(null));
        stdout.printf("%s\n", fd.read_line(null, null));
        fd.close(null);
    } catch (Error e) {
        // Ignora exceções
    }
}

[update 2009-03-19]Faltou o close.[/update]

Observação¹: é preciso «usar» GLib:

using GLib;

Observação²: a variável filename é do tipo string – equivalente em C a GString e gchar *.

Observação³: é preciso usar o pacote (--pkg) gio-2.0, que importa GIO, recursos de I/O da GLib.

Java

Em sua linguagem de programação, a SUN Microsystems optou por criar uma API própria (bem complicada e verborrágica em relação às demais, diga-se).

BufferedReader fd = null;
try {
    fd = new BufferedReader(new FileReader(filename));
    System.out.println(fd.readLine());

} catch (Exception e) {
    // Ignora exceções

} finally {
    try {
        if (fd != null)
            fd.close();
    } catch (IOException e) {
        // Ignora exceções
    }
}

Observação¹: as classes usadas estão no pacote java.io:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

Observação²: a variável filename é do tipo String.

**

Fica aqui a dica de três APIs interessantes.

[]'s
Cacilhas, La Batalema

Quem vai pra Vala?

2009-03-11T22:05:00.013-03:00

Dessa vez o pessoal do Gnome acertou a mão. Estou falando da linguagem de programação Vala.

Até hoje, quem queria programar em C# era obrigado a usar ou um sistema operacional problemático, ou uma ferramenta monstruosamente pesada e ineficiente.

Não mais.

O projeto Gnome lançou há algum tempo a linguagem Vala, fortemente baseada na sintaxe do C#, mas voltada para aplicações Gnome. Quem manja de C# ou maja de Java e já viu C# não terá dificuldade em lidar com Vala.

Instalação

Segundo a página do projeto, Vala foi feito para plataforma Gnome. Surgiu aí meu primeiro problema: uso Slackware e o Volkerding decidiu que Slackware não terá mais suporte a Gnome! Em sua total substituição, há o Xfce.

Simplesmente não há um pacote oficial de Gnome para Slackware – e os não-oficiais que já experimentei simplesmente detonaram o sistema todo.

Ainda mais: e quem usa outros SOs? Se não tiver Gnome já era?

Qual não foi minha agradável surpresa quando descobri que Vala compilou e instalou sem problemas no Slackware 12.2?! Sua dependência verdadeira é GTK+ 2.x, que você encontra em praticamente qualquer distribuição GNU/Linux ou BSD.

E Windows? Também tem!

Usando

Um «Olá Mundo» em Vala é bastante simples (tanto quanto Java, pelo menos):

using GLib;

public class HelloWorld : Object {
    public static int main(string[] args) {
        stdout.printf("Olá Mundo!\n");
        return 0;
    }
}

Ao contrário do .NET, não há código escondido do programador. Por exemplo:

using GLib;

public class HelloWorld : Object {

    private Gtk.Window window;


    public HelloWorld() {
        window = new Gtk.Window(Gtk.WindowType.TOPLEVEL);
        window.set_default_size(300, 200);
        window.destroy += Gtk.main_quit;
        window.add(new Gtk.Label("Olá Mundo!"));
    }


    public void show() {
        window.show_all();
        Gtk.main();
    }


    public static int main (string[] args) {
        Gtk.init(ref args);
        var sample = new HelloWorld();
        sample.show();

        return 0;
    }
}

~~Antes que alguém reclame, peço desculpas pelos códigos mal orientados a objetos, mas não quis ter muito o que explicar.~~
[update]Ajeitei pra ninguém ficar me chateando.[/update]

Maturidade

Estranhamente a linguagem já está bastante madura na 0.5.7. Não encontrei quebras inusitadas nem erros bizarros.

[update 2009-04-01]
Encontrei uma quebra inusitada: Vala não lida bem com closures e escopo dinâmico. Ela se perde um pouco gerando alguns erros inesperados.

Outro erro inconveniente está na API com C: o bind de método destruidor não suporta parâmetros, o que pode ocorrer em alguns casos da GLib – lembre-se do que não há métodos destruidores reais em C, mas sim funções de desalocação.
[/update]

A única coisa que tenho a reclamar muito é a documentação precária, bem longe das documentações de API bem organizadas da SUN Microsystems e da Microsoft.

IDE

Por enquanto há uma IDE chamada Val(a)IDE – só que essa já desarmou na minha cara algumas vezes – e a promessa de uma extensão para o Eclipse – que ainda não apareceu na página da própria extensão.

Segundo a página official, há também extensões para MonoDevelop (Deus me livre!) e para GEdit.

**

É isso aí! Quando eu ganhar um pouco mais de intimidade com a linguagem, escrevo mais alguma coisa. Por enquanto foi só divulgação. Um tutorial meia-boca pode ser encontrado aqui.

[]'s
Cacilhas, La Batalema

Calculadora científica com o Vim

2009-03-04T12:25:00.002-03:00

Desta vez vou reblogar…

O voyeg3r publicou um artigo curtinho e muito legal sobre como criar uma calculadora científica no Vim usando Python.

O artigo pode ser encontrado no vivaotux.

Boa leitura!

[]'s
Cacilhas, La Batalema

Propriedades e acessores

2009-01-29T23:30:00.008-03:00

Em Java e em C++ há um bom motivo para que os atributos sejam sempre privados: preservar a interface das classes.

Por exemplo, imagine que temos uma classe que representa o registro de uma pessoa. Nela temos a idade. Sendo um número inteiro, poderia ser um atributo público:

Person person;
person.age = 23;
std::cout << person.age << std::endl;

Faz sentido. Agora imagine que mais tarde descobrimos que é preciso fazer um tratamento do valor recebido – para estar numa faixa aceitável, por exemplo…

Sem alterar a interface – e efetuar uma refatoração total de todo código onde ocorre instância – é impossível.

Então, em Java e C++ é importante usar métodos acessores e manter os atributos privados. Dessa forma qualquer alteração futura pode ser feita na classe sem alterar o restante do código:

Person person;
person.setAge(23);
std::cout << person.getAge() << std::endl;

Propriedades

Já em Python isso não faz sentido!

Em Python, além de atributos e métodos, há as propriedades. Então atributos podem ser públicos e, caso seja necessário adicionar alguma lógica na leitura ou gravação do atributo, basta substituí-lo por uma propriedade, sem prejudicar a interface.

class Person:

    def __init__(self):
        self.name = ""
        self.age = 0

Substituindo por propriedades:

class Person:

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

    age = property(_get_age, _set_age)

E a interface permanece imutável!

Aviso: não use propriedade quando não for necessário! Use atributo público. Um pouco de desempenho não faz mal a ninguém, mesmo em scripts.

Aviso²: testei esse código no prompt e não funciona, mas funciona em script. Se alguém puder descobrir o que está acontecendo, agradeço.

[update 2009-08-26]Usando IPython funcionou corretamente, portanto não sei o que causou o erro. =P

Assim assim, valeu Thiago Coutinho por tê-lo identificado (acho que ainda ocorre durante a interpretação em linha do CPython tradicional).[/update]

Usando metaclasse

Uma forma de implementar automaticamente autopropriedades foi sugerida por Guido van Rossum em Unificando Tipos e Classes (original).

Usaremos uma metaclasse:

class autoprop(type):

    def __init__(cls, name, base, dict):
        super(autoprop, cls).__init__(name, base, dict)
        props = {}
        for method in dict:
            if method.startswith("_get_") \
                or method.startswith("_set_") \
                or method.startswith("_del_"):
                props[method[5:]] = True
        for prop in props:
            fget = getattr(cls, "_get_" + prop, None)
            fset = getattr(cls, "_set_" + prop, None)
            fdel = getattr(cls, "_del_" + prop, None)
            setattr(cls, prop, property(fget, fset, fdel))

A ideia por trás dessa metaclasse é identificar métodos iniciados por _get_, _set_ ou _del_ e criar propriedades a partir daí. O método iniciado por _get_ representa a leitura, _set_ representa a escrita e _del_ representa a remoção.

Nossa classe então ficaria assim:

class Person:
    __metaclass__ = autoprop

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

Usando decoradores

Mas realmente, ao contrário da metaclasse para singleton, usar metaclasse para autopropriedade é como usar uma escopeta para espantar uma mosca.

Vamos usar decoradores!

O decorador @property pode ser usado para criar propriedades para apenas leitura. Como precisamos de leitura e gravação, podemos usar @apply.

É um pouco gambiarrático, mas funciona muito bem e deixa o código relativamente limpo:

class Person:

    def __init__(self):
        self.name = ""
        self.__age = 0

    @apply
    def age():
        def fget(self):
            return self.__age

        def fset(self, age):
            if 0 <= age < 150:
                self.__age = age

        return property(**locals())

A função deve ter o nome da propriedade. O método de escrita deve chamar-se fset, o de leitura fget e o de remoção fdel. A parte mais feia desse código é o retorno. =)

**

Fica aqui a dica!

[]'s
Cacilhas, La Batalema

Interface fluente

2009-01-28T20:53:00.008-03:00

Outro pattern interessante é conhecido como carrying return (não confundir com carriage return, carácter com código ASCII 13).

[update 2009-01-29]Esse era o nome dado há uns anos atrás, quando conheci esse pattern. Porém ele não ganhou espaço entre os programadores na época e poucos continuaram usando (como eu). =P

Hoje em dia ele voltou com o nome Fluent Interface, Interface Fluente.

A propósito, troquei o título deste artigo para usar uma linguagem mais nova e mais fácil de ser reconhecida.

Valeu Walter e Lucas![/update]

~~Há outros nomes, mas não consigo encontrar no São Google, pois não é um pattern muito usado.~~

Parecido com Smalltalk

Imagine que você tem uma classe Java que recebe muitos parâmetros na instanciação:

Person person = new Person(
    aString, aDate, anotherString, aLoad, aPerson, anotherPerson
);

A quantidade de argumentos pode explodir ao extremo. Python pode apresentar maior visibilidade quanto ao significado dos parâmetros:

person = Person(
    name=aString,
    birthdate=aDate,
    id=anotherString,
    load=aLoad,
    father=aPerson,
    mother=anotherPerson
)

Smalltalk, uma linguagem bem mais antiga do que Python ou Java, já tinha uma abordagem bem mais elegante:

person := Person new.
person
    setName:      aString;
    setBirthdate: aDate;
    setId:        anotherString;
    setLoad:      aLoad;
    setFather:    aPerson;
    setMother:    anotherPerson.

É possível conseguir um código similar em Java usando acessores tipo setter:

Person person = new Person();
person.setName(aString);
person.setBirthdate(aDate);
person.setId(anotherString);
person.setLoad(aLoad);
person.setFather(aPerson);
person.setMother(anotherPerson);

Finalmente

Mas é possível obter um código ainda mais elegante usando o pattern em questão.

A ideia é simples: em vez dos acessores setter não terem retorno (void), basta eles retornarem this:

class Person {
    private String name;
    private Date birthdate;
    private String id;
    private Load load;
    private Person father;
    private Person mother;

    public Person() {
        name = null;
        birthdate = null;
        id = null;
        load = null;
        father = null;
        mother = null;
    }

    public String getName() {
        return name;
    }

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public Date getBirthdate() {
        return birthdate;
    }

    public Person setBirthdate(Date birthdate) {
        this.birthdate = birthdate;
        return this;
    }

    public Load getLoad() {
        return load;
    }

    public Person setLoad(Load load) {
        this.load = load;
        return this;
    }

    public Person getFather() {
        return father;
    }

    public Person setFather(Person father) {
        this.father = father;
        return this;
    }

    public Person getMother() {
        return mother;
    }

    public Person setMother(Person mother) {
        this.mother = mother;
        return this;
    }
}

Agora podemos usar uma estrutura de código similar à de Smalltalk:

Person person = new Person()
    .setName(aString)
    .setBirthdate(aDate)
    .setId(anotherString)
    .setLoad(aLoad)
    .setFather(aPerson)
    .setMother(anotherPerson);

[]'s
Cacilhas, La Batalema

Singleton

2009-01-27T21:39:00.006-03:00

Um design pattern bastante conhecido na engenharia de software é singleton.

Singleton é quando uma classe possui apenas uma instância e não se deseja que em uma mesma aplicação haja mais de uma.

Exemplos de classes desejadamente singleton são pools e carregadores.

Em C++ a saída para criar uma classe singleton é tornar protegido seu método construtor e criar um método getInstance para retornar a instância única:

class Loader {
    protected:
        Loader();

    public:
        ~Loader();

        static Loader& getInstance();
}

O método getInstance deve guardar uma referência estática para a instância:

static Loader& Loader::getInstance() {
    static Loader *instance = 0;
    if (!instance)
        instance = new Loader();
    return *instance;
}

Java utiliza a mesma abordagem, já outras linguagens, como Perl, Python e Ruby têm uma abordagem bem mais elegante.

Singleton em Python

A ideia de singleton em Python – Perl e Ruby – é usar o próprio construtor da classe para obter a instância.

Por exemplo, em vez de (Java):

Image character = Loader.getInstance().getImage("char.png");

Teremos (Python):

character = Loader().getImage("char.png")

Há três formas de implementar singleton em Python: ¹implementando diretamente na classe, ²herdando um classe pai ou ³usando metaclasse (o mais divertido!).

Implementação direta na classe

Você pode implementar uma classe singleton diretamente, usando os metamétodos __new__ (construtor real) e __init__ (construtor de inicialização).

A classe ainda precisa ter um atributo de classe para armazenar a instância.

A ideia mais simples é implementar __new__ para devolver a instância em vez de uma nova a cada vez:

class Loader:

    __instance = None
    __initialized = False


    def __new__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

Repare no atributo __initialized… isso é porque ainda temos um problema: o construtor de inicialização (__init__) será chamado novamente a cada tentativa de obter a instância.

Então precisamos verificar se a inicialização já foi executada:

    def __init__(self, *args, **keyw):
        if not self.__initialized:
            self.__initialized = True
            # Restante do método...

Pronto! Nossa classe já é singleton.

Herança

Podemos usar uma classe pai que implemente unicidade e estendê-la:

class Singleton:

    __instance = None
    __initialized = False

    def __new__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, *args, **keyw):
        if not self.__initialized:
            self.__initialized = True
            self._init(*args, **keyw)

Assim, para implementar uma classe singleton:

class Loader(Singleton):

    def _init(self, *args, **keyw):
        # Este será o construtor...

A vantagem desta abordagem é sua capacidade de reaproveitamento: é possível reutilizar a classe Singleton como classe pai de cada nova classe singleton.

No entanto traz dois inconvenientes: primeiro os métodos podem conflitar com métodos de outras classes pai em herança múltipla; segundo é preciso prestar atenção à implementação estranha (uso de _init em vez de __init__) e ter cuidado com a sobrescrita de métodos.

A solução para tornar isso mais transparente é usar uma metaclasse.

Metaclasse

Metaclasse é um classe cujas instâncias são classes. Vamos criar uma metaclasse cujas classes sejam singleton:

class singleton(type):

    def __init__(cls, name, base, dict):
        super(singleton, cls).__init__(name, base, dict)
        cls.__instance = None
        cls.__copy__ = lambda self: self
        cls.__deepcopy__ = lambda self, memo=None: self

    def __call__(cls, *args, **keyw):
        if cls.__instance is None:
            cls.__instance = \
                super(singleton, cls).__call__(*args, **keyw)
        return cls.__instance

Agora vem a beleza da metaclasse: para criar uma classe singleton basta fazer:

class Loader:
    __metaclass__ = singleton

Nada mais! Todo o resto da classe pode ser implementado sem preocupações.

A única dúvida que pode ocorrer é: e se a classe tiver outra metaclasse?

É fácil resolver! Por exemplo: imagine uma classe singleton que implemente autopropriedades:

class Loader:

    class __metaclass__(autoprop, singleton):
        pass

**

Está aqui outra dica! Mais sobre singleton pode ser encontrado nas Reflexões de Monte Gasppa e Giulia C..

[]'s
Cacilhas, La Batalema

Mostrando o status e o branch de repositórios git no console

2009-01-27T11:06:00.017-03:00

Com uma função de shell script e a ajuda da variável PS1 podemos fazer uma configuração bem interessante: exibir no próprio console em qual branch estamos e qual o estado dele.

Um exemplo de como fica:

Esse é um screenshot do meu desktop, mostrando o repositório do tracks (um aplicativo interessante para quem pretende usar a metodologia GTD). Em amarelo, o caminho do repositório. Entre os colchetes, o branch no qual estamos, e finalmente, um * indicando se o repositório contém modificações ainda não confirmadas no repositório.

Para configurar, basta adicionar ao seu .bashrc:

function parse_git_dirty {
    [[ $(git status 2> /dev/null | tail -n1) \
        != "nothing to commit (working directory clean)" \
    ]] && echo "*"
}

function parse_git_branch {
    git branch --no-color 2> /dev/null | \
    sed -e '/^[^*]/d' \
        -e "s/* \(.*\)/[\1$(parse_git_dirty)]/"
}

export PS1='\u@\h \[\033[1;33m\]\w\[\033[0m\]$(parse_git_branch)$'

Visto originalmente aqui.

[]'s
- Walter Cruz

Pyglet

2009-01-24T13:11:00.007-03:00

Há alguns módulos em Python de interface com a biblioteca de mídia SDL, sendo o mais conhecido PyGame.

PyGame é legal, lembra a mim a antiga API gráfica do Colour BASIC do MSX (eita saudosismo!).

No entanto o Kao Félix apresentou recentemente um outro módulo menos conhecido, chamado Pyglet, que, a primeira vista, achei mais pythónica. =D

Gostaria então de sugirir dois tutoriais do Kao Félix:

Instalando Pyglet

Se você possui o EasyInstall, basta executar:

bash$ sudo easy_install -U pyglet

Primeira aplicação

Resolvi fazer minha primeira aplicação segundo as dicas do Kao Félix, mas adaptando a meu jeito próprio de programar.

Iniciaremos com o hash-bang, as peculiaridades de Python e os imports dos submódulos de Pyglet que vamos precisar:

#!/usr/bin/env python
# coding: UTF-8

from __future__ import division
__metaclass__ = type

from pyglet import app, clock, resource, sprite
from pyglet.window import key, Window

Carregando os recursos iniciais

Esta é classe singleton para carregar os recursos de mídia que precisaremos.

Fiz o seguinte: baixei a bola do Kao, mas pode também baixar daqui mesmo – preferível, para não sobrecarregar o link dele.

O arquivo de som está no pacote do KDE, mas você pode baixar daqui.

Nessa classe singleton, implementaremos o método __new__ (apenas para singleton) e __init__ para carregar as mídias.

Para carregar uma imagem usamos resource.image(). Para áudio, resource.media():

class Loader:
    """Singleton class for loading resources"""

    __inst = None
    __initialized = False

    def __new__(cls, *args, **keyw):
        if not cls.__inst:
            cls.__inst = object.__new__(cls)
        return cls.__inst

    def __init__(self):
        if not self.__initialized:
            self.__initialzed = True

            self.images = {}
            self.sounds = {}

            image = resource.image("char.png")
            image.anchor_x = image.width // 2
            image.anchor_y = image.height // 2
            self.images["ball"] = image

            self.sounds["pop"] = resource.media(
                "pop.wav",
                streaming=False
            )

O parâmetro streaming=False indica que o arquivo de áudio deve ser completamente carregado para a memória – e não tratado como um fluxo (stream).

Gerenciando o teclado

Uma nova classe será usada para gerenciar o teclado. O construtor armazenará uma referência para a janela principal e o método handle_input() gerenciará as teclas:

class KeyHandler(key.KeyStateHandler):
    """Class for handling key events"""

    def __init__(self, window):
        super(KeyHandler, self).__init__()
        self.window = window

    def handle_input(self, dt):
        speed = 320 * dt
        dx, dy = 0, 0

        if self[key.RIGHT]:
            dx = 1
        elif self[key.LEFT]:
            dx = -1

        if self[key.UP]:
            dy = 1
        elif self[key.DOWN]:
            dy = -1

        self.window.ball.x += dx * speed
        self.window.ball.y += dy * speed

Repare que nosso objeto window terá um atributo ball, que é um sprite.

Agora nosso sprite

Vamos criar agora uma classe que estende sprite.Sprite, a classe de sprite de Pyglet.

O único método que implementaremos será o construtor, que buscará em Loader a imagem que desejamos:

class Ball(sprite.Sprite):
    """Sprite that's a ball"""

    def __init__(self, *args, **keyw):
        super(Ball, self).__init__(
            Loader().images["ball"],
            *args, **keyw
        )

Janela principal

Finalmente a aplicação!

Por um mal hábito adquirido programando Tkinter, tenho o hábito de usar a mesma classe para aplicação e janela principal, porém você não precisa fazer ~~esse bacalhau~~ isso!

No entanto vou mostrar aqui da forma como estou habituado.

O construtor:

ajustará o título da janela (set_caption());
criará uma nova bola (classe Ball);
registrará o manipulador de eventos de teclas (push_handlers());
e registrará o método handle_input() do manipulador de eventos de teclas para execução periódica (clock.schedule_interval()).

class MainApplication(Window):
    """Main window and application"""

    def __init__(self):
        super(MainApplication, self).__init__()
        self.set_caption("Teste de movimento")

        self.ball = Ball(x=300, y=240)

        handler = KeyHandler(self)
        self.push_handlers(handler)
        clock.schedule_interval(handler.handle_input, 1/60)

Manipulando outros eventos

Os métodos de Window que manipulam eventos têm nome iniciado por on_, seguido pelo nome do evento. Por exemplo: on_close, on_draw, on_key_press, on_key_release.

Vamos implementar on_close() para tocar o som ao sair e on_draw() para exibir o sprite:

    def on_close(self):
        Loader().sounds["pop"].play()
        super(MainApplication, self).on_close()

    def on_draw(self):
        self.clear()
        self.ball.draw()

Fazendo funcionar

Para terminar, precisamos instanciar a aplicação e chamar o ciclo principal de Pyglet.

Veja que esse tipo de programação onde um módulo toma o controle e programamos os métodos que atenderão eventos caracteriza um framework.

if __name__ == "__main__":
    window = MainApplication()
    app.run()

Conclusão

Vemos aqui um ótimo módulo – ou melhor, framework – para criação de aplicações gráficas usando as bibliotecas SDL e OpenGL.

[]'s
Cacilhas, La Batalema

Atributos privados onde?

2009-01-10T07:43:00.003-03:00

Os programadores de Java e C++ pregam vigorosamente a favor de métodos e atributos privados, como se isso fosse uma grandíssima vantagem.

É um recurso… faz sentido em seu contexto, mas não traz vantagem alguma por si só – ao contrário da evangelização dos fanáticos.

De qualquer forma, o C++ não bloqueia tanto o acesso do programador quanto é pregado.

Por exemplo, voltemos lá atrás no artigo Portanto GDBM para Lua: havia uma classe GdbmObject com um descritor de arquivo de banco de dados privado.

Digamos que, por alguma razão bizarra, queiramos ter acesso direto ao descritor.

Mas o atributo é privado!

Vamos ao bacalhau:

class GdbmObjectCorrupting {
    public:
        bool closed;
        GDBM_FILE fd;
}

Repare que os atributos públicos aqui têm o mesmo tipo e o mesmo nome dos atributos privados da classe original. Isso garantirá que os símbolos gerados sejam idênticos – e este é o truque.

Agora imagine que temos a instância obj de GdbmObject, da qual queremos acessar os atributos privados. A mágica é:

GdbmObjectCorrupting *aux =
    reinterpret_cast<GdbmObjectCorrupting *>(obj);

Pronto! Já está feit~~o o bacalhau~~a a mágica!

No escopo de aux, aux->fd dá acesso direto ao descritor de obj, assim como aux->closed dá acesso ao booleano closed de obj.

Agora, este artigo é uma prova de conceito! Não aconselho ninguém a fazer isso. Aliás o Kodumaro desaprova fortemente tal prática: reitero, é apenas uma prova de conceito.

[]'s
Cacilhas, La Batalema

Perl6

2008-12-10T22:27:00.006-03:00

Larry Wall, criador do Perl e cocriador do Parrot, declarou que a versão 6 de Perl não será compatível com as versões anteriores.

Realmente dei uma olhada no Perl6 e está muito diferente… só que para melhor. =)

A única coisa de que não gostei foram das mudanças em expressões regulares, no mais as mudanças só acrescentam.

Tipagem

Uma das maiores reclamações que os programadores fazem de Perl é sua tipagem insanamente fraca, apenas três tipos: escalar ($scalar), vetor (@array) e vetor associativo (%hash).

Perl6 traz o suporte a tipos! Pelo que vi na documentação, há seis tipos novos: inteiro (int), ponto flutuante (num), string (str), booleano (bool), bit (bit) e referência (ref), de forma estática:

my int $foo = 5;
my str $bar = "foo";
my num $baz = 5.3;
my bool $foobar = 1;

Conversão:

print str 5;
print scalar @list;

Passagem de parâmetros

Em Perl a passagem de parâmetros sempre foi por cópia, agora passa a ser por referência, exceto para tipos primitivos.

No caso de atribuição de referência de tipos primitivos, em vez do tradicional:

 my $b = \$a;

Passa a ser:

 my $b := $a;

Mudanças em vetores

A criação de vetor passa a suportar um formato mais simples.

Temos o tradicional:

my @fruits = ("apple", "pear", "banana");

Que passa a ser:

my @fruits = "apple", "pear", "banana";

E a lista:

my @fruits = qw/apple pear banana/;

Passa a ser:

my @fruits = <apple pear banana>;

Em Perl5, para se obter um item de um vetor, o primeiro carácter mudava de @ para $: $fruits[0]. Agora, em Perl6, não há mais alteração: @fruits[0].

A quantidade de elementos de um vetor era dada por:

my $count = $#fruits + 1;

Agora, em Perl6 passa a ser:

my int $count = @fruits.elems;

Repara que o famigerado -> virou um simples ponto!

Também para obter o último elemento do vetor, que era:

my $last = $fruit[$#fruit];

Passa a ser:

my $last = @fruit[@fruit.end];

Ou ainda:

my $last = @fruit[*-1];

Para se obter um vetor em um contexto string, Perl6 oferece o atalho ~. Para numérico + e para booleano ?:

my str $str_fruits = ~@fruits;
my num $num_fruits = +@fruits;
my bool $bool_fruits = ?@fruits;

Tratamento de exceções

Em Perl5 era usado eval para avaliar um bloco com possível exceção e $@ recebia os dados de exceção:

eval {
    …
};
if ($@) {
    warn "exception: $@";
}

Perl6 passa a usar try-CATCH:

try {
    …
    CATCH {
        warn "exception: $!";
    }
}

Repare que a mensagem de exceção passa a ser capturada em $! e o bloco CATCH fica dentro do bloco try.

Repetições

Não há uma forma menos dolorosa de dizer isso: foreach vira for, que também passa a suportar algumas construções de while, for vira loop, que também passa a suportar algumas construções de while.

Então:

foreach (@fruits) {

Vira:

for @fruits {

foreach my $fruit (@fruits) {

Vira:

for @fruits -> $fruit {

Agora, olha o while aí:

while (my($age, $sex, $location) = splice @whatever, 0, 3) {

Vira:

for @whatever -> $age, $sex, $location {

Contando até dez em Perl5:

for (my $i = 1; $i <=10; $i++) {
    print "$i\n";
}

Contando até dez em Perl6:

loop (my $i = 1; $i <=10; $i++) {
    say $i;
}

E loop { … } funciona como while (1) { … }.

Vetor associativo

Sofre alterações parecidas com as de vetor.

Por exemplo, em Perl5:

my $c = $days{February};

Em Perl6 vira:

my int $c = %days{'February'};

Ou ainda:

my int $c = %days<February>;

Alguns métodos

Para se obter o tamanho de uma string em Perl5:

my $len = length $string;

Em Perl6 fica:

my int $len = $string.chars;

Para exibir um vetor de modo ordenado em Perl5:

print sort(@fruits);

Em Perl6:

say @array.sort;

Ou ainda:

@array.sort.print;

Variáveis de sistema

Para se obter o valor da variável HOME em Perl5:

print $ENV{HOME};

Em Perl6 passa a ser:

print %*ENV<HOME>;

Ou ainda:

print $+HOME;

Orientação a objetos

Criar uma classe em Perl5 era uma aventura!

Você criava um pacote (package) e «abençoava» um escalar com o pacote… pronto: aí tinha uma instância cuja classe era o pacote.

Um tremendo bacalhau.

Em Perl6 temos as palavras reservadas class, has (para atributos) e method (para métodos), para criar classes reais.

Métodos privados precisam começar com !, por exemplo, $!age, e métodos públicos precisam começar com ., como por exemplo $.name.

A passagem de parâmetros também mudou. Além de ser por referência, como citado, passa a suportar parâmetros nominais e parâmetros excedentes – como *args de Python, mas com a sintaxe *@args.

Se o argumento for mutável precisa ser seguido de is rw.

O que era:

package Square;
@ISA = qw/ Rectangle /;

Passa a ser:

class Square is Rectangle {

E o que era:

my $rect = new Rectangle(4, 5);

Passa a ser:

my Rectangle $rect .= new(4, 5);

Conclusão

Há muito mais! Consulte a página Perl6::Perl5::Differences, mas o que já sabemos é: quem trabalha com Perl vai precisar aprender de novo!

[]'s
Cacilhas, La Batalema

Persistência de dados entre execuções em OpenStep

2008-12-05T15:18:00.002-03:00

OpenStep facilita a persistência de dados entre uma execução e outra do programa através da classe NSUserDefaults.

Para persistir dados para a próxima execução, basta criar um dicionário (NSDictionary) representando um hash dos dados a serem persistidos.

Digamos que o dicionário seja defaults e APP_NAME é uma string (NSString) representando o nome da aplicação:

[[NSUserDefaults standardUserDefaults]
    setPersistentDomain: defaults
    forName: APP_NAME
];

E para recuperar os dados persistidos da última execução:

NSDictionary *defaults = [
    [NSUserDefaults standardUserDefaults]
    persistentDomainForName: APP_NAME
];

Então defaults será um dicionário contendo os dados persistidos!

Simples assim. =)

Referência: GNUstep Base.

[]'s
Cacilhas, La Batalema

Base64

2008-11-20T09:38:00.011-03:00

De vez enquando, não tem como não, nós programadores sempre esbarramos na Base64.

Base64 é um protocolo de codificação que usa apenas seis bits, o que significa um conjunto de sessenta e quatro (64) elementos – daí Base64.

A conversão de oito (byte) para seis bits é feita da seguinte forma:
xxxxxx.xx xxxx.xxxx xx.xxxxxx

Ou ainda:
aaaaaabb bbbbcccc ccdddddd

Os elementos usados são caracteres simples, começando com as letras maiúsculas, A (0) a Z (25), então as letras minúsculas, a (26) a z (51), os números, 0 (52) a 9 (61), e os caracteres + (62) e / (63).

Na conversão de bytes (8b) para Base64 (6b), cada três bytes é convertido em quatro dígitos, então um código Base64 é sempre pensado em grupos de quatro. Se o tamanho de um código Base64 não for múltiplo de quatro, caracteres = são acrescentados ao final até que o tamanho seja múltiplo de quatro.

Python

Em Python, Base64 é tão simples que nem tem graça:

>>> print "Kodumaro".encode("base64")
S29kdW1hcm8=
>>> print "S29kdW1hcm8=".decode("base64")
Kodumaro

Lua

Em Lua, é preciso baixar o módulo Mime do LuaSocket:

> require "mime"
> print(mime.b64 "Kodumaro")
S29kdW1hcm8=
> print(mime.unb64 "S29kdW1hcm8=")
Kodumaro

Smalltalk

Sendo muito sincero sobre o assunto, não sei como fazer conversão de Base64 em Smalltalk. =(

Mas sei que os módulos do Seaside providenciam isso!

Se alguém souber, por favor informe!

[update 2009-11-27]
Sugestão do Hugo:

No Squeak tem isso aqui:
(Base64MimeConverter mimeEncode: 'base64' readStream) contents
(Base64MimeConverter mimeDecode: 'S29kdW1hcm8' as: ByteString) contents
E no Pharo tem métodos para strings:
'base64' base64Encoded
'S29kdW1hcm8' base64Decoded
A implementação usa as coisas do Squeak:
String>>base64Decoded
↑ (Base64MimeConverter mimeDecode: self as: self class)

String>>base64Encoded
↑ (Base64MimeConverter mimeEncode: self readStream) contents
Para outros Smalltalks eu não sei…

Legal né? =)

Muito legal sim, Hugo, valeu!
[/update]

C

Aha! Aqui começa de verdade a brincadeira!

É claro que você pode usar as funcionalidades de Base64 da gLibC, mas descobri que nem todas as versões dela apresentam tais funcionalidades:

#include <glib/gbase64.h>

Vamos precisar usar os cabeçalhos stdlib.h, string.h e sys/types.h. Como também vamos criar um cabeçalho para «compartilhar» algumas funções, ele também será incluído no início de nosso arquivo base64.c:

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include "base64.h"

Agora vamos criar um array com todos os possíveis caracteres Base64 em sua ordem natural:

static const char b64all[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"
    "ghijklmnopqrstuvwxyz0123456789+/";

Também vamos precisar de três funções locais: uma para obter o índice de um elemento (_getindex), outra para codificar para Base64 um grupo de três bytes (_encode) e mais uma para decodificar um grupo de quatro elementos Base64 (_decode):

int _decode(u_int8_t *, const u_int8_t *);
void _encode(u_int8_t *, const u_int8_t *, int);

Não é preciso uma função para _getindex:

#define _getindex(c) (int) (index(b64all, c) - b64all)

Repara que, em vez de char, estamos usando u_int8_t, que é mais conveniente quando queremos lidar com bytes enquanto bytes, não caracteres.

A partir daqui, se preferir, organize as funções em ordem alfabética – ou na ordem que quiser.

A primeira função que implementaremos será para codificar uma string C (const char *) para Base64. Como a string pode não ser bem formada, a função deverá receber também seu tamanho:

const char *b64encode(const char *original, int length) {
    // Se o tamanho não for informado, consideramos uma string bem
    // formada
    if (length == 0)
        length = strlen(original);

    // Inteiro com o tamanho do código a ser gerado
    int b64length = ((length + 2) / 3) * 4 + 1;

    // Contadores para percorrer as strings
    int i=0, j=0;

    // Alocando memória para o código
    char *b64 = (char *) malloc(sizeof(char) * b64length);
    memset(b64, 0, b64length);

    while (i < length) {
        // Codifica um grupo de três bytes...
        _encode(
            (u_int8_t *) b64 + j,
            (const u_int8_t *) original + i,
            (length - i)
        );

        // E segue para o próximo grupo
        i += 3;
        j += 4;
    }

    // Retorna o código
    return (const char *) b64;
}

A próxima função deve fazer o contrário, converter um código Base64 para uma string. Como a string resultante pode não ser bem formada – pode não ser terminada em carácter nulo ou possuir caracteres nulos no meio –, é preciso uma forma de informar seu tamanho, então ela receberá um ponteiro para um inteiro:

const char *b64decode(const char *b64, int *length) {
    // Inteiro com o tamanho do código
    int b64length = strlen(b64);

    // Se não for múltiplo de quatro, há algo errado
    if (b64length % 4 != 0)
        return NULL;

    // Tamanho máximo da string decifrada
    int prob = (b64length / 4) * 3 + 1;

    // Contadores para percorrer as strings
    int i=0, j=0;

    // Alocando memória para o resultado
    char *s = (char *) malloc(sizeof(char) * prob);

    while (j < b64length) {
        // Decifra um grupo de quatro elementos
        // e conta o resultado
        i += _decode(
            (u_int8_t *) s + i,
            (const u_int8_t *) b64 + j
        );

        // Segue para o próximo grupo
        j += 4;
    }

    // Se foi fornecido um inteiro para contagem, informa o tamanho
    if (length != NULL)
        *length = i;

    // Retorna a string decifrada
    return (const char *) s;
}

Agora precisamos das funções específica para as conversões.

Primeiro para codificar:

void _encode(u_int8_t *dest, const u_int8_t *src, int len) {
    // Menor que 1, nada a fazer
    if (len < 1)
        return;

    // Dados a serem retornados
    int aux[] = { 0, 0, 0, 0 };

    // Primeiro elemento: os 6 bits mais significativos do primeiro
    // byte
    aux[0] = src[0] >> 2;

    // Segundo elemento: os 2 bits menos significativos do primeiro e
    // os quatro bits mais significativos do segundo byte
    aux[1] = (src[0] & 0x03) << 4;

    if (len > 1) {
        // SE houver um segundo...
        aux [1] |= (src[1] & 0xf0) >> 4;

        // Terceiro elemento: os quatro bits menos significativos do
        // segundo e os dois mais significativos do terceiro byte
        aux [2] = (src[1] & 0x0f) << 2;

        if (len > 2) {
            // Se houver um terceiro...
            aux[2] |= src[2] >> 6;

            // Quarto elemento: os seis bits menos significatos do
            // terceiro byte
            aux[3] = src[2] & 0x3f;
        }
    }

    // Codifica agora os valores numéricos para string
    dest[0] = b64all[aux[0]];
    dest[1] = b64all[aux[1]];
    dest[2] = '=';
    dest[3] = '=';
    if (len > 1) {
        dest[2] = b64all[aux[2]];
        if (len > 2)
            dest[3] = b64all[aux[3]];
    }
}

int _decode(u_int8_t *dest, const u_int8_t *src) {
    // Representação numérica do código
    int aux[] = { 0, 0, 0, 0 };

    // Contador
    int i, c = 1;

    // Converte código para valores numéricos
    for (i = 0; i < 4; ++i)
        aux[i] = _getindex(src[i]);

    // Primeiro byte: primeiro elemento seguido dos quatro bits mais
    // significativos do segundo
    dest[0] = (u_int8_t) (aux[0] << 2) | ((aux[1] & 0x30) >> 4);

    // Zera os bytes seguintes
    dest[1] = '\0';
    dest[2] = '\0';

    if (aux[2] != -1) {
        // Se houver um terceiro elemento...
        ++c;

        // Segundo byte: quatro bits menos significativos do segundo
        // elemento seguidos pelos quatro bits mais significativos do
        // terceiro
        dest[1] = (u_int8_t) ((aux[1] & 0x0f) << 4) | (aux[2] >> 2);

        if (aux[3] != -1) {
            // Se houver um quarto elemento...
            ++c;

            // Terceiro byte: dois bits menos significativos do
            // terceiro elemento seguidos pelo quarto elemento
            dest[2] = (u_int8_t)
              ((aux[2] & 0x03) << 6) |
              aux[3];
        }
    }

    // Retorna o tamanho da string
    return c;
}

Cabeçalho

Por último criamos o cabeçalho base64.h, tornando públicas as duas funções de codificação e decodificação:

#ifndef _BASE64_H
#define _BASE64_H

const char *b64decode(const char *, int *);
const char *b64encode(const char *, int);

#endif

Conclusão

Mesmo que ninguém vá implementar uma biblioteca de conversão Base64, espero que este artigo sirva para ajudar a entender melhor do que se trata Base64.

[update]
Se quiser acrescentar algum açucar sintático, coloque em base64.c:

#ifdef C_PLUS_PLUS
const char *b64decode(const char *b64, int &length) {
    return b64decode(b64, &length);
}
#endif

E mude o conteúdo de base64.h para:

#ifndef _BASE64_H
#define _BASE64_H

#ifdef C_PLUS_PLUS
extern "C" {
#endif

const char *b64decode(const char *, int *);
const char *b64encode(const char *, int);

#ifdef C_PLUS_PLUS
}
const char *b64decode(const char *, int &);
#else
#define _b64decode(s, len) b64decode(s, &len)
#endif

#endif

[/update]

[]'s
Cacilhas, La Batalema

Objective C

2008-11-13T21:52:00.011-03:00

Escrevi recentemente um artigo com um exemplo bem simples de desenvolvimento de uma aplicação para ambiente GNUstep, mas cometi a gafe de não dedicar algum tempo falando da linguagem de programação em questão, Objective C.

Objective C, ou Objective-C, ou ObjC, é uma linguagem de programação reflectiva orientada a objetos criada nos idos da década de 1980 – mais ou menos na mesma época que o C++ – pelos fundadores da Stepstone, mais tarde adquirida pela NeXT. É na verdade uma camada bem fina sobre a linguagem C padrão.

Isso significa que, se você sabe programar em C, conseguirá programar em ObjC sem muito esforço.

Diferenças para C

Sobre a linguagem C, ObjC adiciona os seguintes recursos:

Orientação a objetos, adaptada de Smalltalk.
Tipo boleano – BOOL. Verdadeiro é YES e falso é NO.
Comentário de linha, iniciado por // (na época C não suportava).
A diretiva de preprocessador #import, que funciona como #include, mas só inclui o cabeçalho se ele não foi incluído ainda.
O tipo id, similar a void * de C/C++.
A constante nil, que é um objeto id sem valor: (id)0.

A maior parte dos comandos referentes a orientação a objetos começam com @, como @interface, @implementation, @end, @private, @protected, @public, @protocol, etc.… Entre colchetes é avaliado o ambiente de mensagem, com uma sintaxe muito parecida com a de Smalltalk.

Criando uma classe

Como exemplo, vamos criar a classe Point, com os atributos x e y.

Para tanto, primeiro criamos a interface no arquivo Point.h:

#ifndef _POINT_H
#define _POINT_H

#import <Foundation/Foundation.h>

@interface Point : NSObject
{
    int x;
    int y;
}

+ (id) newWithX: (int)valuex Y: (int)valuey;
- (id) initWithX: (int)valuex Y: (int)valuey;
- (int) diagonal;
- (int) getX;
- (int) getY;
- (void) setX: (int)value;
- (void) setY: (int)value;

@end

#endif

As diretivas #ifndef, #define e #endif já são velhas conhecidas dos programadores C/C++. O #import já foi explicado, funciona parecido com #include.

O cabeçalho Foundation/Foundation.h inclui a classe NSObject, definida pela API OpenStep, usada aqui como classe pai de nossa classe Point.

O comando @interface inicia a descrição da interface e o comando @end encerra. O pequeno escopo entre chaves define os atributos de instância, protegidos por padrão – para defini-los como públicos a sintaxe seria:

{
    @public
        int x;
        int y;
}

As linhas começadas por um sinal de menos (-) indicam métodos de instância – métodos de classe são iniciados por +. Por exemplo:

- (id) initWithX: (int)valuex Y: (int)valuey;

Significa um método de instância que recebe dois atributos inteiros – valuex e valuey, e retorna um id.

Agora precisamos implementar a interface. Para isso vamos criar o arquivo Point.m:

#include <math.h>
#import "Point.h"

@implementation Point

+ (id) newWithX: (int)valuex Y: (int)valuey {
    return [[Point alloc]
        initWithX: valuex Y: valuey];
}

- (id) initWithX: (int)valuex Y: (int)valuey {
    if ((self = [super init])) {
        x = valuex;
        y = valuey;
    }
    return self;
}

- (int) diagonal {
    return (int) sqrt((double) ((x * x) + (y * y)));
}

- (int) getX {
    return x;
}

- (int) getY {
    return y;
}

- (void) setX: (int)value {
    x = value;
}

- (void) setY: (int)value {
    y = value;
}

@end

O código é muito parecido com C, e até mesmo com C++, cabendo apenas alguns comentários:

self é uma palavra reservada que representa a instância, como this de Java e C++.
super referencia a classe pai, como em Java.
Repare no comando [super init]: aqui é passada uma mensagem para super e o valor retornado é atribuído a self.

Para instanciar um objeto, a sintaxe é:

id point = [Point newWithX: 4 Y: 5];

Ou, com tipagem estática:

Point *point = [Point newWithX: 4 Y: 5];

Para obter o valor de x:

printf("x = %d\n", [point getX]);

E para mudar seu valor:

[point setX: 2];

OpenStep

OpenStep é a API aberta para desenvolvimento de aplicações para NEXTSTEP, resultado de um trabalho colaborativo da NeXT com a SUN Microsystems.

Diversos sistemas e ambientes oferecem suporte a OpenStep, como OS X e GNUstep.

Diversos recursos interessantes são oferecidos nessa API, desde vantagens semelhantes à STL de C++, até conjunto de widgets para construção de janelas, toolkit.

Já vimos uma classe dessa API, NSObject. Outra interessante é NSString, cuja finalidade é a mesma de std::string de C++ e String de Java.

A criação de uma NSString é:

id url = [NSString stringWithCString: "http://kodumaro.blogspot.com/"];

Há ainda um apelido sintático:

id url = @"http://kodumaro.blogspot.com/";

Um forma legal de conhecer mais sobre OpenStep é ler os manuais de referência do GNUstep (toolkit aqui) e do OS X.

[]'s
Cacilhas, La Batalema

Desenvolvendo aplicações GNUstep

2008-11-07T23:29:00.019-03:00

Sempre fui fascinado pelo NeXTSTEP e gostaria muito tivesse dado certo. Por mais que a Apple negue, seu Mac OS X não é muito mais do que uma versão nova de um NeXTSTEP portado para equipamentos MacIntosh.

Mas não só o OS X herdou os recursos do NeXTSTEP. No começo da década de 1990, em colaboração com a SUN Microsystems a NeXT lançou o OpenStep, uma especificação aberta que define a API para o NeXTSTEP.

Assim ambientes baseados em NeXTSTEP podem rodar em quaisquer sistemas operacionais e aplicações portáteis podem ser criadas.

A Free Software Foundation lançou um projeto de implementação da API OpenStep para sistemas GNU, o GNUstep.

Mais do que uma API de programação, GNUstep é todo um ambiente, desde a API até aplicações e ambiente operacional.

Inicialmente o ambiente gráfico / geranciador de janelas era o AfterStep. Certo dia, na lista de discussão para definir os rumos da versão 2 do AfterStep, um brasileiro chamado Alfredo Kojima sugeriu a reescrita do código do zero.

Enquanto o grupo continuava debadendo, Kojima decidiu iniciar o desenvolvimento da versão 2 do AfterStep, codinome WindowMaker, por conta própria e depois apresentou-o à comunidade. O Window Maker então substituiu o AfterStep como gerenciador de janelas do projeto GNUstep e o AfterStep continuou seu desenvolvimento a parte.

Diversas versões do Window Maker foram lançadas, apesar de nunca ter chegado a uma versão 1.0, um eterno beta – atualmente se encontra na versão 0.92. Porém seu desenvolvimento esfriou gradativamente.

Ano passado o projeto voltou a esquentar e promessas de novas versões estão no ar, o que me inspirou a escrever este artigo.

Consulte o blog do Bardo.

GNUstep

Mas este artigo não é sobre Window Maker, e sim sobre GNUstep.

Para desenvolver aplicações GNUstep, você precisa baixar seu core antes. Acesse a página de recursos, vá ao tópico GNUstep Core e baixe as versões estáveis de cada pacote. Descompacte, compile e instale na ordem em que os pacotes aparecem na tabela (startup, make, base, gui e backend). O core do GNUstep deverá ser instalado em /usr/GNUstep/.

Você precisa acrescentar /usr/GNUstep/System/Tools a seu path de executáveis, /usr/GNUstep/System/Library/Libraries a sua lista de diretórios de bibliotecas – em ambiente GNU/Linux, acrescente esse path ao arquivo /etc/ld.so.conf e execute ldconfig – e crie uma variável de ambiente GNUSTEP_MAKEFILES com o valor /usr/GNUstep/System/Library/Makefiles e outra GNUSTEP_INSTALLATION_DOMAIN com o valor SYSTEM.

Tendo o GNUstep instalado, podemos partir para as ferramentas de desenvolvimento, Gorm e Project Center. Você também encontrará apontadores para as versões estáveis na mesma máquina de recursos, no tópico GNUstep Development Tools.

Criando um projeto

Vamos criar nosso primeiro projeto GNUstep!

Primeiro abrimos o Project Center com o comando:

bash$ openapp ProjectCenter

Vá em Project → New... (ou pressione M-n), vai abrir uma janela de diálogo pedindo o nome do projeto. Selecione o tipo Application e forneça o nome Temperature e clique Ok.

Por enquanto nossa brincadeira com Project Center acaba por aqui. Pode salvar – Project → Save ou M-s – e sair – Quit ou M-q.

Criando uma aplicação

Agora vamos trabalhar no Gorm, execute:

bash$ openapp Gorm

Um segredinho: nas versões anteriores você mandava abrir o Temperature.gorm a partir do Project Center e ele já abria o Gorm para a aplicação atual. Na versão que experimentei – Gorm 1.2.6 e Project Center 0.5.0 – há um bug. O truque é abrir o Gorm a parte e criar uma nova aplicação.

Se quiser testar se está funcionando – em algumas lugares que testei funcionou – para abrir o Gorm, na janela principal do Project Center clique em Interfaces e duplo clique em Temperature.gorm.

No Gorm, crie uma janela e marque como Visible at launch time.

No Gorm então acesse Document → New Application, depois vá em Document → Save As.... Na janela de diálogo encontre seu projeto Temperature, dentro dele Resources e, dentro desse, salve como Temperature.gorm – confirme o Replace.

Vão abrir três janelas: Main Menu, My Window e Temperature.gorm. Se as janelas Palettes e Inspector não estiverem abertas, encontre-as no menu Tools.

Selecione a janela My Window – ela representa a janela principal da aplicação – e veja em Inspector o campo Title contendo My Window – se não estiver vendo, mude o seletor para Attributes. Mude o título para Temperature Converter – repare que o título da janela My Window também mudou.

Repare que na janela Palettes tem alguns widgets. Para acrescentar um widget à janela é só segurar e arrastar (drag'n'drop). Vamos acrescentar três tipos de widget: Text, System Bold e Button. Adicione componentes até ficar mais ou menos com a cara deste corte:

Para mudar o texto de um widget, use o duplo clique. Você também pode mudar a borda no Inspector. Altere os widgets até ficarem mais ou menos assim:

Agora é hora de criar a classe para gerenciar essa janela! Hora de codar? Ainda não…

Na janela Temperature.gorm, na barra principal clique em Classes e selecione NSObject – futuca um pouco que você acha. No menu Operations selecione SubClass. Na lista da direita vai aparecer NewClass e o Inspector vai selecioná-lo – veja a caixa Class com NewClass. Mude o nome da classe para ConverterManager. Apenas confirme na janela Modifying Class.

Podemos agora criar os atributos (outlets) e métodos da classe (actions).

Vamos criar um atributo para cada caixa de texto que criamos – incluside a de Kelvin.

Na janela Inspector há a aba Outlets (0) com o botão Add. Clique nesse botão e teremos NewOutlet com um duplo clique você será capaz de mudar seu nome para degreeC.

Crie mais dois atributos: degreeF e kelvin.

Para criar o primeiro método acesse a aba Actions (0) e siga o mesmo procedimento anterior. Os métodos serão chamados convertC2F: e convertF2C:.

E a classe já está pronta!

Instanciando a classe

Mantendo a classe ConverterManager, no menu principal do Gorm selecione Classes → Instantiate. Na janela Temperature.gorm aparecerá um objeto ConverterManager: é agora que vem parte da mágica…

Precisamos inicialmente ligar o atributo degreeC dessa instância à primeira caixa de texto da janela (ao lado do rótulo °C).

Segure a tecla Ctrl, clique sobre a instância, segure e arraste, solte sobre a caixa de diálogo – vai aparecer um T na caixa –, então, na janela Inspector selecione degreeC e clique no botão Connect. Vai aparecer um S sobre a instância e, na janela Inspector, em Connections, vai aparecer: degreeC (TextField(0)).

Faça o mesmo para as outras caixas ligando cada caixa a um atributo.

Agora precisamos fazer com que os botões acionem métodos da instância, para isso o procedimento é o inverso: segurando a tecla Ctrl clique sobre o botão Celsius to Fahrenheit, segure, arraste e solte sobre a instância de ConverterManager na janela Temperature.gorm.

Na janela Inspector clique em target → convertC2F: e então clique no botão Connect.

Faça o mesmo para conectar o outro botão ao outro método. Agora todas as ações estão conectadas!

Salvando tudo

Na janela Temperature.gorm, selecione Classes e encontre a classe ConverterManager. Selecione-a, então, no menu principal do Gorm clique em Classes → Create Class Files. Apenas confirme as duas janelas de diálogo. Isso criará os dois arquivos ConverterManager.m e ConverterManager.h dentro de Resources.

Agora clique em Document → Save All e Quit.

De volta ao Project Center

Volte ao Project Center e clique em Project → Open... e abra o arquivo PC.project do projeto Temperature.

Na janela principal do projeto dê um duplo clique em Classes e depois em ConverterManager.m, isso adicionará o código ao projeto do Project Center.

Finalmente o código!

Precisamos finalmente editar o conteúdo dos métodos. Duplo clique sobre ConverterManager.m na janela principal e vai abrir a janela do editor:

/* All Rights reserved */

#include <AppKit/AppKit.h>
#include "ConverterManager.h"

@implementation ConverterManager


- (void) convertC2F: (id)sender
{
  /* insert your code here */
}


- (void) convertF2C: (id)sender
{
  /* insert your code here */
}

@end

O código é Objective C, um variante orientado a objetos de C que lembra um pouco Smalltalk.

O método covertC2F deve obter o valor do atributo degreeC – que está ligado à caixa de diálogo com o valor em graus Celsius –, calcular e ajustar os valores em Fahrenreit e Kelvin:

- (void) convertC2F: (id)sender
{
  float celsius = [degreeC floatValue];
  float fahrenreit = (9.0f * celsius / 5.0f) + 32.0f;

  [degreeF setStringValue: [NSString stringWithFormat: @"%1.2f",
    fahrenreit]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

O método convertF2C deve fazer o contrário:

- (void) convertF2C: (id)sender
{
  float fahrenreit = [degreeF floatValue];
  float celsius = 5.0f * (fahrenreit - 32.0f) / 9.0f;

  [degreeC setStringValue: [NSString stringWithFormat: @"%1.2f",
    celsius]];

  [kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
    (celsius + 273.15f)]];
}

Salve agora (M-s) e feche o editor. Clique no ícone com a chave de fenda para compilar:

Na janela de build há outro ícone igual, clique nele para compilar. Se tudo correr bem você verá uma bela mensagem:

=== Build succeeded! ===

Se falhar, volte e veja o que está errado.

Clique então no ícone do foguete para rodar:

Na janela Launch clique no mesmo ícone e a janela irá abrir. Faça alguns testes para ver se funciona bem.

Para sair clique com o botão direito e escolha Quit.

Se tudo funcionar bem, seu programa está pronto! Salve tudo em Project → Save.

Instalando a aplicação

Para instalar, abra um terminal:

bash$ cd Temperature/
bash$ make
bash$ sudo make install

Assim sua aplicação estará instalada em /usr/GNUstep/System/Applications/Temperature.app – ou /usr/GNUstep/Local/Applications/Temperature.app, se você se esqueceu de ajustar o conteúdo da variável de ambiente GNUSTEP_INSTALLATION_DOMAIN – e você executá-la com o comando:

bash$ openapp Temperature

Conclusão

Espero que com este artigo algumas pessoas se interessem pelo desenvolvimento de aplicações para ambiente GNUstep, que aliás roda sobre Mac OS X também – em plataforma OS X, o WINGs (toolkit de widgets para Window Maker) e o GNUstep são abstrações do Cocoa, toolkit de widgets do OS X.

A facilidade de desenvolvimento de aplicações gráficas para GNUstep com Project Center e Gorm é incrível, apesar de seu jeitão esquisito e do uso da tremendamente estranha linguagem de programação Objective C.

[]'s
Cacilhas

PS: Eu já estava morrendo de sono quando escrevi este artigo, portanto alguns erros de português podem ocorrer. Por favor me avisem!

Portando GDBM para Lua

2008-10-16T21:21:00.015-03:00

Espero que este artigo seja interessante. =)

Além de ser um linguagem de programação brasileira, desenvolvida na PUC Rio, Lua possui uma poderosa API com C, na minha opinião, sua maior vantagem.

A outra parte importante deste artigo é GDBM, um conjunto de sub-rotinas de banco de dados baseado em hash, uma alternativa livre ao Unix DBM.

A ideia aqui é demonstrar um pouco dos recursos da biblioteca GDBM e como é simples estender a linguagem Lua.

O objeto

Pessoalmente, quando crio extensões para Lua, gosto de criar primeiro uma classe que represente meu objeto principal, ou uma classe para cada tipo de objeto que será usado nos scripts; depois crio um módulo que porta cada recurso para Lua.

Neste caso vamos criar uma classe GdbmObject que faça a interface com a base de dados, GDBM_FILE.

É claro que poderia ter usado direto GDBM_FILE, aliás comecei fazendo assim, mas acabei voltando ao procedimento que me é natural.

Quanto a objetos datum, não vi necessidade de criar uma interface, já que datum não passa de uma representação mais flexível de string.

O cabeçalho, gdbmobj.h, começa então com as instruções de preprocessamento triviais e a inclusão do cabeçalho gdbm.h, essencial para lidar com GDBM:

#ifndef _GDBMOBJ_H_
#define _GDBMOBJ_H_

#include <gdbm.h>

Podemos então criar a classe e começar os métodos públicos pelo construtor e o destruidor.

O Construtor precisa criar o GDBM_FILE. Para tanto, temos a função gdbm_open, que recebe cinco parâmetros:

o nome do arquivo
o tamanho de blocos para leitura e gravação em bytes (mínimo 512)
o modo de leitura e gravação
as permissões do arquivo, para caso ele seja criado
uma função de callback a ser chamada quando ocorrer um erro fatal

Assim, pelo menos alguns desses parâmetros precisam ser argumentos do construtor. Para simplificar, vamos reduzir: caso o callback seja nulo, é usada uma função padrão. Vamos ficar com ela:

class GdbmObject {
    public:
        GdbmObject(
            const char *name,
            int block=512,
            int mode=GDBM_READER,
            int perm=0644
        );
        ~GdbmObject();

Nosso construtor então recebe os elementos essencias para gdbm_open.

Os outros métodos públicos importantes precisam representar as funções de gdbm.h que queremos acessar, em ordem alfabética: gdbm_close, gdbm_delete, gdbm_exists, gdbm_fetch, gdbm_firstkey, gdbm_nextkey, gdbm_reorganize, gdbm_setopt, gdbm_store e gdbm_sync:

        bool gclose(void);
        bool gdelete(const char *);
        bool gexists(const char *);
        double gfetch_number(const char *);
        const char *gfetch_string(const char *);
        const char *gnext(const char *key=NULL);
        bool greorganize(void);
        bool gsetopt(int, int);
        bool gstore(const char *, const char *);
        bool gstore(const char *, double);
        bool gsync(void);

Agora um método para verificar se a base está fechada um método para retornar a última mensagem de erro:

        bool isclosed(void) const;
        const char *last_error(void) const;

Entrando em território privado, precisamos de dois atributos: um flag que indique se a base está fechada e o GDBM_FILE em si:

    private:
        bool closed;
        GDBM_FILE fd;

Então um método privado para converter datum em string e outro para fazer o gdbm_fetch comum a gfetch_number e gfetch_string:

        static const char *get_string(datum);
        datum gfetch(const char *);
};

#endif /* _GDBMOBJ_H_ */

Código dos métodos

A lógica em si vai no arquivo gdbmobj.cc, que deve iniciar incluindo nosso cabeçalho e o cabeçalho cstring, para que possamos usar strlen nas conversões entre strings e datum.

#include <cstring>
#include "gdbmobj.h"

O código do construtor é simples: basta pegar os argumentos e passá-lo como parâmetro para gdbm_close – não esqueça de ajudar closed como false!

GdbmObject::GdbmObject(
    const char *name, int block, int mode, int perm
): closed(false)
{
    this->fd = gdbm_open(
        const_cast<char *>(name),
        block, mode, perm, NULL
    );
}

O destruidor deve apenas fechar a base, caso esqueçam de fazê-lo:

GdbmObject::~GdbmObject() {
    this>gclose();
}

Precisamos fazer o gclose. Ele deve:

verificar se a base já não está fechada
fechar a base
verificar se não houve erro
marcar o objeto como fechado

bool GdbmObject::gclose(void) {
    if (this->closed)
        return false;

    gdbm_close(this->fd);

    if (gdbm_errno == GDBM_NO_ERROR) {
        this->closed = true;
        return true;
    } else
        return false;
}

Agora o método gdelete: primeiro verificar se já não está fechado – todos os métodos precisam verificar isso –, em seguida converter a chave string em datum – para isso o cabeçalho cstring – e então fazer o que tem de ser feito:

bool GdbmObject::gdelete(const char *key) {
    if (this->close)
        return false;

    datum dkey;
    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);

    gdbm_delete(this->fd, dkey);

    return gdbm_errno == GDBM_NO_ERROR;
}

O próximo método verifica se uma chave existe e funciona similar ao gdelete, só o retorno é que tem um significado diferente:

bool GdbmObject::gexists(const char *key) {
    if (this->close)
        return false;

    datum dkey;
    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);

    return static_cast<bool>(gdbm_exists(this->fd, dkey));
}

Os métodos gfetch_number e gfetch_string devem retornar um valor para uma chave, um retornando double e outro string (const char *), ambos usando o método privado gfetch para obter a chave em formato datum antes:

double GdbmObject::gfetch_number(const char *key) {
    datum data = this->gfetch(key);
    double resp = -1.;

    if (data.dsize == sizeof(double)) {
        double *aux = reinterpret_cast<double *>(data.ptr);
        resp = *aux;
    }

    delete[] data.dptr;
    return resp;
}

const char *GdbmObject::gfetch_string(const char *key) {
    if (this->closed)
        return NULL;

    datum data = this->gfetch(key);
    const char *aux = get_string(data);

    delete[] data.dptr;
    return aux;
}

O método gnext é mais complexo, pois faz interface com gdbm_firstkey (quando a chave for nula) e com gdbm_nextkey.

const char *GdbmObject::gnext(const char *key) {
    if (this->closed)
        return NULL;

    datum next;
    next.dptr = NULL;
    next.dsize = 0;

    if (key == NULL)
        next = gdbm_firstkey(this->fd);

    else {
        datum current;
        current.dptr = const_cast<char *>(key);
        current.dsize = strlen(key);
        next = gdbm_nextkey(this->fd, current);
    }

    if (next.dptr != NULL) {
        const char *aux = get_string(next);

        delete[] next.dptr;
        return aux;
    } else
        return NULL;
}

O método greorganize é similar a gclose:

bool GdbmObject::greorganize(void) {
    if (this->closed)
        return false;

    gdbm_reorganize(this->fd);
    return gdbm_errno == GDBM_NO_ERROR;
}

O método gsetopt precisa tornar transparente algumas peculiaridades de gdbm_setopt:

bool GdbmObject::gsetopt(int option, int value) {
    if (this->closed)
        return false;

    gdbm_setopt(this->fd, option, &value, sizeof(int));
    return gdbm_errno == GDBM_NO_ERROR;
}

Temos dois métodos gstore: um para armazenar números, outro para strings, mas a lógica é a mesma: converter tudo pra datum e usar gdbm_store para armazenar. Vamos usar apenas o flag GDBM_REPLACE:

bool GdbmObject::gstore(const char *key, double value) {
    if (this->closed)
        return false;

    datum dkey, data;

    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);
    data.dptr = reinterpret_cast<char *>(&value);
    data.dsize = sizeof(double);

    gdbm_store(this->fd, dkey, data, GDBM_REPLACE);
    return gdbm_errno == GDBM_NO_ERROR;
}

bool GdbmObject::gstore(const char *key, const char *value) {
    if (this->closed)
        return false;

    datum dkey, data;

    dkey.dptr = const_cast<char *>(key);
    dkey.dsize = strlen(key);
    data.dptr = const_cast<char *>(&value);
    data.dsize = sizeof(double);

    gdbm_store(this->fd, dkey, data, GDBM_REPLACE);
    return gdbm_errno == GDBM_NO_ERROR;
}

O método gsync é quase idêntico a greorganize:

bool GdbmObject::gsync(void) {
    if (this->closed)
        return false;

    gdbm_sync(this->fd);
    return gdbm_errno == GDBM_NO_ERROR;
}

Agora os métodos constantes, isclosed (está fechado) e last_error (último erro):

bool GdbmObject::isclosed(void) const {
    return this->closed;
}

const char *GdbmObject::last_error(void) const {
    if (this->closed)
        return "database closed";

    else
        return const_cast<const char *>(gdbm_strerror(gdbm_errno));
}

O método gfetch faz a verdadeira interface com gdbm_fetch para gfetch_number e gfetch_string:

datum GdbmObject::gfetch(const char *key) {
    datum data;
    data.dptr = NULL;
    data.dsize = 0;

    if (!this->closed) {
        datum dkey;
        dkey.dptr = const_cast<char *>(key);
        dkey.dsize = strlen(key);

        data = gdbm_fetch(this->fd, dkey);
    }

    return data;
}

O método estático get_string precisa converter datum em string:

const char *GdbmObject::get_string(datum data) {
    if (data.dptr == NULL)
        return NULL;

    char *aux = new char[data.dsize + 1];

    for (int i=0; i<data.dsize; ++i)
        aux[i] = data.dptr[i];
    aux[data.dsize] = '\0';

    return const_cast<const char *>(aux);
}

Aqui cabe um comentário para justificar o uso de for em lugar de strcpy:

O ponteiro de datum não é uma string, é um ponteiro para um grupo de bytes – mais ou menos similiar a uma string de Pascal, que tem a vantagem de suportar carácter nulo como parte. Portanto pode não ter um carácter nulo ou ter caracteres nulos dentro do grupo de bytes.

Então a função strcpy não é aplicável.

Que entre a Lua!

Vamos introduzir então a API com Lua, no arquivo luagdbm.cc.

O código precisa começar incluindo o cabeçalho de nossa classe e o cabeçalho de Lua para C++:

#include <lua.hpp>
#include "gdbmobj.h"

Algumas configurações importantes são dados de versão e nome do módulo:

#define VERSION "1.0"
#define MODULE "gdbm"
const char *modulename = MODULE;

Quando Lua carrega uma extensão, chama a função luaopen_nome_da_função, no caso luaopen_gdbm, que deve receber um ponteiro para um estado Lua e deve responder com um inteiro representando a quantidade de elementos empilhados para o estado Lua ao final.

Outra função interessante é set_info, que serve para separar de luaopen_* os dados de diretos, strings e números.

Também vamos criar uma função para empilhar um objeto GdbmObject para o estado Lua:

extern "C" int luaopen_gdbm(lua_State *);
static void set_info(lua_State *);
static void pushdb(lua_State *, GdbmObject *);

Agora vamos declarar uma função para cada método público de GdbmObject – é nossa interface com Lua:

extern "C" {
    static int luagdbm_close(lua_State *);
    static int luagdbm_delete(lua_State *);
    static int luagdbm_exists(lua_State *);
    static int luagdbm_fetch_number(lua_State *);
    static int luagdbm_fetch_string(lua_State *);
    static int luagdbm_isclosed(lua_State *);
    static int luagdbm_next(lua_State *);
    static int luagdbm_open(lua_State *);
    static int luagdbm_reorganize(lua_State *);
    static int luagdbm_setopt(lua_State *);
    static int luagdbm_store(lua_State *);
    static int luagdbm_sync(lua_State *);
}

Podemos implementar cada uma dessas funções.

Função de carregamento

Como já foi dito, a função de carrgamento é luaopen_gdbm.

Ela deve criar um vetor de luaL_reg relacionando cada função com as chaves no módulo em lua, terminando com nulo:

int luaopen_gdbm(lua_State *L) {
    static const luaL_reg gdbm_funcs[] = {
        {"close", luagdbm_close },
        {"delete", luagdbm_delete },
        {"exists", luagdbm_exists },
        {"fetch_number", luagdbm_fetch_number },
        {"fetch_string", luagdbm_fetch_string },
        {"isclosed", luagdbm_isclosed },
        {"next", luagdbm_next },
        {"open", luagdbm_open },
        {"reorganize", luagdbm_reorganize },
        {"setopt", luagdbm_setopt },
        {"store", luagdbm_store },
        {"sync", luagdbm_sync },
        { NULL, NULL }
    };

Então o módulo deve ser registrado com as funções. Para poder usar o módulo como metatabela para os objetos GdbmObject, vamos também criar também a chave __index apontando para o próprio módulo:

    luaLregister(L, modulename, gdbm_funcs);
    lua_pushliteral(L, "__index");
    lua_getglobal(L, modulename);
    lua_settable(L, -3);

Agora só falta chamar set_info e informar que uma estrutura – o módulo – foi empilhada:

    set_info(L);
    return 1;
}

Função para empilhar um objeto de banco de dados

É a função pushdb, que recebe a pilha e um ponteiro para o objeto a ser empilhado.

A função também deve associar ao objeto o próprio módulo como metatabela:

void pushdb(lua_State *L, GdbmObject *db) {
    lua_pushlightuserdata(L, db);
    lua_getglobal(L, modulename);
    lua_setmetatable(L, -2);
}

Vamos deixar set_info para o final…

Funções de interface com os métodos público

Praticamente todas funções devem:

carregar o ponteiro para objeto GdbmObject do estado
verificar se ele ele não está nulo
fazer o que tem de ser feito
retornar o que foi solicitado ou uma mensagem de erro

Repare que todas as funções retornam a quantidade de elementos empilhados (lua_push*).

Assim como começamos pelo método gclose, vamos começar pela função luagdbm_close:

int luagdbm_close(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->gclose()) {
        delete db;
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_delete ainda precisa recuperar a chave a ser deletada:

int luagdbm_delete(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);

    if (db->gdelete(key)) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_exists é similar à anterior, só que mais simples:

int luagdbm_exists(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);

    lua_pushboolean(L, static_cast<int>(db->gexists(key)));
    return 1;
}

As funções luagdbm_fetch_number e luagdbm_fetch_string são similares, só que, assim como os métodos gfetch_number e gfetch_string, retornam número e string:

int luagdbm_fetch_number(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    double value = db->getch_number(key);

    lua_pushnumber(L, value);

    if (value == -1.) {
        lua_pushstring(L, db->last_error());
        return 2;

    } else
        return 1;
}

int luagdbm_fetch_string(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    const char *value = db->getch_string(key);

    if (value == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;

    } else {
        lua_pushstring(L, value);
        return 1;
    }
}

A função luagdbm_isclose é extremamente simples:

int luagdbm_isclosed(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    lua_pushboolean(L, static_cast<int>(db->isclosed()));
    return 1;
}

A função luagdbm_next também não é complicada, apenas é preciso verificar se o parâmetro chave foi fornecido:

int luagdbm_next(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = NULL;
    if (lua_type(L, 2) == LUA_TSTRING)
        key = lua_tostring(L, 2);

    const char *value = db->gnext(key);

    if (value == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;

    } else {
        lua_pushstring(L, value);
        return 1;
    }
}

Vamos deixar a função luagdbm_open, devido a sua complexidade, então passamos direto para luagdbm_reorganize:

int luagdbm_reorganize(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->greorganize()) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A função luagdbm_setopt precisa obter dois inteiros, representando a opção e o valor a ser ajustado:

int luagdbm_setopt(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    int option = static_cast<int>(lua_tonumber(L, 2));
    int value = static_cast<int>(lua_tonumber(L, 3));

    if (db->gsetopt(option, value)) {
        lua_pushboolean(L, 1);
        return 1;
    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

Outra função um pouco mais complicada é luagdbm_store, que deve armazenar um par chave-valor.

A complexidade não está no armazenamento em si, mas na tomada de decisão do tipo da chave, número ou string.

Começamos como as outras funções:

int luagdbm_store(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    const char *key = lua_tostring(L, 2);
    bool resp = false;

Então precisamos decidir se o próximo parâmetro é número ou string e usar uma variável do tipo conveniente:

    switch (lua_type(L, 3)) {
        case LUA_TSTRING: {
            const char *aux = lua_tostring(L, 3);
            resp = db->gstore(key, aux);
            break;
        }

        case LUA_TNUMBER: {
            double aux = lua_tonumber(L, 3);
            resp = db->gstore(key, aux);
            break;
        }

        default:
            lua_pushnil(L);
            lua_pushstring(L, "not compatible data");
            return 2;
    }

Podemos então retornar convenientemente:

    if (resp) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

A última função é luagdbm_sync, que não tem segredos:

int luagdbm_sync(lua_State *L) {
    GdbmObject *db =
        reinterpret_cast<GdbmObject *>(lua_touserdata(L, 1));

    if (db == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "no database");
        return 2;
    }

    if (db->gsync()) {
        lua_pushboolean(L, 1);
        return 1;

    } else {
        lua_pushnil(L);
        lua_pushstring(L, db->last_error());
        return 2;
    }
}

Abertura de uma base de dados

Finalmente chegamos à função luagdbm_open!

Ela é bem complexa, pois pode receber parâmetros diferentes.

Se o parâmetro for string, será considerada como o nome do arquivo de base de dados e para todas as demais configurações são usados os valores por defeito.

Se for uma tabela:

o valor para a chave name representará o nome do arquivo;
o valor para a chave block representará o tamanho do bloco;
o valor para a chave mode representará o modo de leitura e/ou gravação;
o valor para a chave permission representará as permissões para a criação do arquivo.

No entanto, mais de um parâmetros podem ser passados para o modo, como por exemplo GDBM_WRCREAT e GDBM_SYNC. Para esses casos, o valor para a chave mode deve ser uma tabela indexada contendo os modos desejados – e a função precisa estar preparada para processar isso!

A primeira parte da função é carregar os valores por defeito:

int luagdbm_open(lua_State *L) {
    const char *name = NULL;
    int block = 512;
    int mode = GDBM_READER;
    int perm = 0644;

Então precisamos verificar se o parâmetro é string (nome do arquivo, tudo mais ajustado por defeito) ou tabela:

    switch(lua_type(L, 1)) {
        case LUA_TSTRING:
            name = lua_tostring(L, 1);
            break;

        case LUA_TTABLE: {
            lua_getfield(L, 1, "name");

            if (lua_type(L, -1) == LUA_TSTRING) {
                name = lua_tostring(L, -1);

Agora precisamos pegar o valor de block:

                lua_getfield(L, 1, "block");
                if (lua_type(L, -1) == LUA_TNUMBER)
                    block = static_cast<int>(lua_tonumber(L, -1));

Ao trazermos o valor de mode para cima, precisamos ainda verificar seu tipo:

                lua_getfield(L, 1, "mode");
                switch (lua_type(L, -1)) {
                    case LUA_TNUMBER:
                        mode = static_cast<int>(lua_tonumber(L, -1));
                        break;

Agora, caso seja uma tabela, é preciso percorrer seus valores enquantos estes forem números:

                    case LUA_TTABLE: {
                        int i = 1;
                        lua_rawgeti(L, -1, i);
                        mode = 0;
                        while (lua_type(L, -1) == LUA_TNUMBER) {
                            mode |= static_cast<int>(
                                lua_tonumber(L, -1)
                            );
                            lua_pop(L, 1);
                            lua_rawgeti(L, -1, ++i);
                        }

                        mode = (mode == 0) ? GDBM_READER : mode;
                        break;
                    }

Repare que lua_rawgeti(L, -1, i) empilha o i-ésimo elemento da tabela no fim da pilha (-1) e lua_pop(L, 1) desempilha para voltarmos à tabela.

Agora, caso não seja nem número, nem tabela, ignora:

                    default:
                        break;
                }

Obter as permissões é tão simples quanto obter o tamanho do bloco. Aproveitamos e já encerramos o switch o parâmetro ignorando outros tipos:

                lua_getfield(L, 1, "permission");
                if (lua_type(L, -1) == LUA_TNUMBER)
                    perm = static_cast<int>(lua_tonumber(L, -1));
            }

            break;
        }

        default:
            break;
    }

Repare bem em uma coisa: lua_to*(L, 1) retorna o primeiro parâmetro passado à função, lua_to*(L, 2) retorna o segundo parâmetro. lua_to*(L, -1) retorna o último elemento empilhado por lua_push*, lua_getglobal, lua_getfield, lua_rawget, lua_rawgeti ou qualquer outra função da API que empilhe elementos.

Agora é preciso verificar se, após todo esse trabalho, o nome do arquivo foi realmente ajustado:

    if (name == NULL) {
        lua_pushnil(L);
        lua_pushstring(L, "file not supplied");
        return 2;

Finalmente podemos abrir o arquivo de banco de dados e, se tudo correr bem, retorná-lo para o estado Lua – caso contrário, retornar um erro:

    } else {
        GdbmObject *db = new GdbmObject(name, block, mode, perm);

        if (gdbm_errno == GDBM_NO_ERROR) {
            if (db == NULL) {
                lua_pushnil(L);
                lua_pushstring(L,
                    "no error, but no database returned"
                );
                return 2;

            } else {
                pushdb(L, db);
                return 1;
            }
        } else {
            delete db;
            lua_pushnil(L);
            lua_pushstring(L, gdbm_strerror(gdbm_errno));
            return 2;
        }
    }
}

Informações

A função set_info é na verdade a mais chata: primeiro ajusta dados padrão sobre o módulo, depois carrega as constantes usadas pelo GDBM com nomes similares.

É bastante extenso e se não quiser, não precisa ler agora. Está aqui apenas para quem quiser programá-lo.

void set_info(lua_State *L) {
    lua_pushliteral(L, "_COPYRIGHT");
    lua_pushliteral(L, "Copyright (C) 2008 Rodrigo Cacilhas");
    lua_settable(L, -3);
    lua_pushliteral(L, "_DESCRIPTION");
    lua_pushliteral(L, "GDBM interface");
    lua_settable(L, -3);
    lua_pushliteral(L, "_NAME");
    lua_pushliteral(L, MODULE);
    lua_settable(L, -3);
    lua_pushliteral(L, "_VERSION");
    lua_pushliteral(L, VERSION);
    lua_settable(L, -3);

    lua_pushliteral(L, "READER");
    lua_pushnumber(L, GDBM_READER);
    lua_settable(L, -3);
    lua_pushliteral(L, "WRITER");
    lua_pushnumber(L, GDBM_WRITER);
    lua_settable(L, -3);
    lua_pushliteral(L, "WRCREAT");
    lua_pushnumber(L, GDBM_WRCREAT);
    lua_settable(L, -3);
    lua_pushliteral(L, "NEWDB");
    lua_pushnumber(L, GDBM_NEWDB);
    lua_settable(L, -3);
    lua_pushliteral(L, "FAST");
    lua_pushnumber(L, GDBM_FAST);
    lua_settable(L, -3);
    lua_pushliteral(L, "SYNC");
    lua_pushnumber(L, GDBM_SYNC);
    lua_settable(L, -3);
    lua_pushliteral(L, "NOLOCK");
    lua_pushnumber(L, GDBM_NOLOCK);
    lua_settable(L, -3);

    lua_pushliteral(L, "INSERT");
    lua_pushnumber(L, GDBM_INSERT);
    lua_settable(L, -3);
    lua_pushliteral(L, "REPLACE");
    lua_pushnumber(L, GDBM_REPLACE);
    lua_settable(L, -3);


    lua_pushliteral(L, "CACHESIZE");
    lua_pushnumber(L, GDBM_CACHESIZE);
    lua_settable(L, -3);
    lua_pushliteral(L, "FASTMODE");
    lua_pushnumber(L, GDBM_FASTMODE);
    lua_settable(L, -3);
    lua_pushliteral(L, "SYNCMODE");
    lua_pushnumber(L, GDBM_SYNCMODE);
    lua_settable(L, -3);
    lua_pushliteral(L, "CENTFREE");
    lua_pushnumber(L, GDBM_CENTFREE);
    lua_settable(L, -3);
    lua_pushliteral(L, "COALESCEBLKS");
    lua_pushnumber(L, GDBM_COALESCEBLKS);
    lua_settable(L, -3);


    lua_pushliteral(L, "NO_ERROR");
    lua_pushnumber(L, GDBM_NO_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "MALLOC_ERROR");
    lua_pushnumber(L, GDBM_MALLOC_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "BLOCK_SIZE_ERROR");
    lua_pushnumber(L, GDBM_BLOCK_SIZE_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_OPEN_ERROR");
    lua_pushnumber(L, GDBM_FILE_OPEN_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_WRITE_ERROR");
    lua_pushnumber(L, GDBM_FILE_WRITE_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_SEEK_ERROR");
    lua_pushnumber(L, GDBM_FILE_SEEK_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "FILE_READ_ERROR");
    lua_pushnumber(L, GDBM_FILE_READ_ERROR);
    lua_settable(L, -3);
    lua_pushliteral(L, "BAD_MAGIC_NUMBER");
    lua_pushnumber(L, GDBM_BAD_MAGIC_NUMBER);
    lua_settable(L, -3);
    lua_pushliteral(L, "EMPTY_DATABASE");
    lua_pushnumber(L, GDBM_EMPTY_DATABASE);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANT_BE_READER");
    lua_pushnumber(L, GDBM_CANT_BE_READER);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANT_BE_WRITER");
    lua_pushnumber(L, GDBM_CANT_BE_WRITER);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_DELETE");
    lua_pushnumber(L, GDBM_READER_CANT_DELETE);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_STORE");
    lua_pushnumber(L, GDBM_READER_CANT_STORE);
    lua_settable(L, -3);
    lua_pushliteral(L, "READER_CANT_REORGANIZE");
    lua_pushnumber(L, GDBM_READER_CANT_REORGANIZE);
    lua_settable(L, -3);
    lua_pushliteral(L, "UNKNOWN_UPDATE");
    lua_pushnumber(L, GDBM_UNKNOWN_UPDATE);
    lua_settable(L, -3);
    lua_pushliteral(L, "ITEM_NOT_FOUND");
    lua_pushnumber(L, GDBM_ITEM_NOT_FOUND);
    lua_settable(L, -3);
    lua_pushliteral(L, "REORGANIZE_FAILED");
    lua_pushnumber(L, GDBM_REORGANIZE_FAILED);
    lua_settable(L, -3);
    lua_pushliteral(L, "CANNOT_REPLACE");
    lua_pushnumber(L, GDBM_CANNOT_REPLACE);
    lua_settable(L, -3);
    lua_pushliteral(L, "ILLEGAL_DATA");
    lua_pushnumber(L, GDBM_ILLEGAL_DATA);
    lua_settable(L, -3);
    lua_pushliteral(L, "OPT_ALREADY_SET");
    lua_pushnumber(L, GDBM_OPT_ALREADY_SET);
    lua_settable(L, -3);
    lua_pushliteral(L, "OPT_ILLEGAL");
    lua_pushnumber(L, GDBM_OPT_ILLEGAL);
    lua_settable(L, -3);
}

Compilando

Uma forma legal de compilar é através de um arquivo Makefile.

Esse arquivo começa com um comentário informando data e seu criador, e logo em seguida os recursos usados: compilador (CC), link-editor (LD), flags de compilação (CFLAGS) e bibliotecas envolvidas (LIBS), no caso:

# $Id: luagdbm,v 1.0 2008/10/16 23:25:31 cacilhas Exp $

CC ?= c++
LD ?= c++
RM ?= rm -f

CFLAGS ?= 
LIBS ?= -lm -llua -lgdbm -lstdc++

# **********************************************************************

Então os procedimentos de compilação.

O procedimento para compilar os arquivos fontes (*.cc) em objetos (*.o) é:

.cc.o:
    $(CC) -c $< $(CFLAGS) -o $@

Finalmente fazemos a link-edição de tudo na biblioteca compartilhada gdbm.so:

gdbm.so: gdbmobj.o luagdbm.o
    $(LD) -shared $? ($LIBS) -o $@

Agora precisamos informar ao make o que fazer por defeito:

all: gdbm.so

E como limpar a bagunça:

clean:
    $(RM) luagdbm.o
    $(RM) gdbmobj.o

Feito isso já podemos compilar:

bash$ make

Se tudo correu bem, a biblioteca gdbm.so terá sido gerada, se não, verifique os erros e volte corrigindo-os. Caso encontre algum erro neste artigo, por favor informe para que eu possa corrigi-lo!

Fazendo funcionar

Agora mova a biblioteca para um diretório onde Lua possa encontrá-la. Aqui para mim é /usr/lib/lua/5.1/, mas aí para você pode ser qualquer coisa. O conteúdo da variável de ambiente LUA_CPATH pode dar uma dica.

Na ausência dessa variável, entrando no interpretador Lua, a chave package.cpath informa o local correto.

Feito isso, podemos iniciar um interpretador Lua e fazer testes:

bash$ lua
Lua 5.1.3  Copyright (C) 1994-2008 Lua.org, PUC-Rio
> require "gdbm"
> db = assert(gdbm.open { name = "dbtest.db", mode = gdbm.WRCREAT })
> db:store("first", "a")
> db:store("second", "b")
> db:store("thirt", "c")
> db:close()

Saindo do interpretador, você poderá ver o arquivo dbtest.db criado. Vamos reler seu conteúdo:

> db = assert(gdbm.open "dbtest.db")
> k = db:next()
> while k do print(k, db:fetch_string(k)) k = db:next(k) end
first   a
second  b
thirt   c
> db:close()

A ordem de gdbm_next não é necessariamente a ordem de registro.

Conclusão

Acho que este artigo está cheio de informações e é bastante longo, mas se você conseguiu lê-lo até aqui, significa que consegui fazê-lo útil.

Para saber mais, leia a manpage de gdbm e o PiL.

[]'s
Cacilhas, La Batalema

[update 2008-10-23]Valeu pela divulgação no BR-Linux.org, Augusto![/update]

Tcl/Tk

2008-10-15T21:08:00.002-03:00

Uma linguagem de script muito subestimada é Tcl/Tk.

Tcl significa Tool Command Language e foi criada por John Ousterhout para ser uma extensão de C, uma linguagem de agregação de componentes, mais ou menos como o Shell Script.

Tk é uma extensão gráfica para Tcl escrita em C. É um acrónimo para toolkit, nome comumente usado para frameworks gráficos. Em cada plataforma operacional, Tk oferece uma interface homogénia com o sistema de janelas. Outras linguagens também pode acessar a biblioteca Tk – como por exemplo Tkinter.

Tcl e Tk são de código aberto.

Vamos a alguns exemplos:

bash$ tclsh
% puts stdout {Olá Mundo!}
Olá Mundo!

Uma característica fortíssima de Tcl/Tk é que tudo são strings.

Cada token é uma string e strings não precisam de delimitadores, mas aspas (") e chaves ({ e }) podem ser usados como.

No exemplo acima, puts, stdout e {Olá Mundo!} são strings. A primeira string da linha referencia o comando a ser executado, no caso puts «coloca» uma string em um fluxo (stream).

A segunda string (stdout) indica qual o fluxo de saída, no caso a saída padrão.

A terceira string é aquela que será direcionada para a saída selecionada. No caso exibe Olá Mundo! na saída padrão.

Vamos a um exemplo um pouco mais complicado:

puts -nonewline stdout {Informe um número: }
gets stdin num
set dob [expr [set num] * 2]
puts stdout "O dobro é [set dob]"

Como já vimos, puts exibe uma string em uma saída, no caso novamente na saída padrão (stdout). A string -nonewline é um parâmetro que indica a puts para não inserir mudança de linha ao final.

O comando gets recebe uma string de uma entrada – no caso stdin, entrada padrão: o teclado – e a atribui a uma variável referenciada pela última string, num.

O comando set retorna o conteúdo de uma variável, se receber uma terceira string, atribui esta à variável e retorna.

Os colchetes executam o comando interno e tudo é substituído pela string retornada.

O comando expr trata todas as strings como uma expressão matemática, retornando o resultado.

Assim, [set num] retorna o valor da variável num, o expr pega esse valor de num, tratado como um número, e múltiplica por dois (2), retornando.

Daí os colchetes substituem novamente toda a expressão pelo valor retornado, ou seja, uma string representando o dobro do valor de num, então o set mais externo atribui essa valor à variável dob.

No final o último comando exibe na saída padrão a string, substituindo o que estiver entre colchetes. Como set dob retorna o valor de dob, acho que é óbvio o que é exibido.

Só que Tcl/Tk suporta um «apelido» para set, que é o cifrão ($), como em Shell e Perl (não como em PHP):

puts -nonewline stdout {Informe um número: }
gets stdin num
set dob [expr $num * 2]
puts stdout "O dobro é $dob"

Isso deixa o código bem mais limpo. =)

Outras extensões

Há ainda outras linguagens baseadas em Tcl/Tk que valem a pena serem citadas.

A primeira é [incr Tcl], uma variação orientada a objetos.

Outra é TclX (Tcl estendido), que, além de suportar todas os recursos de Tcl/Tk ainda suporta outros similares ao bash, como echo, loop e & (para execução paralela).

Finalizando

Este artigo é apenas um esboço. Outro mais completo pode ser encontrado nas Reflexões de Monte Gasppa e Giulia C..

[]'s
Cacilhas, La Batalema

HTML Unescape em Python

2008-09-24T17:32:00.004-03:00

Toda linguagem tem seus pontos altos e baixos, e suas próprias idiossincracias. Ontem eu esbarrei em algo interessante com relação a biblioteca padrão do Python.

Eu precisava de uma função que fosse mais ou menos equivalente ao html_entity_decode do PHP.

Eu estava usando a biblioteca webhelpers, que tem uma função escape, mas cadê a unescape? Olhando o código, descubro que a webhelpers usa uma função definida em webhelpers.utils, chamada cgi_escape, que seria uma implementação melhor de cgi.escape.

Minhas esperanças então se concentratam no módulo cgi. Mas uma olhada mais atenta me frustrou de novo: temos escape, mas não unescape. Até que um comentário num post do codare que, vejam só a ironia, mostrava como implementar um escape, me trouxe a solução: xml.sax.saxutils.unescape (e sua par, xml.sax.saxutils.escape).

Sei que teria sido muito fácil implementar uma função assim eu mesmo – até mesmo trivial. O ponto é que algo que eu considerava intuitivo e esperava encontrar naquele lugar, se mostrou muito mais difícil de achar do que minha intuição supôs. E eu não gosto de ter minha intuição enganada.

Regressão linear

2008-07-12T18:55:00.006-03:00

Em meu trabalho ora me envolvo em projetos de frontend – aplicações web –, ora me envolvo em projetos de backend. Ora trabalho em projetos de uma frente a outra.

No entanto sou fascinado por problemas conceituais e soluções matemáticas, portanto gosto muito mais de backend do que de frontend.

Em problemas conceituais, uma coisa magnífica é poder prever estados de um sistema por meio de regressão.

Há alguns tipos de regressão: regressão linear, regressão por potência, regressão logarítmica e regressão exponencial, mas todas podem ser reduzidas à regressão linear.

A função da regressão linear é simples:

Ou seja, a ordenada estimada é igual à intercepção (α) mais a inclinação (β) vezes a abscissa. O problema real é calcular α e β.

Há muitas e muitas formas de calcular esses, umas mais simples, outras mais interessantes. =)

Uma forma legal é usando o produto de uma matriz quadrada pelo vetor de coeficientes.

Assim sendo, o primeiro procedimento deve ser montar as matrizes. Hoje vamos trabalhar com Python.

from __future__ import division
__metaclass__ = type

class LinearRegression:
    def __init__(self, pointset):
        # pointset deve ser uma lista de pares x, y
        self.__set = pointset

        self.__createMatrices()
        self.__calculateAlpha()
        self.__calculateBeta()

    def __createMatrices(self):
        s = self.__set

        m11 = len(s)
        m21 = sum([e[0] for e in s])
        m12 = m21
        m22 = sum([e[0] ** 2 for e in s])

        self.__m = [m11, m21, m12, m22]

        self.__rvector = [
            sum([e[1] for e in s]),
            sum ([e[0] * e[1] for e in s])
        ]

Agora é preciso resolver o produto de matriz por vetor. Podemos traduzir isso por meio de determinantes:

Daí:

    def __calculateAlpha(self):
        r = self.__rvector
        m = self.__m

        num = r[0] * m[3] - r[1] * m[2]
        den = m[0] * m[3] - m[1] * m[2]

        self.__alpha = num / den

Também é possível calcular β através de determinantes:

Daí:

    def __calculateBeta(self):
        r = self.__rvector
        m = self.__m

        num = m[0] * r[1] - m[1] * r[0]
        den = m[0] * m[3] - m[1] * m[2]

        self.__beta = num / den

Falta somente agora o método para prever um estado estrapolado:

    def predict(self, x):
        return self.__alpha + (self.__beta * x)

Esta mesma lógica pode ser implementada em outras linguagens. Há ainda outros algoritmos mais simples para calcular regressão linear, mas o apresentado é o mais didático.

[]'s
Cacilhas, La Batalema

Embaralhando palavras

2008-06-29T13:48:00.003-03:00

Outro dia o Walter estava falando sobre um comportamento irregular da implementação de expressões regulares em Python, especificamente o token \b.

Havia uma brincadeira em Ruby com regex que seleciona cada palavra em uma frase e embaralha a ordem das letras, mantendo a primeira e a última em seus lugares.

Para separar as palavras e os elementos de espaçamento entre elas, usava-se uma regex com \b. Resolvi fazer a brincadeira em Smalltalk, mas descobri que o token também não funciona, portanto precisei fazer uma expressão que representasse cada bloco: ((\w+)|(\W+)).

Para reproduzir essa brincadeira, usando Squeak, primeiro usando o System Browser crie um método shaked na categoria copying da classe String:

shaked
    | aux fst i lst temp |

    (self size <= 3) ifTrue: [ ↑ self copy ].

    fst := (self byteAt: 1) asCharacter asString.
    lst := (self byteAt: self size) asCharacter asString.
    aux := self copyFrom: 2 to: self size - 1.
    temp := Array new: aux size factorial.

    i := 0.
    aux permutationsDo: [ :s |
        i := i + 1.
        temp at: i put: (fst, s, lst).
    ].

    ↑ temp at: temp size atRandom.

Agora, em um workspace, execute o seguinte código:

| phr |

" Esta é a frase a ser embaralhada "
phr := 'Kodumaro: as sombras da programação'.

Transcript open.
phr regex: '((\w+)|(\W+))' matchesDo: [ :s |
    Transcript show: s shaked.
].

Transcript cr.

Selecione tudo (M-a) e execute (M-d).

[]'s
Cacilhas, La Batalema

Cálculos estatísticos: polinómio de Lagrange

2008-06-11T23:50:00.015-03:00

Dando sequência aos artigos sobre cálculos estatísticos no Kodumaro – e em outros blogs amigos –, tive a ideia de falar sobre interpolação polinomial.

Por ser um método simples, decidi usar o polinómio de Lagrange:

Não é preciso calcular os coeficientes – é possível simplificar o cálculo final transformando parte do polinómio em um vetor de coeficientes, mas é mais fácil de visualizar sem fazê-lo.

C++

Dessa vez não vou usar C, mas C++, para poder usar recursos de orientação a objetos, como encapsulamento.

Primeiro vamos criar um namespace kodumaro e uma classe Lagrange. Abra o arquivo lagrange.h:

#ifndef LAGRANGE_H_
#define LAGRANGE_H_

namespace kodumaro {
    class Lagrange {
        public:
            Lagrange(const double *, const double *, int);
            ~Lagrange() {}

            double getY(double);

        private:
            const double *vector_x;
            const double *vector_y;
            int           length;
    };
}

#endif /*LAGRANGE_H_*/

O construtor irá receber um vetor de abscissas, um vetor de ordenadas e o tamanho dos vetores. Esses vetores representarão as coordenadas dos pontos a serem interpolados.

O método getY() retornará a ordenada para uma determinada abscissa, de acordo com a interpolação de Lagrange.

Agora o arquivo lagrange.cc contendo a implementação dos métodos:

#include "lagrange.h"

using namespace kodumaro;

Lagrange::Lagrange(const double *vx, const double vy, int len):
    vector_x(vx), vetory(vy), length(len) {}

double Lagrange::getY(double x) {
    double y = 0;

    for (int i = 0; i < length; ++i) { // ciclo do somatório
        double aux = vector_y[i];
        for (int j = 0; j < length; ++j) // ciclo do produtório
            if (i != j)
                aux *= (x - vector_x[j]) / (vector_x[i] - vector_x[j]);
        y += aux;
    }

    return y;
}

E está pronto! Basta incluir lagrange.h e compilar lagrange.cc junto com seu código teste.

O uso é simples:

kodumaro::Lagrange lagr(vx, vy, len);
y = lagr.getY(x);

Common Lisp

Não seria legal fazer isso sem usar uma linguagem funcional. =)

Também vamos aproveitar orientação a objetos – sim! É possível combinar orientação a objetos e programação funcional – para guardar nossos dados.

A classe será similar à de C++, mas o atributo será uma lista de pares de coordenadas:

(defclass lagrange ()
  ((pairs :initarg :pairs :accessor lagrange-pairs)))

Agora o método para calcular a ordenada em relação a uma abscissa:

(defmethod lagrange-get-y ((a-lagrange lagrange) x)
  (reduce '+
    (loop
      for '(xi . yi) in (lagrange-pairs a-lagrange)
      for i from 0
      collect (* yi (reduce '*
        (loop
          for '(xj . yj) in (lagrange-pairs a-lagrange)
          for j from 0
          collect (if (= i j)
            1
            (/ (- x xj) (- xi xj)))))))))

A relação entre esse código e a expressão matemática acima é praticamente 1:1.

O uso é:

(let ((a-lagrange (make-instance 'lagrange :pairs coordinates)))
  (setq y (lagrange-get-y a-lagrange x)))

Smalltalk

Se foi legal usar orientação a objetos numa linguagem onde a orientação foi costurada como em uma colcha de retalhos e em uma linguagem funcional, imaginem em uma linguagem realmente orientada a objetos!

Smalltalk é uma das linguagens mãe da orientação a objetos: criada antes de C a partir de Simula, é praticamente a linguagem que define os conceitos de orientação a objetos.

Como já disse antes, tornei-me fã do Squeak, devido a sua aplicabilidade educacional e ao XO.

No Squeak, abra o System Browser, se não houver um pacote Kodumaro crie-o e, dentro dele, uma categoria Kodumaro-Interpolation.

Na categoria, crie um classe:

PointArray subclass: #Lagrange
    instanceVariableNames = ''
    classVariableNames = ''
    poolDictionaries: ''
    category: 'Kodumaro-Interpolation'

Agora crie o método para calcular a ordenada para uma abscissa:

getY: x
    | y |

    y := 0.
    1 to: self size do: [ :i | | aux |
        aux := (self at: i) y.
        1 to: self size do: [ :j |
            (i ~= j) ifTrue: [
                aux := aux * (
                    (x - (self at: j) x)
                    /
                    ((self at: i) x - (self at: j) x)
                )
            ]
        ].
        y := y + aux.
    ].

    ↑ y

E pronto! Você pode testar instanciando Lagrange – o método new: recebe o tamanho do vetor como parâmetro – e passando a mensagem getY:.

Io

Io é uma linguagem prototipada baseada principalmente em Self e Lua, mas também em outras, como Smalltalk e Lisp.

O código Io pode ser:

Point := Object clone do(
    x := 0
    y := 0
)

Lagrange := List clone do(
    // Gostei da ideia desse método add
    add := method(sx, sy,
        p := Point clone
        p x = sx
        p y = sy
        append(p)
    )

    getY := method(x,
        y := 0
        for(i, 0, size - 1,
            aux := at(i) y
            for(j, 0, size - 1,
                // Havia feito diferente antes,
                // mas acho o if assim mais claro:
                if(i != j) then(
                    aux = aux * ( \
                        (x - at(j) x) \
                        / \
                        (at(i) x - at(j) x) \
                    )
                )
            )
            y = y + aux
        )
        return y
    )
)

Vou dar um exemplo de código pois, devido a ser uma linguagem recente, não há muita documentação.

Digamos que você salvou o código acima no arquivo lagrange.io:

Io> Importer FileImporter import("lagrange")
Io> v := Lagrange clone
Io> v add(1, 10)
Io> v add(2, 100)
Io> v add(3, 1000)
Io> v getY(2)
==> 100
Io> v getY(2.5)
==> 448.75

Conclusão

Bem, desta vez deixo a conclusão ao leitor e convido a quem quiser fazer também suas implementações.

Outro método muito interessante é o polinómio de Newton.

[]'s
Cacilhas, La Batalema

Variância em Smalltalk

2008-06-07T18:44:00.005-03:00

Já que o artigo sobre variância rendeu outro artigo interessante, me empolguei e resolvi escrever como implementar o cálculo da variância em Smalltalk.

Como gostei muito da ferramenta e para privilegiar seu foco educacional, vou usar o Squeak.

Abra o System Browser e, se não tiver o pacote Kodumaro, crie-o. Crie então a categoria Kodumaro-Variance.

Crie então a seguinte classe:

FloatArray subclass: #VariantiableArray
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Kodumaro-Variance'

Agora os métodos…

Na categoria math functions, crie o método rms:

rms
    "Calculates and returns the root mean square"
    | aux |

    aux := 0.
    self do: [ :e |
        aux := aux + (e * e)
    ].

    ↑ (aux / self size) sqrt

É claro que poderíamos criar um método para retornar o numerador do cálculo, mas vou fazer diferente. =)

Vamos implementar a variância populacional com média aritmética – average, herdado de Collection, já que costuma ser um valor mais redondo – e a variância da amostra com média quadrada, ambas também na categoria math functions.

populationalVariance
    "Calculates and returns the populational variance"
    | aux mean |

    aux := 0.
    mean := self average.

    self do: [ :e | | temp |
        temp := e - mean.
        aux := aux + (temp * temp).
    ].

    ↑ aux / self size

Agora a variância amostral:

sampleVariance
    "Calculates and returns the sample variance"
    | aux mean |

    aux := 0.
    mean := self rms.

    self do: [ :e | | temp |
        temp := e - mean.
        aux := aux + (temp * temp).
    ].

    ↑ aux / (self size - 1)

Está pronto!

— Como assim? Só isso?

É, só isso. =)

Vamos testar, abra um Workspace e digite:

| v |

v := VariantiableArray newFrom: #(1 2 3 4 5).

Transcript
    open;
    show: 'Média aritmética: ', v average printString; cr;
    show: 'Média quadrada: ', v rms printString; cr;
    show: 'Variância populacional: ', v populationalVariance printString; cr;
    show: 'Variância da amostra: ', v sampleVariance printString; cr.

Pressione M-a M-d para executar.

[]'s
Cacilhas, La Batalema