Mostrando postagens com marcador Smalltalk. Mostrar todas as postagens
Mostrando postagens com marcador Smalltalk. Mostrar todas as postagens

domingo, 11 de abril de 2010

Coleções com Smalltalk

Smalltalk 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

domingo, 4 de abril de 2010

Quem ama BLOXeia!

Smalltalk 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

sábado, 3 de abril de 2010

SUnit

Smalltalk 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

terça-feira, 22 de dezembro de 2009

Seaside

Squeak 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 gurudons 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

terça-feira, 6 de outubro de 2009

IDEs em ambiente GNU/Linux

Poliedro 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:
  1. Editores de texto
  2. IDEs focadas em projeto
  3. RAD


A quem se interessar, boa leitura!

[]'s
Cacilhas, La Batalema

quinta-feira, 20 de novembro de 2008

Base64

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

domingo, 29 de junho de 2008

Embaralhando palavras

Squeak 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

quarta-feira, 11 de junho de 2008

Cálculos estatísticos: polinómio de Lagrange

Paradigma funcional 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:
y=\sum_{i=0}^{n-1}\Big(y_i\prod_{j=0\\j\neq i}^{n-1}\frac{x-x_j}{x_i-x_j}\Big)

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

sábado, 7 de junho de 2008

Variância em Smalltalk

Squeak 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

terça-feira, 3 de junho de 2008

Habilitando XML em Io

VisualWorks É extremamente frustrante instalar Io e descobrir que os recursos de XML não funcionam!

Mas existe solução. ;)

Você vai primeiro no Hick.org e baixa a libsgml – estou usando a versão 1.1.4.

Descompacte, configure e compile:
bash$ tar xzvf libsgml-*.tar.gz
bash$ cd libsgml-*/
bash$ ./configure
bash$ make


Antes de instalar, edite o Makefile, identifique a seguinte linha:
install -m 644 -o root -g root --directory /usr/local/include/sgml


E substitua-a pelo seguinte:
install -o root -g root --directory /usr/local/include/sgml
install -m 644 -o root -g root include/Variant.h \
/usr/local/include/sgml/Variant.h


Não esqueça de respeitar a indentação!

Feito isso, pode instalar:
bash$ sudo make install


Agora recompile e reinstale seu pacote Io.

Para testar:
bash$ io
Io 20080120
Io> SGML
Io> xml := URL with("http://kodumaro.blogspot.com/") fetch asXML
Io> links := xml elementsWithName("a") map(attributes at("href"))
Io> links foreach(link, link println)


Referência: Io Programming Guide.

[]'s
Cacilhas, La Batalema

domingo, 4 de maio de 2008

Magma: persistência de dados no Squeak

Squeak Apesar de eu ter gostado bastante do GNU Smalltalk e sua facilidade em executar scripts, o Squeak é fascinante e tremendamente completo.

A Cincom deveria ficar com vergonha de vender o Visual Works, não porque o Visual Works seja ruim – pelo contrário! É uma senhora ferramenta – mas porque o Squeak dá de dez a zero nele. Aliás até o Eclipse ficaria pra trás do Squeak se não suportasse outras linguagens além de Java.

Você pode encontrar um pouco mais sobre Visual Works na Superfície Reflexiva.

Voltando ao Squeak, que é parte do foco deste artigo, vamos falar agora de persistência de dados.

O Squeak oferece algumas bibliotecas de interface com RDBMS's, como MySQL e PostgreSQL. Mas hoje vamos falar de Magma.

Magma é uma biblioteca de banco de dados multiusuário orientado a objetos. Para instalar Magma, abra o SqueakMap Package Loader e instale os pacotes Magma client e Magma server – a versão que estou usando é 1.0r40.

Magma pode ser usado de duas formas: ¹arquitetura cliente-servidor ou ²em modo monousuário (single-user).

Vamos começar com o modo monousuário, pois é mais simples, depois entender a arquitetura cliente-servidor não vai ser nenhum bicho de sete cabeças – principalmente pra quem já trabalha com RDBMS.

A primeira coisa que precisamos fazer é criar o repositório. Para tanto, crie um diretório em algum lugar, vou criar em /tmp/magmaRepository, depois abra um workspace e digite:
" Create repository "
MagmaRepositoryController
create: '/tmp/magmaRepository'
root: Dictionary new.


Se você estiver usando o Windows e quiser criar o repositório em C:\Magma Repository, pode proceder da mesma forma, basta lembrar de sempre substituir /tmp/magmaRepository pelo path do Windows que você escolheu.

Selecione todo o texto, clique com o botão azul (do meio do mouse) e escolha do it. Quando o Magma terminar de criar o repositório, já podemos fechar o workspace e criar a classe que representará nossa tabela.

Para teste, criei uma classe Person:

No System Browser crie um pacote Kodumaro, nele crie a seguinte classe:
Object subclass: #Person
instanceVariableNames: 'firstname lastname birth'
classVariableNames: ''
poolDictionaries: ''
category: 'Kodumaro'


Crie então os seguintes métodos na classe – não vou entrar em detalhes sobre como fazer isso, é fácil e você pode encontrar no Google:
initialize

firstname := ''.
lastname := ''.
birth := null.


Crie também os métodos acessores:
birth
↑ birth


O sinal ↑ você consegue com ^.
birth: aDate
birth := aDate.

firstname
↑ firstname.

firstname: aName
firstname := aName.

lastname
↑ lastname.

lastname: aName
lastname := aName.

fullname
↑ firstname, ' ', lastname.

[update 2008-05-07]Uma coisa legal é que você não precisa criar diretamente os métodos acessores – getters e setters para a galera do Java –, como fizemos acima.

Você pode clicar com o botão azul sobre a lista de categorias ou sobre a lista de métodos, ir em refactor instance variable → accessors e escolher o atributo, então o Squeak cria os métodos acessores pra você![/update]


E os métodos de exibição:
printString
↑ self fullname, ': ', birth printString.

printOn: aStream
self printString printOn: aStream.


Clique com o botão azul (do meio) sobre as yet unclassified e em seguida em categorize automatically, em seguida mova fullname para accessing.

Já temos então nossa classe Person, podemos povoar a base.

Abra um workspace e digite nele:
| coll mySession user1 user2 user3 |
user1 := Person new
firstname: 'Rodrigo';
lastname: 'Cacilhas';
birth: (Date newDay: 20 month: 11 year: 1975).

user2 := Person new
firstname: 'Walter Rodrigo';
lastname: 'Cruz';
birth: (Date newDay: 8 month: 12 year: 1981).

user3 := Person new
firstname: 'Claudio';
lastname: 'Torcato';
birth: (Date newDay: 13 month: 5 year: 1977).

coll := MagmaCollection new.
coll
add: user1;
add: user2;
add: user3.

mySession := MagmaSession openLocal: '/tmp/magmaRepository'.
mySession connectAs: 'cacilhas'.
mySession commit: [
mySession root
at: 'kodumaro'
put: coll
].
mySession disconnect; closeRepository.


Selecione todo o código, clique o botão azul (do meio), selecione do it, depois limpe o workpace para que possamos reaproveitá-lo.

Abra um Transcript e edite o workspace par fazermos uma consulta:
| mySession |

mySession := MagmaSession openLocal: '/tmp/magmaRepository'.
mySession connectAs: 'cacilhas'.

(mySession root at: 'kodumaro') do: [ :col |
Transcript show: col printString; cr
].

mySession disconnect; closeRepository.


Os objetos na base de dados devem ser exibidos no Transcript.

Modelo cliente-servidor


O modelo cliente-servidor é trivial: levantar servidor, conectar com o cliente, fazer as consultas, desconectar. Quando não for mais usar, pare o servidor.

Para levantar o servidor, no workspace execute:
" Start server "
MagmaServerConsole new
open: '/tmp/magmaRepository';
processOn: 51001;
inspect.


Selecione o código, botão azul (do meio) e do it. Isso iniciará o servidor ouvindo na porta 51001/tcp e abrirá uma janela de inspect para o console do servidor – que poderemos usar para pará-lo.

Abra um workspace – ou reaproveite o que está aberto – para podermos fazer uma conexão cliente – abra também o Transcript, se já não estiver aberto:
| mySession |

mySession := MagmaSession
hostAddress: #(127 0 0 1) asByteArray
port: 51001.

mySession connectAs: 'cacilhas'.

(mySession root at: 'kodumaro') do: [ :col |
Transcript show: col printString; cr
].

mySession disconnect.


Selecione o código, botão azul (do meio) e do it.

Para parar no servidor, no inspect do console digite:
self shutdown


Botão azul (do meio) e do it.


Não que alguém vá trocar – por enquanto – um RDBMS pelo Magma, mas já é algum conhecimento para quando os SGBD's orientados a objetos estiverem mais maduros.

[]'s
Cacilhas, La Batalema

PS: Por favor nenhum comentário sobre ZODB estar bem maduro, já sabemos disso. O Magma é que ainda não está.

sábado, 19 de abril de 2008

Peculiaridades do GNU Smalltalk

VisualWorks Visual Works é uma ótima ferramenta para desenvolvimento de grandes sistemas em Smalltalk, no entanto suas limitações na versão gratuita são extremamente incômodas.

Há algumas boas alternativas ao Visual Works, como Squeak e GNU Smalltalk.

Como sou fã do Projeto GNU, escolhi como substituto GNU Smalltalk.

Mas GNU Smalltalk também tem lá seus inconvenientes, todos contornáveis com a criação de uma nova imagem personalizada, o que pode ser feito na linha de comando ou com a ajuda da ferramenta gráfica Blox.

Também podemos resolver esses «inconvenientes» no próprio código. Por exemplo, cadê a potência (#**)?

[update 2008-06-12]O trouxa aqui não sabia que os números em Smalltalk respondem à mensagem raisedTo:. =P[/update]


Vamos calcular potência de dois em GNU Smalltalk:
#!/bin/sh
"exec" "gst" "-f" "$0" "$@"

Number extend [
** val [
| aux |

aux := 1.
1 to: aux do: [ :i |
aux := aux * self
].
^aux.
]
].


0 to: 10 do: [ :i |
Transcript
show: i printString;
tab;
show: (2 ** i) printString;
cr.
].


Claro, esta não é uma solução definitiva para potência, apenas um quebra-galho.

A mensagem extend estende os recursos de uma classe acrescentando novos métodos, no caso #** (potência).

Vamos agora ao cálculo de números primos…

O método #at:ifAbsent: de Dictionary, quando retorna o valor por defeito, não o retorna diretamente, mas passa a ele a mensagem value, que quase nenhuma classe trata.

Então precisamos estender Object para tratar a mensagem:
#!/bin/sh
"exec" "gst" "-f" "$0" "$@"

Object extend [
value [
^self
]
].

count := 0.
max := 5000.
primeList := Dictionary new.

primeList at: 1 put: false.

2 to: max do: [ :i |
(primeList at: i ifAbsent: true) ifTrue: [
Transcript show: i printString; tab.
count := count + 1.
(i * 2) to: max by: i do: [ :j |
primeList at: j put: false
]
]
].

Transcript
cr;
show: 'Quantidade de primos: ', count printString;
cr.


Conforme for encontrando outras peculiaridades do GNU Smalltalk, vou postando aqui.

[]'s
Cacilhas, La Batalema

sexta-feira, 18 de abril de 2008

Io

Smalltalk Depois de cinquenta e três dias afastado da rede mundial, estou de volta, podendo novamente postar artigos.

Para marcar esta volta, quero falar de uma novíssima linguagem de programação que, apesar ainda estar saindo do forno – não sei sua idade, mas deve ter pouco mais de um ano –, pode vir a se tornar uma escolha viável: Io.

Io é uma linguagem de programação pequena e prototipada. Seus conceitos são inpirados em outras linguagens de programação, como Smalltalk, Self, Lisp, Lua e outras.

É uma linguagem de código aberto – licença BSD –, a máquina virtual é pequena – por volta de 10KB – e roda atualmente em quatro plataformas: Unix-like, Windows, Symbian e Syllable – antigo AtheOS.

Possui uma sintaxe muito semelhante à de Smalltalk e um forte conceito de orientação a objetos.

Em Io, em vez de atributos, propriedades, métodos e variáveis, temos slots. Slot consiste no armazenamento de um objeto dentro de outro, ou seja, cada objeto possui slots contendo outros objetos.

Todas linhas de código são mensagens interceptadas pelo objeto Lobby: a primeira «palavra» é interpretada como o nome de um slot de Lobby. Caso o slot não exista, é gerada uma exceção.

Caso exista, o objetos residente naquele slot é retornado e o resto da mensagem é passada para ele, e assim sucessivamente.

Se o objeto num dos slots for um método, ele será executado e seu retorno será usado para tratar o restante da mensagem.

A atribuição de valor a um slot é feita por =, caso o slot não exista, será gerada uma exceção. Para a criação – e inicialização – de um novo slot, é usado :=.

Não há classes propriamente didas: a «instanciação» é feita por meio de protótipos, ou seja, clonagem de um objeto matriz.

Vamos a um exemplo…

Vamos criar um protótipo Person, que contenha nome, sobrenome e retorne o nome completo:
Person := Object clone
Person firstname := ""
Person lastname := ""
Person birth := Date
Person fullname := method("#{firstname} #{lastname}" interpolate)
Person asString = method(fullname .. ": " .. birth asString("%Y-%m-%d"))


Para «instanciar» um objeto de Person também usamos clone:
cacilhas := Person clone
cacilhas firstname = "Rodrigo"
cacilhas lastname = "Cacilhas"
cacilhas birth = Date fromString("1975-11-20", "%Y-%m-%d")


Ao ser executado:
cacilhas fullname println


Será exibido Rodrigo Cacilhas.
cacilhas println


Agora é exibido Rodrigo Cacilhas: 1975-11-20.

Para obter a data atual:
Date now println


Também é possível obter uma representação numérica da data usando asNumber, que no caso retorna a data em segundos:
Date now asNumber println


Outros slots válidos de Date now são: year (ano), month (mês), day (dia), hour (hora), minute (minuto) e second (segundo).

Pegando apontadores do Google:
SGML
xml := URL with("http://www.google.com/search?q=io+language") fetch asXML
links := xml elementsWithName("a") map(attributes at("href"))


Espero que tenham achado a linguagem tão interessante quanto eu achei e que ela alcance um nível de maturidade que permita sua aplicação extensiva.

[]'s
Cacilhas, La Batalema

terça-feira, 26 de fevereiro de 2008

Primos em Smalltalk

VisualWorks Smalltalk é a linguagem orientada a objetos por excelência.

Desenvolvida na década de 1960, baseada na linguagem Simula, muitos paradigmas modernos foram criados por essa equipe do MIT.

Segue aqui um exemplo aplicado de Smalltalk: busca por números primos.

O algoritmo é baseado no crivo de Aristóstenes, que consiste em, a cada primo encontrado, eliminar seus múltiplos até o fim do conjunto.

Vamos começar declarando as variáveis locais count, com a contagem de primos encontrados, max, que conterá o tamanho do conjunto, e primeList, uma lista – na verdade dicionário – dos números marcados como não-primos:
| count max primeList |

count := 0.
max := 5000.
primeList := Dictionary new.


Começamos então com nenhum primo conhecido (0) e um conjunto de cinco mil (5000) números. Vamos agora informar ao dicionário que 1 não é primo e pedir para limpar o Transcript – área (stream) onde será exibido o resultado:
primeList at: 1 put: false.
Transcript clear.


É preciso agora criar um ciclo (loop) de 2 até o máximo de números do conjunto:
2 to: max do: [ :i |


Para cada i, é preciso verificar se é verdadeiro – se o número não existe na lista (ifAbsent:), ele não é múltiplo de nenhum dos números antecessores, portanto é primo (true):
    (primeList at: i ifAbsent: true) ifTrue: [


Se o número é primo, devemos:
  1. exibi-lo no Transcript;
  2. incrementar o contador;
  3. marcar todos seus múltiplos como não-primos


Fechando os colchetes já abertos, o código fica assim:
        Transcript show: i printString; tab.
count := count + 1.
i * 2 to: max by: i do: [ :j |
primeList at: j put: false
]
]
].


Resta agora somente exibir a contagem:
Transcript
cr;
show: 'Quantidade de primos: ', count printString;
cr.


Repara que, quando várias mensagens são enviada ao mesmo objeto, elas são separadas por ponto-e-vírgula (;).

Alguns comentários:
  • Quando um número recebe a mensagem #printString, ele retorna uma representação string para exibição.
  • Transcript trata a mensagem #tab exibindo uma tabulação e a mensagem #cr exibindo uma mudança de linha.
  • Quando um número recebe a mensagem #to:do:, reitera de forma parecida com for de C.
  • A mensagem #to:by:do: funciona como #to:do:, mas acrescenta o passo.
  • A mensagem #at:put: faz o dicionários associar um par chave-valor ou mudar o valor associado a uma chave.
  • A mensagem #at:ifAbsent: faz o dicionário retornar o valor associado a uma chave, ou um valor padrão.
  • A mensagem #ifTrue: é enviada a um objeto booleano, que executa o bloco de código somente se o objeto for verdadeiro. Outras mensagens similares são: #ifFalse:, #ifTrue:ifFalse: e #ifFalse:ifTrue:.


Bem, espero que esse pequeno tutorial seja de alguma ajuda, se não para o mercado, para expandir conhecimentos.

[]'s
Cacilhas, La Batalema

domingo, 29 de julho de 2007

Orientação a objetos

Orientação a objetos é o paradigma de programação por «simulação», ou seja, em vez de o programador pensar em procedimentos ou funções, ele usa o conceito de objetos, similares aos reais, que interagem entre si.

Cada objeto tem características próprias, executa procedimentos próprios e interage de uma maneira própria. Essa técnica também é chamada «programação antropomórfica» ou «programação por personificação».

Veja que não é necessário uma linguagem ou sintaxe com suporte a orientação a objetos, apenas que o programador seja capaz de pensar orientadamente a objetos. Porém uma linguagem ou sintaxe com suporte próprio ajuda bastante.

Na abordagem tradicional procedimental o foco da programação está nos procedimentos imperativos. Na programação funcional o foco está nas funções, passagem de parâmetros e tratamento de retorno.

Já na orientação a objetos o foco está nos objetos simulados e na interação entre eles.

Por exemplo, no famoso jogo da cobrinha, a cobra seria um objeto com características – tamanho por exemplo – e procedimentos – virar à esquerda, por exemplo. Outros objetos seriam a maça e as paredes.

A própria cobra é composta de secções, que por si são objetos com características – posição – e procedimentos – mudar a posição.

O jogo surge da interação entre os objetos.

As características de um objeto são chamadas atributos e os procedimentos métodos. Algumas linguagens permitem atributos especiais que executam métodos de forma transparente. Esses atributos são chamados propriedades.

Atributos e métodos usados para interagir com outros objetos são chamados interface.

Então orientação a objetos consiste em elaborar objetos similares a coisas físicas, com características próprias e uma interface, de forma a que da interação entre os objetos surja o resultado desejado.

Sintaxe


Não… não é da sintaxe de criação, comandos class e similares que vou falar.

Quero falar de como a sintaxe de uma linguagem deve ser para incitar a orientação a objetos.

Segundo Smalltalk, para uma perfeita orientação a objetos as instruções de um programa devem ser mensagens envidas a objetos.

Para incentivar a orientação a objetos é interessante que o primeiro elemento de uma mensagem seja o objeto chamado.

Por exemplo, fatorial de 5 em Perl (procedimental):
fatorial 5


Em Smalltalk:
5 fatorial


Em Perl, procedimental, é informado um procedimento – fatorial – a ser executado e é passado a esse procedimento o parâmetro 5.

Em Smalltalk, orientada a objetos, é informado um objeto – 5 – ao qual é passada a mensagem, dizendo para ele executar um método internamente.

Observação: em Haskell, linguagem funcional, não imperativa, a sintaxe seria, no caso em questão apenas, idêntica à de Perl, mas a lógica é diferente: é informada uma função matemática que necessita de um parâmetro. Ou seja, é diferente você dizer «execute esse comando» de «o resultado dessa função é».

Sintaxe ou paradigma?


É preciso se perguntar: «estou orientado a objetos ou estou usando uma linguagem que facilita orientação a objetos para programar sequencialmente?»

Não é pela linguagem ser orientada a objetos que o programa será. Também não é pela linguagem não ser orientada que o programa não será.

Programa é a representação de um algoritmo em uma linguagem determinada; se o algoritmo for orientado a objetos o programa também será, mas se o algoritmo não for, não faz diferença se a linguagem em si é ou não.

Aliás, muitos programadores deixam de estruturar por usar uma linguagem orientada a objetos, resultando em programas sequenciais.

Gente, muito cuidado no planejamento. Não confiem na linguagem para fazer tudo pra vocês.


Bem, está aí mais um artigo conceitual.

[]'s
Cacilhas

sábado, 28 de julho de 2007

Smalltalk

VisualWorks Faz tempo que quero escrever algo sobre Smalltalk.

Smalltalk é a linguagem de programação orientada a objetos. O conceito de orientação a objetos foi criado pela equipe que desenvolveu Smalltalk, no MIT durante o final da década de 1960, ainda antes da criação de C. A primeira versão oficial foi Smalltalk-71.

[update 2008-04-19]Pequena correção: o conceito de orientação a objetos foi aprimorado em Smalltalk. A linguagem Simula já era orientada a objetos antes de Smalltalk.[/update]


Em Smalltalk tudo são objetos. Números são objetos, classes são objetos, métodos são objetos, blocos de código, strings, etc., tudo mesmo.

Outros conceitos que leigos acreditam ter sido criados na década de 1990 também proveem de Smalltalk, como bytecode e máquina virtual. É como Smalltalk trabalha.

Para ter Smalltalk instalado, eu uso Cincom VisualWorks.


Este artigo tem por objetivo exibir alguns exemplos.

Vamos então ao famoso «Olá Mundo!»:

Se você também instalou VisualWorks, inicie um novo workspace, digite e execute:
Transcript show: 'Hello World'.
Transcript cr.


Dica: é preciso selecionar o código para executá-lo.

O botão para execução é o raiozinho (Do it).


Os comandos são chamados mensagens e têm o formato:
objeto método[: parâmetros].

Onde os parâmetros são outros objetos passados ao método do objeto que recebe a mensagem.

O objeto Transcript é a janela principal do VisualWorks, que tem o método show (mostrar). Como parâmetro, estamos passando o objeto 'Hello World', uma string.

O método cr de Transcript insere uma mudança de linha.

Chamadas a diversos métodos de um mesmo objeto podem ser concatenadas com ;:
Transcript show: 'Hello World'; cr.


Na verdade não é obrigatório usar o ponto como terminador de mensagem. Ele é apenas um separador de mensagens.

Podemos «picar» a string:
Transcript show: ('Hello World' copyFrom: 2 to: 4).
Transcript cr.


Vai exibir ell: assim como Pascal e Lua, os índices em Smalltalk começam em 1.

Para exibir um número:
Transcript show: (((3 + 5) negated) printString).
Transcript cr.


Vamos agora criar um coleção:
| ord |
ord := SortedCollection new.
ord add: 'Forca de Expressao'.
ord add: 'Monte Gasppa'.
ord add: 'Walter Cruz - devlog'.
Transcript show: (ord at: 1).
Transcript cr.


Ou ainda:
| ord |
ord := SortedCollection new.
ord add: 'Forca de Expressao'.
ord add: 'Monte Gasppa'.
ord add: 'Walter Cruz - devlog'.
ord do: [ :each | Transcript show: each; cr ].


Para exibir todos os número de 1 a 10:
(1 to: 10) do: [ :index |
Transcript show: (index printString); cr
].


Vamos ficar por aqui por enquanto… quando eu estiver mais desenferrujado, escreverei mais alguma coisa.

Apropósito, mais informações podem ser obtidas aqui.

[]'s
Cacilhas