quarta-feira, 29 de outubro de 2014

Extendendo Rebol e GitHub

Resolvi criar um repositório no GiHub para integrar com o blog. Colocarei alguns programas, scripts e outros dados para facilitar os testes (como veremos adiante). Para quem não quer utilizar o Git, foi criada uma página para que todo o repositório possa ser baixado. Basta clicar nos botões para baixar o repositório compactado.

Algumas linguagens possuem uma função que retorna o somatório de uma lista como, por exemplo: sum [1,2,3,4,5,6]. Se não temos, teremos que criar e, se desejarmos, poderemos criar com algumas características especiais. Eu posso querer criar uma função para o somatório e, em algumas ocasiões, desejo saber a média aritmética da lista. Se eu não especificar o tipo de dado, poderei efetuar o somatório de número, datas, horas e outras coisas que possam ser passíveis de serem somadas. Então, vamos lá.

Existem diversas formas de criar uma função em Rebo. Vamos utilizar Funct. A razão é que todas as variáveis criadas internamente serão locais e não influenciarão no restante do ambiente. Vejamos como ficaria:

   1 rebol[
   2     Title: "Somatório de séries."
   3     Date: 28/10/2014
   4     Version: 0.1
   5     Autor: Guaracy
   6 ]
   7 
   8 sum: funct [
   9     "Somatório de séries"
  10     nums [block!]
  11     /average "Retorna apenas a média do somatório da série"
  12     /inject val "Valor para a inicialização do total"
  13 ][
  14     either inject [total: val][total: 0]
  15     foreach n nums [total: total + n]
  16     either average[total / length? nums][total]
  17 ]

Nas linhas de 1 até 6 (poderia ser em uma linha mas dificultaria a legibilidade), temos o cabeçalho que é obrigatório. Poderia ser apenas no formato REBOL [] mas as informações podem auxiliar o programador podendo até verificar se a versão é compatível com seu programa.

O nome pela qual a função será chamada é sum: . O primeiro bloco após funct são as especificações da função. Colocamos uma string com uma descrição da função, o parâmetro nums que deverá ser um bloco ou ocorrerá um erro antes mesmo da função ser executada e dois refinadores. Se ela for chamada com /average, efetuará o somatório, dividirá pelo número de elementos e retorna a média aritmética em vez do somatório. Se /inject for especificado, deverá ser informado um valor que inicializará o total.

A linha 14 temos either que avalia uma expressão e retorna o primeiro bloco se a expressão for verdadeira ou o segundo se for falsa (como um if/then/else em outras linguagens). Se foi especificado /inject, o total será inicializado com o valor informado ou zero se não.

Na linha 15 temos o laço colocar em total a soma dos valores contidos no bloco informado para a função.

Na linha 16 verificamos se o retorno deve ser o total ou a média. O último resultado da função é o valor que será retornado (mas podemos utilizar return x se desejarmos outro valor).

A próxima parte seria integrar a nova função ao ambiente. Como coloquei no GitHub (poderia ser em um servidor da minha empresa ou outro qualquer) para demonstrar a integração com a internet. Basta executar do https://raw.githubusercontent.com/guaracy/rebol/master/extensoes/sum.r3 para que a nova função faça parte do nosso repertório. Poderia também baixar e gravar o arquivo no meu computador e executar do %sum.r3. Mas é necessário fazer isto sempre que executamos o Rebol? Não. É possível termos um arquivo rebol.r no diretório que executamos o Rebol com todas as instruções que desejamos que sejam feitas na inicialização do ambiente. Colocamos o do %sum.r3 no arquivo e sempre podemos contar com a nova função.

Já podemos ver como a nossa função funciona e o motivo das informações na definição da função.

>> help sum
USAGE:
        SUM nums /average /inject val

DESCRIPTION:
        Somatório de séries
        SUM is a function value.

ARGUMENTS:
        nums (block!)

REFINEMENTS:
        /average -- Retorna apenas a média do somatório da série
        /inject
                val -- Valor para a inicialização do total


Podemos utilizar o somatório e/ou média com qualquer valor que faça sentido como números, horas, datas, pares ordenados, etc. Note que não faz sentido a média entre duas datas.

>> sum [1 2 3 4 5]
== 15

>> sum/inject [1 2 3 4 5] 10         
== 25

>> sum/average [1 2 3 4 5]
== 3

>> sum/average/inject [1 2 3 4 5] 10
== 5

>> sum [10:20 10:30 10:00 5:15]
== 36:05

>> sum/average [10:20 10:30 10:00 5:15]
== 9:01:15

>> sum/average/inject [10:20 10:30 10:00 5:15] 5:00
== 10:16:15

>> sum [20/10/2014 10 10 5 2 6]
== 22-Nov-2014

>> sum [20/10/2014 23:25 8:55]              
== 21-Oct-2014/8:20

>> sum [2x3 6 2 3 -1 2x1]
== 14x14

>> sum [20/10/2014 2.5]           
== 22-Oct-2014/12:00

>> sum [2.3 3.5 4.2 12.9] 
== 22.9

sábado, 25 de outubro de 2014

Tipos de dados.

Podemos dizer que Rebol é uma linguagem dinâmica de tipagem forte, isto é, uma palavra (variável) poderá conter qualquer tipo de dado mas as operações não fazem a conversão de tipo automaticamente. Uma instrução do tipo: "nome" + 1 retorna um erro

Quando criamos uma função, é permitido especificar o tipo de cada argumento que ela receberá. Assim, se ela espera um tipo inteiro e recebe um tipo diferente, um erro é informado mesmo antes das operações (mesmo que elas sejam permitidas).

A linguagem possui 58 tipos nativos.

>> ? system/catalog/datatypes

SYSTEM/CATALOG/DATATYPES is a block of value: [end! unset! none! logic! integer! decimal! percent! money! char! pair! tuple! time! date! binary! string! file! email! url! tag! bitset! image! vector! block! paren! path! set-path! get-path! lit-path! map! datatype! typeset! word! set-word! get-word! lit-word! refinement! issue! native! action! routine! rebcode! command! op! closure! function! frame! object! module! error! task! port! gob! event! callback! handle! struct! library! utype!]


Se por um lado são muitos tipos, por outro facilitam bastante a vida do programador e dispensam a criação de funções para trabalhar com formatos específicos bem como podem melhorar a legibilidade do programa. Vejamos, superficialmente, alguns tipos:

logic!

Armazenam valores lógicos e são utilizados em testes condicionais. Os possíveis valores para verdadeiro são true, yes e on e para falso são false, no e off. Permitem uma maior legibilidade ao código.

integer!

Armazenam números inteiros. É importante salientar que a divisão converte o número para decima. Por exemplo, 4 / 2 retorna 0.5. Caso seja necessário um resultado inteiro, devemos efetuar a conversão de tipos: to integer! 2 / 4 retorna 0.

decimal!

Armazenam valores com ponto flutuante. É possível utiliza o ponto ou a virgula para separar a parte inteira da decimal Os valores 123,45 e 123.45 são válidos e representam o mesmo número. Em números longos é possível usar o apostrofo (') para separar as sequências, facilitado a leitura. Então 1'246'487,31 é um número válido. A letra E representa o expoente como em 1,23e10 ou 3,14e-208.

percent!

Utilizado para representar percentual. 7% + 2% = 9%. Convertendo para decimal to-decimal 5% = 0.05. Também está relacionado com legibilidade,

money!

Especifica valores financeiros e devem iniciar com o cifrão ($). No R3 serve apenas para ficar mais bonitinho (pelo menos por enquanto). Nas versões anteriores do Rebol, era possível especificar R$12.23 e US$5.26. O programa não permitia somar os dois valores sem uma conversão.

char!

Informa um único caractere (letra, número ou símbolo). Deve ser seguida pelo símbolo sustenido (#) e o caractere entre aspas. Então #"a" indica o caractere a minúsculo. Existem diversas formas de criar caracteres especiais que não podem ser entrados diretamente pelo teclado. O caractere Esc, por exemplo, pode ser informado como #"^(esc)" ou to-char 27. É possível entrar qualquer caractere informando o seu valor hexadecimal (0000 até FFFF) entre parênteses. #"^(001B)" ou #"^(1B)". É possível algumas operações entre caracteres como somar ou subtrair um número ou outro caractere. Por exempĺo: #"A" + 1 = #"B".

pair!

São pares ordenados (x,y) e também aceitam diversas operações e o acesso de seus valores individuais.  Exemplificando a soma temos: 2x3 + 1 = 3x4 e 2x3 + 3x1 = 5x4. Para acessar individualmente podemos usar first e second para retornar o valor de x e y.

tuple!

Representam versões, endereços de internet e cores no formato RGB. São três ou mais valores numérico positivos entre 0 e 255 separados por ponto. Permitem operações matemáticas e lógicas. Podemos comparar uma versão 1.2.120 > 1.2.2 = true ou 1.2.120 > 1.2.200 = false. Podemos calcular 20% de uma cor fazendo 255.128.128 * 20% = 127.64.64.

time!

Representam tempo no formato hh:mm[:ss[.d]]. Podemos efetuar operações e os ajustes sobre minutos e segundo serão feitos automaticamente. Por exemplo: 10:30 + 2:42 = 13:12 ; 2:40 * 2 = 5:20 ; 0:120:70 - 0:1:2 = 2:00:08.

date!

Representam datas e também permitem operações. Aceita uma variedade de formatos. 3/11/2014 + 80 = 22-Jan-2015 (somamos 80 dias em uma data) ; 1/1/2001 - 1/1/2000 = 366 (número de dias entre duas datas com ano bissexto levado em consideração). Se o valor estiver em uma variável, podemos selecionar apenas o dia ou ano bem como o dia da semana.

binary!

Armazenam dados binários que podem estar na base binária, hexa (default) ou 64. Como exemplos podemos ter: #{45FA100125FA4E7C} (base 16 e é necessário a representação de um byte com os dois dígitos 00-FF), 2#{00001111 11001100 00110011} (base 2 sendo cada byte representado por 8 dígitos) e 64#{A465Eesq} (base 64).

string!

Representam uma série de caracteres. Se estiver em uma linha, pode ser delimitada por aspas (") ou deve ser delimitada por parênteses {} se utilizar mais de uma linha. Pode conter parênteses aninhados desde que o número de aberturas for igual ao número de fechamentos. Assim os parênteses serão considerados como caracteres. Para incluir um parênteses no meio, deve ser precedido por um circunflexo. Por exemplo: "Nome da pessoa", {Nome da pessoa} , {Nome {da} pessoa} e {Nome da^} pessoa} são exemplos válidos.

file!

Contém o nome e ou caminho de um diretório ou arquivo. É precedido pelo símbolo de percentual (%). Por exemplo: %./rebol/teste.r3 informa o arquivo teste.r3 que se encontra no subdiretório rebol ao passo que %teste.r3 informa o nome de um arquivo que se encontra no diretório atual. Além da parte visual que permite a fácil identificação, também permite que o programa trabalhe com caminhos de forma mais transparente (/ no linux e \ no windows). Também permite ler o conteúdo de um arquivo apenas digitando-se read %/caminho/arquivo (sem a necessidade de comandos para abrir ou fechar o arquivo).

email!

Identifica um endereço válido de email. Ainda não está funcionando no R3.

url!

Identifica uma URL (Uniform Resource Locator). Não testei todos e alguns não estão disponíveis, pelo menso por enquanto, na versão R3. Como o http: deve ser o mais utilizado, para ler uma página basta executar read http://www.rebol.com.

tag!

Tags são utilizados em linguagens de marcação (html por exemplo) para o tratamento das informações. Estão entre os sinais de menor (<) e maior (>).

image!

Indica que é uma imagem.Se uma variável possui uma imagem (por exemplo: 
image: load http://kde-look.org/CONTENT/content-files/167376-kdeflames.png) com imagem/size retorna um par informando o número de pixel na verticar e horizontal (e.g. 512x158), pick posição returna uma tupla com informações (RGBA) do pixel e poke posição 255.0.0.0 irá setar o pixel como vermelho.

block!

É um grupo de qualquer coisa delimitado por colchetes [ e ]. Por exemplo, [10 + 20] é um bloco contendo dois inteiros e uma word e pode até ser avaliado retornando 30. Já um bloco [1 2 3 4 5 6] é um bloco contendo seis inteiros. É como um array (mais poderoso) em outras linguagens.

Ok, vamos ficar por aqui. 58 tipos de dados é muita coisa para assimilar em pouco tempo, sem contar que alguns nem podem ser obtidos ou fazem sentido imediatamente. Por exemplo, type? first [nome:] retorna set-word!. Por enquanto, basta saber que nome: 10, irá colocar na palavra nome o valor inteiro 10.

quinta-feira, 23 de outubro de 2014

R3. Atronix? Compilar?

Como já escrevi, estou usando o R3 (REBOL versão 3) da Atronix. Como motivos posso citar:
  1. Assistindo ao vídeo do primeiro artigo, nota-se que é uma empresa séria que não possui apenas um funcionário e não faz programinha de brinquedo.
  2. A primeira versão do sistema foi desenvolvida em Visual Basic (independente de qualquer coisa, já fiz alguns programas comerciais bem interessantes com o VB), depois passaram para Delphi (também já fiz programas comerciais com ele) e depois, analisaram python e ruby entre outros e decidiram desenvolver o sistema em REBOL. E pretendem continuar com a versão 3.
  3. Deslocaram um engenheiro para trabalhar 10h semanais exclusivamente com o desenvolvimento do R3.
  4. O sistema e distribuído aproximadamente 50/50 entre Linux e Windows. Como uso Linux prefiro alguém que tenha um certo compromisso com a plataforma.
A versão oficial é muito engessada pelo Carl e a versão da Saphirion parece deixar o usuário mais curioso sem resposta além de algumas páginas com problema (se vai na parte da R3GUI e tentar acessar faces ou outros retorna uma página incorreta; mas vou dar um desconto pois eles estão em férias).

Olhando o GitHub do R3, é possível verificar que ocorreram atualizações há um dia (pela data de hoje) e, inclusive, no dia 20/10/2014 tem a mensagem "Add an encapper for Windows and Linux..." (veremos o que é encapper depois). Opa, legal, Opa, legal. Vamos clonar o repositório e compilar uma versão atualizada.

Um git clone https://github.com/zsx/r3.git e vamos ver o install (é sempre a primeira coisa a ser feita).

Steps to compile Atronix (http://www.atronixengineering.com) flavor of Rebol 3
0. some directory variables:
 #top points to the top directory of source
1. get libffi compiled and installed
 #cd $(top)/src/libffi
 #./autogen.sh
 #./configure --prefix=`pwd`/../../make/libffi
 #make
 #make install
2. go back to top make directory
 #cd $(top)/make
    #make -f makefile-64 clean #ignore errors it generates
 #make -f makefile-64 r3-view-linux
    #possible makefiles are:
 a. makefile-64 for 64-bit Linux systems
 b. makefile-32 for 32-bit Linux systems
 c. makefile-mingw-32 for cross-compiling for 32-bit windows systems from Linux
    d. makefile-mingw-64 for cross-compileing for 64-bit windows sytems from Linux
 e. makefile-armv7 for ARMv7 linux systems

Notes: only r3-view-linux is tested, i.e. r3-core-linux might not even build

Humm. Apenas o r3-view-linux é testado. É o que quero mesmo, então vamos em frente. Bem, já tenho a libffi mas ali diz para compilar em um sub diretório de make. La vai um git clone git://github.com/atgreen/libffi.git, autogen, etc e tudo termina normal. Primeiro passo ok. Agora é só um

make -f makefile-64 clean e um make -f makefile-64 r3-view-linux. Aguarda e ... erro com libffi. Olhando o r3/make/makefiles/linux-common-defs tinha a linha
INC=... -Ilibffi/lib/libffi-3.1.1 e a biblioteca que baixei era a 3.2. Troquei 3.1.1 por 3.2 e um tudo funcionou perfeitamente.

Bem, fica a dica para que possui Windows e OSX. Como é aberto, se a pessoa tiver conhecimento, paciência e vontade, pode clonar o repositório e tentar compilar para a sua arquitetura. Vai que tenha apenas que trocar um 3.1.1 por um 3.2? 

Na imagem abaixo é possível ver as alterações nos programas.


Agora é só criar uma ligação simbólica em /usr/bin/r3 -> ~/fontes/r3/make/r3-view-linux e usar de qualquer lugar.


Build: 22-Oct-2014/22:13:29. :D


A R3-GUI eu não me preocupei já que a última atualização foi efetuada há 8 meses. Mas pretendo clonar depois.

Ah, sim, o encapper. Basicamente é um programa que junta o compilador e scripts e cria um executável. Abaixo podemos ver um teste.r que imprime algo sendo encapsulado.



A Saphiron possui um que faz o mesmo para android, juntando tudo e criando uma .apk. Aí é só instalar e clicar no ícone para executar. Infelizmente os fontes não estão disponíveis para uso externo.


Agora é aguardar para que um programa em R3 possa ser criado em um Linux x64 (ou qualquer outro SO) e ser gerado executáveis para Linux 34 e 64, Windows 32 e 64, OSX e Android.


terça-feira, 21 de outubro de 2014

REBOL + Android : Configurando um ambiente para desenvolvimento no tablet.

Tenho um tablet Galaxy 10.1 que é utilizado basicamente em viagens. No resto do tempo ele fica bem paradão. Como existe uma versão de REBOL para Android, resolvi configurar um ambiente de desenvolvimento no tablet. Não é necessário nada de especial para a instalação dos programas. É possível configurar no celular mas, como não sou masoquista ...
São quatro programinhas para instalar:
  1. O r3-droid.apk. É necessário baixar e instalar manualmente pois ainda não está disponível no Google Play.
  2. Um teclado para quem pretende programar. O Hacker's Keyboard é uma boa pedida. Basta acessar o link e mandar instalar.
  3. Um editor de texto que possua algumas facilidades para o programador. A minha escolha recaiu sobre o Jota Text Editor. Também é só acessar o link e mandar instalar. Possui uma certa integração com REBOL, desde salientar a sintaxe (não é perfeita mas é melhor que nada e pode ser alterada/melhorada)até abrir o texto por uma aplicação (que pode ser escolhido o R3/Droid).
  4.  Como uso Linux e é mais complicado acessar os arquivos do tablet, uma solução simples seria o WiFi File Transfer que permite a transferência dos arquivos pela rede. Também é só baixar e instalar.
E é tudo. Podem existir outros programas melhores, mas foram as opções gratuitas que eu testei. No tablet, com o novo teclado e a integração do editor é relativamente confortável a criação e execução de programas. Algumas capturas de tela para mostrar como ficou:

A área de trabalho para o desenvolvimento ficou assim.O R3/Droid para testar os programas, o editor, um navegador (algumas páginas salvas na memória para recorrer em caso de dúvida) e um gerenciado de arquivos.




O R3/Droid sendo executado. Mais para testes já que ele aceita apenas uma linha para ser interpretada.




Teclado e o editor com sintaxe salientada (médio mas melhor que nada)


Acessando menu > file ...

temos acesso a opção "Open by Application"



... e podemos utilizar R3/Droid para que o programa sendo digitado seja enviado e executado (interpretado). É claro que optei por "Sempre".Vale constar que é possível criar um atalho Ctrl+R > Open by Application.


Para a tranferências de arquivos entre o table e o desktop. Basta acessar pelo navegador no desktop para ler ou enviar arquivos do tablet.




Não é um desktop mas é um ambiente bem interessante.

segunda-feira, 20 de outubro de 2014

Meu primeiro programa para Linux, Windows e Android.

Apesar do R3 ainda estar em desenvolvimento, resolvi testar a parte gráfica. A ideia foi fazer um programa simples para o cálculo individual do valor a ser pago em um restaurante informando-se o número de pessoas, total da conta e o percentual da gorjeta. Apesar do desenvolvimento ser feito no Linux, o programa deveria rodar no Windows e Android.

O primeiro problema encontrado foi a resolução da tela final. Ficava bom no Linux e razoável no Tablet. Mas muito pequeno no celular. Alguns pequenos cálculos foram suficientes para resolver o problema de forma satisfatória.

O segundo problema foi o modo como o ambiente gráfico era carregado. Estava utilizando load-gui. Funcionava perfeitamente mas, como a instrução pede para carregar o ambiente pela internet, achei que não seria indicado. Se o aparelho estiver desconectado, o comando irá falhar. Optei por baixar o programa r3-gui.r3 (responsável pelo dialeto gráfico) da Saphirion, colocá-lo na mesma pasta do programa e utilizar do %r3-gui.r3. Assim não precisaria de acesso à internet. Rodou bem no Android e no Windows. No Linux estou usando o REBOL da Atronix e o programa apresentou erro. A solução mais simples foi baixar o r3-gui.r3 da Atronix. Aí precisei incluir as linhas 3 até 5 (poderia ser apenas uma linha) para contornar a situação. Não cheguei a testar se o programa da Atronix funciona com o R3 da Saphirion.

O terceiro problema, que é mais uma dificuldade do que um problema propriamente dito, trata-se da execução no Android. Atualmente é necessário executar o REBOL e digitar "do %caminho/programa" para executar. Como estava testando o ambiente para desenvolvimento no tablet (faço outro artigo para explicar como está montado) achava mais fácil abrir o editor, abrir o programa e abrir com aplicativo (o R3 já estava listado). O ideal seria a criação de um .apk para a instalação e execução clicando um ícone. Já é possível criar aplicações para Android com Red, mas fica para outra hora já que o ambiente ainda não está maduro o suficiente para o meu gosto.

O programa ficou maior do que eu pensava. Foram 34 linhas, incluindo as linhas em branco e as três linha para contornar o problema. As linhas 7 e 34 foram para melhorar a aparência nos diversos foramatos de tela (desktop, tablet e celular).




 1 REBOL [Title: "Calculadora de gorjeta"]
 2 
 3 either system/product = 'atronix-view 
 4     [do %r3-gui-a.r3]
 5     [do %r3-gui.r3]
 6 
 7 gui-metric/set 'unit-size (gui-metric 'screen-dpi) / 96
 8 
 9 out: layout [
10     hpanel 2 [
11         text "Qtd. Pessoas" 
12             f-pessoas: field "4"
13             text "Total Conta" 
14             f-conta: field "50"
15             text "Gorjeta"
16             f-gorjeta: field "10"
17             pad
18             button "Calcular" on-action [
19                 pessoas: to-decimal get-face f-pessoas
20                 gorjeta: (to-decimal get-face f-gorjeta) / 100 + 1
21                 conta: to-decimal get-face f-conta
22                 total: round/to (conta * gorjeta) 0.01
23                 individual: round/to (total / pessoas) 0.01
24                 set-face f-total total 
25                 set-face f-individual individual
26             ]
27             text "Total Geral"
28             f-total: field
29             text "Individual"
30         f-individual: field
31     ]
32 ]
33         
34 view/options out [max-hint: round/floor (gui-metric 'work-size) - gui-metric 'title-size]

A aparência ficou assim:

Windows XP (é o único que tenho para testar)


No Linux (Manjaro x64)


No Galaxy S (é velho mas o único que tenho)


No Tablet (Galaxy 10.1). A janela não ocupa toda a tela como no celular mas, como é bem maior, fica perfeitamente legível e fácil de acessar os campos/botão.


Conclusão? Assim até faço alguma coisa para Android, Linux e Windows. ;-)








domingo, 19 de outubro de 2014

Sujando as mãos.

Para começar a brincar com REBOL, temos que baixar o ambiente. Vejamos as opções:
  • Atronix REBOL 3 View Download : Permite baixar versões para Linux (32 e 64 bits), Windows (32 e 64 bits) e Linux (Arm v7) que é bom para o ODROID. Também existem links para baixar os fontes se alguém deseja compilar. Os programas compilados possuem a GUI (não é uma IDE, apenas um dialeto de REBOL chamado VID que permite a criação de janelas, botões, etc., ). O que utilizo foi baixado daqui.
  • Saphirion : Com versões (32bits) para Windows, OSX, Linux e Android.
  • Rebol 3 Binaries (Unofficial) : Os executáveis desta página são compilados diretamente do repositório oficial do REBOL e não possuem GUI. A quantidade de plataformas é bem interessante. Existe ara o Linux x86, OSX x86, Win32 x86, Android ARM, Haiku (inspirado no BeOS), Linux ARMsf, Linux ARMhf, Linux x64 e OSX PPC

Depois de baixar, não é necessário instalar. O REBOL pode ser executado de qualquer lugar. É claro que colocando no path e ajustando algumas variáveis facilita a vida.

Para testes não é necessário um editor já que os comandos podem ser digitados diretamente no console e o resultado é mostrado imediatamente. Como o R3 não permite que o comando seja quebrado em diversas linhas, para fazer algum laço ou coisas mais complexas, utilize o editor de sua preferência. Muitos permitem salientar a sintaxe e outras facilidades.

Considerações iniciais.


- Para sair do ambiente, digite quit e não exit.

- O delimitador é espaço portanto, 2 + 2 retorna 4 mas 2+2 retorna um erro.

- Todo o arquivo que contenha um programa deverá possuir um cabeçalho no início. Podemos, por exemplo, definir uma versão e outros programas poderão acessar posteriormente para diversas finalidades. Por hora podemos ter uma cabeçalho simples como: REBOL [Title: "Título do script"]

- Para obtermos informações sobre funções, um bom local é o REBOL Quick Reference Card. Se estivermos no ambiente interativo do console, podemos obter informações sobre qualquer função digitando help <função> (o help pode ser substituído por ? ).Se digitamos >> help loop (o >> é o prompt e não é digitado) obtemos:

USAGE:
        LOOP count block

DESCRIPTION:
        Evaluates a block a specified number of times.
        LOOP is a native value.

ARGUMENTS:
        count -- Number of repetitions (number!)
        block -- Block to evaluate (block!)

Então, o uso de LOOP requer dois parâmetros. Um count que é o número de repetições e um block que é um bloco (já veremos) que será executado em cada repetição.


- Blocos são delimitados por colchetes [ e ] e podem conter dados e/ou código e/ou outros blocos. Uma linha do tipo loop 5 [print 3] irá imprimir o número três cinco vezes.

- Apesar de variável ser um termo que não corresponde a realidade em REBOL, podemos definir uma variável escrevendo seu nome seguido de dois pontos e sem espaço. Por exemplo, lista: [1 2 3 4 5] poderia significar que atribuímos uma array unidemensional a uma variável lista. Mas está mais para dizer que a palavra lista está associaida a um bloco contendo dados numéricos de 1 a 5.

Ficamos por aqui hoje. Depois tem mais. Um pequeno código (poderia ser escrito em uma linha) para ler uma determinada página e extrair todos os links:


1 parse to-string read http://www.rebol.com [
2     any [thru "A HREF=" copy link to ">" (print link)] to end]
3 

Sim, não é preciso baixar ou instalar nada no ambiente para executar a tarefa. Tudo foi feito pelo parse e read. A função read pode ler dados de um arquivo, porta ou url. Se o arquivo for um diretório, retorna uma lista com todos os arquivos e sub-diretórios existentes. Como REBOL não trabalha com ER, parse é a resposta em REBOL para expressões regulares. Com tal, sua explicação seria suficiente para um livro.

Informações sobre read:

USAGE:
        READ source /part length /seek index /string /lines

DESCRIPTION:
        Read from a file, URL, or other port.
        READ is an action value.

ARGUMENTS:
        source (port! file! url! block!)

REFINEMENTS:
        /part -- Partial read a given number of units (source relative)
                length (number!)
        /seek -- Read from a specific position (source relative)
                index (number!)
        /string -- Convert UTF and line terminators to standard text string
        /lines -- Convert to block of strings (implies /string)

Informações sobre parse (para maiores detalhes sobre rules, melhor acessar a página do parse). Pessoalmente acha mais legível (alguns acham mais poderoso mas não vou entrar no mérito) que trabalhar com ER, apesar da maior verbosidade.

USAGE:
        PARSE input rules /all /case

DESCRIPTION:
        Parses a string or block series according to grammar rules.
        PARSE is a native value.

ARGUMENTS:
        input -- Input series to parse (series!)
        rules -- Rules to parse by (none = ",;") (block! string! char! none!)

REFINEMENTS:
        /all -- For simple rules (not blocks) parse all chars including whitespace
        /case -- Uses case-sensitive comparison


sexta-feira, 17 de outubro de 2014

Início

Resolvi aprender um pouco mais sobre REBOL e decidi deixar registrado pois poderá servir como referência para o futuro. Para mim ou qualquer outro que desejar.

- Mas é de comer? É parente do COBOL? SNOBOL?

Não! É uma linguagem de programação (REBOL = Relative Expression Based Object Language) multiplataforma, multiparadigma desenvolvida por Carl Sassenrath.É interpretada, concisa, de fácil aprendizado e muito boa para a criação de DSLs.

- Mas eu não conheço. Ninguém deve utilizar.

Tem muita coisa que pessoas utilizam e eu também não conheço. Mas vamos contar um pouco da história para facilitar. Inicialmente, era uma linguagem comercial, isto é, para usar seria necessário pagar. Pelo menos uma parte dela que era mais indicada para o desenvolvimento de aplicativos comerciais. Surgiram algumas variantes de código aberto como Boron, Topaz e Red. Como aspectos interessantes de Red, temos o fato de que ela poderá ser compilada ou interpretada em diversas plataformas. E está sendo desenvolvida utilizando REBOL, isto é, o REBOL compila um código em REBOL para diversas plataformas. No mínimo, interessante.

Com o desenvolvimento de REBOL 3 (terceira versão), o Carl resolveu abrir o código da linguagem. Mas as coisas andam muito lentamente por lá e o acesso é meio restrito. Com isto, algumas empresas que já utilizavam REBOL, resolveram trabalhar na nova versão (R3) e já lançaram suas versões baseadas no código aberto com diversas atualizações. Uma das empresas é a Shaphirion e a outra a Atronix. No vídeo abaixo é possível ver melhor o trabalho da Atronix e a utilização de REBOL.



No decorrer dos artigos, pretendo colocar alguns exemplos em Python, Ruby, etc. ao lado de REBOL. Não é para dizer: "VIram como REBOL é melhor!". Apenas para uma comparação mais visual. onde o leitor poderá ter uma noção de como se faz algo em uma ou outra linguagem. Todas as linguagens possuem seus pontos fortes e fracos. Como pontos fortes do REBOL posso citar:
  • facilidade de aprendizado;
  • não é necessário ser administrador/root para instalar e usar;
  • com aproximadamente 0,7M você tem uma linguagem muito poderosa;
  • você poderá executar seus programas no Windows, Linux, Mac, Android e onde mais a linguagem estiver disponivel;
  • vem com pilhas e carregador incluídos. ;-)

Ok, mas não podemos encerrar sem deixar um pequeno exemplo. Não aquele "hello world" sem graça.



print "Bem vindo!"
sorteado: to-string random 100
until [
    chute: ask "Chute: "
    case [
        chute > sorteado [print "Alto" false]
        chute < sorteado [print "Baixo" false]
        true [print "Você venceu!"]]]
print ["Fim de jogo!"]

O que o programa faz é selecionar um número qualquer entre 1 e 100 e esperar que o usuário digite o número correto. Se o número informado for maior que o sorteado, o programa informa Alto. Se o número for menor será informado Baixo. O programa é semelhante em muitas linguagens mas, como características do REBOL, temos a ausência de delimitadores. O espaço é o delimitador. O único delimitador são os colchetes [ e ] que são utilizados para delimitar um bloco (pode ser dados ou código). Uma lista teria o seguinte formato:

lista: [1 2 3 4 5]

Como observação final, eu fechei os três colchetes em uma única linha. É o modo como se fecha em lisp (não em REBOL geralmente). Mas eu gosto mais por ficar com uma aparência de Python (que eu não programo).


E assim termina o primeiro dia.