Calculadora (Red + GUI) – o mais difícil é saber quando parar.

O Taq postou um twitter (mesmo início do artigo anterior) sobre um manifesto reclamando da dificuldade no desenvolvimento de software e pedindo mais simplicidade. Respondi com um link do Carl Sassenrath que já reclamava em 1997. Interessante ler também a definição de simples. Mais tarde eu olhei alguns aplicativos feitos com Electron que permite um desenvolvimento mais multiplataforma. Vi algumas calculadores.  Algumas poderia baixar apenas para Windows ou Linux e Windows e pouca coisa para Mac. Só uma era PWA e podia usar no Android. Todas com um tamanho monstruoso. Não vi nada de simples. No final de semana, resolvi criar uma para testar. Nada melhor que usar Red para ver a diferença.

Ok. Comecei a desenhar a calculador e incluir os botões para as operações. Me deparei com dois grandes problemas:

  1. Como era muito simples incluir as funções, se eu não parasse, iria ficar uma calculadora com milhares de opções e eu demoraria mais do que o tempo que eu pretendia dispor e,
  2. cada nova função precisava de um novo botão e eu teria que ver onde seria colocado.

Eu gostaria de ter apenas essas preocupações no desenvolvimento dos meus programas. E quem não? Bem, parei, dei uma polida no visual e nas funções e pronto. Desenvolvi no Windows e, como o GTK ainda não está na árvore principal, fui obrigado a entrar no Linux para compilar e testar. Já aproveitei e testei no Raspberry Pi. Não tenho Mac para testar.

Acima o resultado do trabalho. A primeira rodando no Windows, a segunda no Linux, a terceira no RPi e a quarta no RPi via SSH pelo Linux. O fonte ficou com 60 LOC. A geração do executável para Windows ficou com menos de 1M. Para Linux e RPi ficaram com mais de 1M. De qualquer forma, pelo menos 1/30 do tamanho dos executáveis criados pelo Electron. E, exagerando um pouco, o tempo para digitar 60 linhas é o mesmo para instalar o Electron.

Atualmente é necessário clicar para entrar com os números. A próxima atualização será o reconhecimento do teclado para a entrada dos número, ponto decimal, limpar o visor (C) e o excluir último caractere (backspace) A nova versão que está no github já permite a entrada pelo teclado dos números, ponto decimal, as quatro operações, limpar o visor “C” e o último digito “Backspace”. Mas já estou pensando em aumentar as funcionalidades da calculadora.

Ok. Acabei de receber um screenshot do programa rodando no Mac (feita pelo R cqls que está fazendo um excelente trabalho no desenvolvendo o bind para GTK).

 

O código:

Para outras informações e manter-se atualizado:  github

 

 

Red – Fullstack

O Taq postou um twitter sobre os custos da fragmentação das linguagens de programação. Apesar de comum em diversas atividades humanas, o cara tem uma certa razão. O desperdício de tempo de computador, energia elétrica, ideias, etc. é grande. Muitas vezes por nada. Talvez trocar seis por meia dúzia. Atualmente tenho visto uma movimentação em torno de Rust. Os caras estão desenvolvendo até um emacs em Rust. Como se não bastasse as “novas” linguagens disponíveis, temos o problema das plataformas. Linux, Windows, Mac, Android, iOS. Tudo fragmentado.  Aí o cara escolhe electron e baixa a metade do HD para desenvolvimento. O programa ocupa a outra metade. E o cara ainda tem coragem de usar uma camiseta escrita “Save the planet”. Pelos materiais utilizados, temos até coleta especial para lixo eletrônico.

Então eu releio o texto antigo do Carl Sanssenrath e penso…

To me this is all about Personal Computing, not Personal Enslaving. It is about being the masters of our own computers, not the reverse.

Para lutar contra a complexidade do desenvolvimento ele criou REBOL. É, uma linguagem muito avançada para a época. Tipo Smalltalk e seu ambiente gráfico com janelas, menus e mouse para a década de 80.  Acho que continua muito avançada para os dias de hoje (ou para os programadores de hoje). Sendo uma linguagem proprietária e como o desenvolvimento estava estagnado, Nenad Rakocevic, iniciou a criação de Red. Basicamente a mesma linguagem com algumas melhorias como abranger todo o espectro do desenvolvimento indo do baixo nível (C,…), passando por níveis mais elevados (Ruby, Python,…) e indo até a criação de DSLs (a própria linguagem possui diversas).

Eliminando a complexidade

  • Como abrange todos os níveis de programação e a sintaxe é a mesma, não é necessário que alguém programando em Ruby, Python, etc. tenha que aprender C para adicionar uma funcionalidade disponível apenas neste ambiente. Até o final do artigo veremos como.
  • Como permite, sem nada adicional, gerar executáveis para os diversos ambientes (Linux, Windows, Mac, etc..) e sem a necessidade de trocar de ambiente, evita que o programador tenha que ficar trocando de SO para ver se está tudo bem (basta executar o programa em outro SO para ver se está tudo bem).
  • Para a interface gráfica existe o dialeto VID que, com as mesmas linhas de programação gera GUI para os sistemas desejados sem a necessidade de baixar bibliotecas adicionais. Nada impede que se adicione a possibilidade de criar uma TUI usando o curses ou algo do tipo. A linguagem possui diversas DSLs escritas nela mesmo.
  • Tudo o que foi dito apenas baixando aproximadamente 1Mb e sem precisar instalar nada.

Mas vejamos alguns aspectos na prática.

Vamos começar escovando bits e trabalhar diretamente com o sistema operacional. Como uso Linux, deixarei os outros sistemas operacionais de fora pois nem tenho como testar. \mas nada impede de fazer o mesmo com os outros. Vejamos como ficaria para imprimir uma string usando uma chamada direta ao Linux.

Syscall

Red/System []

; definições globais
#define STDOUT     1
#define SYS-write  4
#define SYS-exit   1
#define null-byte  #"^@"

#syscall [
   write: SYS-write [
       fd      [integer!]
       buffer  [c-string!]
       count   [integer!]
       return: [integer!]
   ]
   quit: SYS-exit [
       status  [integer!]
   ]
]

; retorna o tamanho de uma string terminada por zero
length?: func [s [c-string!] return: [integer!] /local i][
    i: 0
    while [s/1 <> null-byte][
        s: s + 1
        i: i + 1
    ]
    return i
]

; imprime uma string
print: func[s [c-string!] return: [integer!]][
    write STDOUT s length? msg
]

; programa
msg: "Hello World^/"
result: print msg
if result > 0 [result: 0]
quit result   

Mesmo sem ter (poder utilizar) os cabeçalhos de C (.h), o programa possui apenas 40 LOC. Algumas definições globais, o protótipo das funções que serão utilizadas e o programa com a mesma sintaxe de Red. O nome da função para retornar o tamanho de uma string podia ser strlen ou size. Foi utilizado lenght? para seguir o que já existe na linguagem e não ter que aprender nada de novo. Para abstrair um pouco mais, foi criada a função print para ficar mais próximo do que já existe. Poderia colocar tudo que vem antes do programa em um arquivo separado e trocar por uma linha como #include syscall.h que nem daria para saber que não é um programa em Red. Procure por uma versão em C para ver como ficaria.

Ok. Agora vamos compilar, usando a chave –no-runtime para não incluir o runtime de red/system (na sequencia veremos mais sobre isso). O resultado é:

# guaracym @ guaracy-pc in ~/red/reds-examples
$ red -c --no-runtime syscall.reds

-=== Red Compiler 0.6.3 ===- 

Compiling /home/guaracym/red/reds-examples/syscall.reds ...

Target: Linux 

Compiling to native code...
...compilation time : 19 ms
...linking time     : 5 ms
...output file size : 624 bytes
...output file      : /home/guaracym/red/reds-examples/syscall 

Pois é. O resultado é um executável com abundantes 624 bytes. E que funciona perfeitamente.

# guaracym @ guaracy-pc in ~/red/reds-examples
$ ./syscall                       
Hello World

Apenas por curiosidade, vamos ver o código gerado.

# guaracym @ guaracy-pc in ~/red/reds-examples
$ objdump -d syscall

syscall:     formato de ficheiro elf32-i386


Desmontagem da secção .text:

0804809c <.text>:
804809c:       ff 35 38 91 04 08       pushl  0x8049138
80480a2:       e8 69 00 00 00          call   0x8048110
80480a7:       a3 4c 91 04 08          mov    %eax,0x804914c
80480ac:       a1 4c 91 04 08          mov    0x804914c,%eax
80480b1:       3d 00 00 00 00          cmp    $0x0,%eax
80480b6:       7e 0f                   jle    0x80480c7
80480b8:       b8 00 00 00 00          mov    $0x0,%eax
80480bd:       c7 05 4c 91 04 08 00    movl   $0x0,0x804914c
80480c4:       00 00 00 
80480c7:       ff 35 4c 91 04 08       pushl  0x804914c
80480cd:       5b                      pop    %ebx
80480ce:       b8 01 00 00 00          mov    $0x1,%eax
80480d3:       cd 80                   int    $0x80
80480d5:       55                      push   %ebp
80480d6:       89 e5                   mov    %esp,%ebp
80480d8:       6a 00                   push   $0x0
80480da:       6a 00                   push   $0x0
80480dc:       83 ec 08                sub    $0x8,%esp
80480df:       b8 00 00 00 00          mov    $0x0,%eax
80480e4:       c7 45 f0 00 00 00 00    movl   $0x0,-0x10(%ebp)
80480eb:       eb 0e                   jmp    0x80480fb
80480ed:       8b 45 08                mov    0x8(%ebp),%eax
80480f0:       40                      inc    %eax
80480f1:       89 45 08                mov    %eax,0x8(%ebp)
80480f4:       8b 45 f0                mov    -0x10(%ebp),%eax
80480f7:       40                      inc    %eax
80480f8:       89 45 f0                mov    %eax,-0x10(%ebp)
80480fb:       8b 75 08                mov    0x8(%ebp),%esi
80480fe:       8a 06                   mov    (%esi),%al
8048100:       3c 00                   cmp    $0x0,%al
8048102:       75 e9                   jne    0x80480ed
8048104:       8b 45 f0                mov    -0x10(%ebp),%eax
8048107:       e9 00 00 00 00          jmp    0x804810c
804810c:       c9                      leave  
804810d:       c2 04 00                ret    $0x4
8048110:       55                      push   %ebp
8048111:       89 e5                   mov    %esp,%ebp
8048113:       6a 00                   push   $0x0
8048115:       6a 00                   push   $0x0
8048117:       6a 01                   push   $0x1
8048119:       ff 75 08                pushl  0x8(%ebp)
804811c:       ff 35 38 91 04 08       pushl  0x8049138
8048122:       e8 ae ff ff ff          call   0x80480d5
8048127:       50                      push   %eax
8048128:       5a                      pop    %edx
8048129:       59                      pop    %ecx
804812a:       5b                      pop    %ebx
804812b:       b8 04 00 00 00          mov    $0x4,%eax
8048130:       cd 80                   int    $0x80
8048132:       c9                      leave  
8048133:       c2 04 00                ret    $0x4

Ok. Encerramos por aqui. Deverá ser utilizado apenas em aplicações específicas e por profissionais qualificados. Não é para o nosso bico. Mas existe a possibilidade.

O nosso nível seria (acho eu), algo em um nível um pouco mais elevado, com o mesmo potencial de C mas um pouco mais bacana. Vamos supor um programa para gerar números aleatórios chamando as funções de uma biblioteca do sistema (no caso do Linux a libc). Ficaria algo assim:

Red/System

Red/System []

#import [
    LIBC-file cdecl [
        rand: "rand" [
            return: [integer!]
        ]
        seed: "srand" [
            seed [integer!]
        ]
        clock: "clock" [
            return: [integer!]
        ]
    ]
]

#define MAX 20

loop 2 [
    seed 1
    print-line ["--> seed 1" ]
    loop 5 [
        print-line rand % MAX
    ]
    seed clock
    print-line ["--> clock" ]
    loop 5 [
        print-line rand % MAX
    ]
]

Para o Linux, LIBC-file é definido como  #define LIBC-file “glibc.so.6” (para o Windows é “msvcrt.dll”). Na definição dos protótipos, eu defini que seed no programa irá chamar srand da biblioteca. Assim é feita a compatibilidade entre os diversos SOs. O programa apenas demonstra que pode ser utilizado clock para inicializar a semente para os números aleatórios. Compilando as 34 LOC, temos:

guaracym @ guaracy-pc in ~/red/reds-examples
$ red -c reds.reds

-=== Red Compiler 0.6.3 ===- 

Compiling /home/guaracym/red/reds-examples/reds.reds ...

Target: Linux 

Compiling to native code...
...compilation time : 381 ms
...linking time     : 14 ms
...output file size : 7096 bytes
...output file      : /home/guaracym/red/reds-examples/reds 

O tamanho do executável ficou em 7096 bytes, o que pode ser considerado bem pequeno para os padrões atuais. O resultado da saída é:

# guaracym @ guaracy-pc in ~/red/reds-examples
$ ./reds          
--> seed 1
3
6
17
15
13
--> clock
18
4
2
3
8
--> seed 1
3
6
17
15
13
--> clock
13
19
12
5
11

Em penúltimo lugar mas não menos importante, temos a linguagem Red propriamente dita. Um programa para ler uma página da internet, extrair o título e imprimir ficaria assim:

Red

Red []

p: read https://example.com
parse p [thru <title> copy t to </title>]
print ["O título da página é: " t]

Como tudo que vem antes de Red [] é considerado comentário, poderíamos ter algo como #!/usr/env red, alterar o atributo do arquivo para executável (chmod +x) e chamar direto como um arquivo de script qualquer. Ou poderemos chamar com red <nome do arquivo>. Poderia passar despercebido mas temos outro detalhe interessante. Foi utilizado parse  que é uma DSL escrita em Red e substitui as  expressões regulares. Continuamos com a mesma sintaxe da linguagem (e mais umas facilidades). Digamos que a leitura da página também é interessante. Nem precisa de baterias.

O resultado é:

# guaracym @ guaracy-pc in ~/red/reds-examples [17:31:04] 
$ red red.red
O título da página é:  Example Domain

Para enviar para um computador que não possua Red instalado(?), podemos gerar um executável e enviar apenas ele para o destino.

# guaracym @ guaracy-pc in ~/red/reds-examples [17:31:14] 
$ red -c red.red

-=== Red Compiler 0.6.3 ===- 

Compiling /home/guaracym/red/reds-examples/red.red ...
...using libRedRT built on 25-Oct-2018/20:29:07
...compilation time : 34 ms

Target: Linux 

Compiling to native code...
...compilation time : 1487 ms
...linking time     : 91 ms
...output file size : 40760 bytes
...output file      : /home/guaracym/red/reds-examples/red 

Aqui vale algumas observações:

  1. O tamanho informado é para desenvolvimento (compilado com -c). Para enviar para outro computador deverá ser compilado com a chave -r (release) e o tamanho ficará em torno de 600Kb ou mais.
  2. Na primeira vez, o tempo para a compilação é maior para gerar uma biblioteca que será utilizada (quase o mesmo com a opção -r).
  3. É possível gerar com a chave -t Windows e enviar diretamente para ser executado em um computador com Windows.

O resultado é o mesmo do chamado pela linha de comando (e nem poderia ser diferente).

# guaracym @ guaracy-pc in ~/red/reds-examples
$ ./red
O título da página é:  Example Domain

Velocidade

Agora vamos juntar o que já foi visto até aqui. Supomos que desejamos um programa que calcule a sequência de Fibonacci de forma recursiva. Sabemos que não é a melhor forma mas suponhamos que e não existe outra. Utilizando uma linguagem que não seja compilada é impraticável para alguns valores mais elevados. Poderíamos utilizar uma biblioteca em uma linguagem compilada e mais rápida ou, podemos escrever em Red e compilar apenas a parte crítica. Ficaria assim:

Red []

;; routine indica a compilação Red/System
fib: routine [n [integer!] return: [integer!]][
    either n < 3
    [1]
    [(fib n - 1) + (fib n - 2)]
]

;; func rotina interpretada
fibt: func [n][
  either n < 3
     [1]
     [(fibt n - 1) + (fibt n - 2)]
]

print fib 40

Quando é encontrada a palavra routine, o interpretador sabe que necessita compilar aquela função. Então o programa não pode ser executado como script o que, na grande maioria dos casos, não deve ser problema nenhum. A maior diferença no programa está no fato de que na rotina compilada é necessário especifica o tipo dos parâmetros ao passo que na interpretada não é necessário. Mas nada impede de termos fibt: func [n [integer!]] onde o parâmetro também seria verificado na chamada e iria gerar um erro antes da execução se fosse chamado com uma string. É possível especificar mais de um tipo aceito pela rotina. Compilamos o programa e o resultado é:

# guaracym @ guaracy-pc in ~/red/reds-examples
$ time ./fib
102334155
./fib  0,83s user 0,00s system 99% cpu 0,834 total

Pareceu bom. Mas vamos testar com um programa em C para ver como fica.

#include<stdio.h>

int fib(int n);

int main() {
  printf("%d\n", fib(40));
}

int fib(int n) {
  if (n<3)
    return 1;
  else
    return ( fib(n-1) + fib(n-2) );
}
# guaracym @ guaracy-pc in ~/red/reds-examples
$ time ./fibc
102334155
./fibc  0,65s user 0,00s system 99% cpu 0,653 total

Ok. O programa em C é mais rápido. Não é desculpa mas Red ainda é uma linguagem alfa (nem RC é) e o código não é otimizado. Acho que o resultado pode ser considerado bom. Independente do estágio da linguagem, vamos comparar com Ruby (só para deixar claro, Red interpretado é mais lento que Ruby)

def fib(n):
    if n==1 or n==2:
        return 1
    return fib(n-1)+fib(n-2)

print (fib(40))
# guaracym @ guaracy-pc in ~/red/reds-examples
$ ruby -v
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]

# guaracym @ guaracy-pc in ~/red/reds-examples
$ time ruby fib.rb
102334155
ruby fib.rb  18,45s user 0,01s system 99% cpu 18,460 total

A diferença no tempo de execução é significativa.

Então era isso. Apesar da abordagem muito superficial, acho que foi possível ter uma ideia da abrangência da linguagem e como tudo fica com uma forma parecida facilitando a vida do desenvolvedor. Não coloquei exemplo de VID pois a parte gráfica para o Linux ainda não está pronta. Basicamente um compilador multiplataforma, um interpretador e, tudo isso, em aproximadamente 1Mb. Nem é possível dizer que vem com as baterias. É mais uma usina.

Voltando ao início do artigo, é uma fragmentação que eu considero muito bem vinda e faço questão de compartilhar. Uma linguagem alfa também pode gerar alguns produtos alfa. Acho que o melhor exemplo é a carteira que está sendo desenvolvida, roda no Windows e Mac e tem só 300Kb sem dependências externas (quase surreal). Se você deseja alguns exemplos de scripts e programas feitos em Red, tem uma página com uma coleção de links. Você pode baixar Red para o seu SO. Só não baixe a versão estável (existe estável de alfa?). Vá até o final e baixe a última versão. Tem mais novidades do que erros.

 

Troquei o Emacs pelo Visual Studio no Linux

Ok, é temporário e é apenas para Red. Mas a história é a seguinte:

Atualmente existe a possibilidade de salientar a sintaxe e mais algumas coisinhas utilizando Red + Emacs. Porém, ainda existe uma certa dificuldade na integração entre os dois o que faz com que o emacs vire um simples (e bem simples) editor de textos como qualquer outro. Opções simples como enviar um bloco ou até mesmo todo o programa para ser interpretado não estão disponíveis.

A plataforma primária dos desenvolvedores de Red é o Windows e eles já fizeram um bom trabalho integrando Red com o Visual Studio, pensei que poderia usar em vez de perder tempo com editores que não uso. Seria possível ajustar o Kate ou algum editor que use o gtksourceview (não gosto do scintilla). Como resolvi testar o Manjaro Budgie para mudar um pouco o visual de tempos usando o KDE (posso dizer que estou gostando), resolvi instalar o Visual Studio.

Apesar de não estar bem familiarizado, é um editor bom, relativamente simples e possui uma boa integração com Red.

captura-de-tela-de-2017-01-18-23-54-29

Red vs Crystal

Vi hoje no Twitter um post do TaQ “An Introduction to Crystal: Fast as C, Slick as Ruby” sobre Crystal. Pelo título fui dar uma olhadinha e achei interessante e, pelos objetivos, achei semelhante a Red (o título pelo menos).

Como conheço mais Red do que Crystal, tentar comparar ambos está mais para presunção do que análise isenta. Então, desculpe qualquer erro nas comparações abaixo, mas resolvi fazer um apanhado de semelhanças e diferenças.

Semelhanças e diferenças (Crystal vs Red)

  • Estágio inicial: Ambas são consideradas beta ou alfa (apesar de ja ser possível fazer muita coisa em Red; acredito que em Crystal também). Red está na versão 0.6.1 e Crystal na versão 0.18.0. Pela abrangência e complexidade de Red, é bem provável que Crystal alcance a versão 1.0 antes de Red.
  • Plataformas: Pelo que vi, Crystal está disponível para Linux e Mac OSX. Atualmente, Red está disponível para Linux, Mac OS X e Windows. Em breve para Android.
  • Instalação: Red não precisa de instalação. É só baixar o executável para a plataforma desejada e executar um script/compilar/usar o REPL.
  • Compatíveis mas não iguais: Red possui a sintaxe parecida com Rebol e Crystal parecida com Ruby. Em algumas situações, Red executa programas feitos em Rebol e Crystal em Ruby. Quem deseja migrar deve estar ciente de que precisará efetuar alterações no código e nada garante que o código funcione sem algum hack.
  • Compilar para código nativo: Com Red, você pode baixar e rodar a versão para Windows e gerar executáveis para qualquer plataforma disponível sem se preocupar com mais nada a não ser a chave -t <plataforma>. É bom deixar claro que Red é composto por duas partes. Red que apresenta grande compatibilidade com Rebol e é de alto nível e Red/System que seria um substituto para o C, compartilhando a mesma sintaxe de Red mas com menos funções. O resultado é que compilando o exemplo da sequência de Fibonacci em Crystal (que está incorreto) o executável ficou com 294K ao passo que em Red/System ficou com 6,4K.  (Crystal foi 0,05s mais rápido que Red). Outro detalhe é que Red pode gerar bibliotecas (.dll, .so, .dylib) que podem ser utilizadas por outras linguagens.
  • Tipagem: Em Crystal, as vezes não é necessário informar o tipo do dado e em outras é (não sei se pode confundir ou não). Em Red não é necessário especificar o tipo de dado mas, se o usuário desejar, poderá especificar para os parâmetros de uma função (pode ser mais de um tipo como integer, string) e assim será gerado erro se um tipo de dado diferente for enviado em vez do erro aparecer apena em tempo de execução. Red/System possui tipagem estática (como pode haver uma interface entre Red e Red/System, existem algumas facilidade para trabalhar com tipos diversos de dados)
  • Interface com bibliotecas: Crystal oferece facilidades para o acesso a bibliotecas escritas em C (não sei se outras linguagens) sem a necessidade de sair da linguagem (escrever um programa em C, por exemplo). Red/System também (e Red por intermédio de Red/System). Como o objetivo de Red/System é ser um “substituto” de C para quem programa em Red, também permite o acesso a syscall (diretamente ao Kernel).
  • Fontes: Ambas linguagens disponibilizam os fontes. Para compilar Crystal você precisa ter Crystal (existem várias linguagens com esta recursividade). Para compilar Red, você precisa ter Rebol (versão comercial). Mas existe a possibilidade de você usar a versão grátis para criar executáveis com os fontes de Red. Ou você pode usar a versão compilada para Windows, Linux e Mac que os desenvolvedores utilizam. Futuramente Red será compilado com Red e a dependência deixará de existir.
  • Espaço armazenamento: Pelo repositório do Arch, diz que eu tenho que baixar 7,5M e, depois de instalado, irá ocupar 57,9M. Para Red eu tenho que baixar 1M do executável e … só. Na realidade, ele cria um arquivo de 500K que é o console (REPL) e uma biblioteca de 10k que são necessários para a execução (considere que em 1M ele já compila para três plataformas diferentes). Não é um item muito relevante mas considerando IoT, pode ser levado em conta (ou se as operadoras limitarem o consumo de dados).

Público alvo

 Bem, qualquer linguagem serve para qualquer um. Vou apenas escrever um pouco para deixar o artigo maior

Crystal

  • Como o ideal não é a compatibilidade com Ruby que tem Rails como carro chefe, certamente não irá abocanhar uma grande parcela de desenvolvedores do Ruby se não for compatível (no artigo diz que não roda Rails).
  • Para outros usuários de Ruby, será necessário analisar com calma o custo/benefício da mudança.
  • Para quem está testando novas(?) linguagens, é uma nova opção para incluir na lista (Go, Rust, Elixir, Red, Crystal, Eve, etc.)

Red Red/System

  • Como Carl Sassenrath encerrou o desenvolvimento de Rebol 2 e disponibilizou os fontes (fora as partes que possuíam copyright) mas largou de mão, muitos ficaram órfãos. O desenvolvimento da versão 3 pela Atronix também data de 2/3 anos atrás. Red pode ser adotado por quem está sem alternativas (e por outros também).
  • Para quem possui um grande leque de aplicações que vão de drives para o SO até aplicativos para rodar no Windows+Mac+Linux+Android (outras opções no futuro como iOS) pode ser uma boa opção.
  • Para quem está de olho na IoT e não quer muita complicação também poderá ser uma opção interessante.
  • Para quem está testando novas linguagens, blá, blá, blá.
Cuidado. O texto abaixo é altamente tendencioso.
O meu interesse por Red é pela descomplicação que ele parece ter (facilidade de passear por diversos SOs sem precisar nem instalar e com 1M), escrevo um programa e gero executável para diversos ambientes, pelo que pode fazer de baixo nível (falar com o Kernel que não é o meu caso) até alto nível (criar DSL ou dialetos como são chamadas em Red), usar GUI nativa dos diversos SOs (atualmente só Windows mas para as próximas versões Android, Mac e Linux/GTK3) e previsões futuras como módulos acopláveis (usar a GPU, por exemplo), meta-DSL (facilidade para a criação de DSLs). Resumindo, parece que os desenvolvedores miraram nas estrelas para alcançar a lua.

Um exemplo que acho legal em Red é o mostrado abaixo. Em poucas linhas é possível criar uma janela, editar um código e ver em tempo real o resultado. Se você tiver curiosidade, basta baixar Red para Windows (é a versão 0.6.2 que está em desenvolvimento e possui o nome de red-latest.exe), baixar o código fonte do relógio que possui 51 linhas contendo o código para criar o ambiente, para criar o relógio e mais 16 linhas que falam sobre o programa. Funciona no wine, bastando tiraro comando transparent da primeira linha. Interessante ler outras informações no site.

blue-clock2
Clock livecoding demo

Vai demorar um bom tempo para Red chegar na versão 1.0. Alguns acham que a versão 0.7 já poderia ser considerada a 1.0 pois possui suporte a parte de I/O. Como não venho de Rebol, olho para o que está considerado para I/O e penso: “Não precisa de tudo aquilo para I/O. Já é possível ler e escrever arquivos, diretórios, posso ler até páginas pelo protocolo http[s]”. Mas se eles dizem …