Parrot VM

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

FizzBuzz (No Stairway to Heaven)

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

IDEs em ambiente GNU/Linux

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

Perl6

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 {

E:

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