Sempre que leio qualquer coisa feita pelo Iam Piumarta fico impressionado. Outro dia ao ler os slides sobre o progresso do grupo dele para construir uma linguagem que seja uma real evolução ao que temos hoje, me dei conta de como aquilo que eles propõem é radicalmente diferente ao que a prática de que estamos habituados.
A atenção excessiva na meta-recursividade do sistema, assim como ser trivial criar e integrar novas gramáticas a linguagem, me faz pensar qual seria o limite de duas propriedade com emergence como essas. O efeito imediato é no compilador, que tem suporte direto a PEGs e pattern matching.
O compilador é capaz de se adaptar a mudanças nas regras de sintaxe e passar a usá-las instantaneamente apos serem definidas, ou seja, você pode definir uma mini linguagem em 5-10 linhas e usá-la logo em seguida. Não só isso, mas elas possuem escopo e podem operar em apenas um bloco de texto do seu fonte. Junta isso ao fato de que PEGs poderem ser compostas facilmente e o compilador suportar staged compilation que o resultado é ter uma linguagem que é maleável ao extremo.
A outra é a máquina virtual, que é construída com essa nova linguagem, de forma que ela mesmo siga o modelo de protótipos e delegação na sua implementação. Isso permite que ela seja tão flexível e dinâmica quanto suas aplicações. Essa é, de longe, a característica mais interessante, pois nenhuma linguagem baseada e máquina virtual que eu conheço chega a esse ponto.
Mas quais seriam aplicações reais disso? Aquilo que hoje fazemos com frameworks e bibliotecas, poderíamos fazer com DSLs. Então em vez de aprender um enorme framework que precisa seguir às regras da linguagem, bastaria aprender uma pequena nova linguagem. Da mesma forma, muita coisa que hoje se traduz em referencia direta ao código de bibliotecas, poderia ser feito como uma série de modificações à gramática corrente.
Porém eu acho que é possível ir muito mais além, com uma VM flexível, seria possível ajustar o modelo de execução para melhor realizar a tarefa que o programa deseja. Como, por exemplo, introduzir processos leves ao estilo do Erlang simplesmente incluindo uma biblioteca.
Quem ainda não se ligou o que gente como Ian Piumarta e Alan Kay tem feito no Viewpoints Research Institute deve parar um pouco e se dedicar àquilo que um dia poderia ser o próximo passo na evolução da computação.
7 responses so far ↓
1 Thiago Silva // Jun 14, 2008 at 9:25 am
Se vc gostou dos slides, recomendo ver o vídeo da palestra enquanto lê eles ;)
A propósito, eu não acho que o trabalho deles envolve, particularmente, VMs.
[]’s
Thiago
2 kumpera // Jun 16, 2008 at 9:02 pm
Thiago,
Boa parte daquilo que o Piumarta fala é sobre como construir um runtime para aquilo que estão pesquisando, basta ver quando ele fala de geração de código, e um core dinâmico. Não tem como pensar em implementar o que eles sugerem sem uma VM.
A chave é quando ele fala de um kernel auto-descritivo e meta-recursivo. (Seria essa a tradução?) Isso implica em construir o runtime com a própria linguagem alvo.
Implementações meta-recursivas são sempre muito interessantes de se estudar. Mesmo dando muitas vezes mais trabalho até conseguir fazer full bootstrap
3 Thiago Silva // Jun 16, 2008 at 11:35 pm
@kumpera: “Não tem como pensar em implementar o que eles sugerem sem uma VM.”
Por que não? Extraído do “Making COLAs with Pepsi and Coke” [1]:
“Providing a dynamic execution model, for which both dynamic and static code can be generated, eliminates the need for a central interpreter - or VM-like agent, and ensures that everything (including the deepest ‘kernel’ behaviour) can be modified, dynamically, on-the-fly.”
e, na conclusão:
“VM - or interpreter - based systems are little better; whereas the compiler is often available to the user, the interpreter rigidly defines both bytecodes (or some equivalent executable representation) thus preventing semantic exploration, and primitives thereby limiting pragmatic extensions. An alternative is to create a virtual execution environment implemented entirely in (one of) the dynamic, late-bound language(s) that it implements.”
Mas, por curiosidade, por que acha isso?
[1] http://piumarta.com/software/cola/colas-whitepaper.pdf
abs
4 Tiago Albineli Motta // Jun 17, 2008 at 11:53 am
Hum a própria definição da mini-linguagem não seria uma VM para esta?
5 kumpera // Jun 17, 2008 at 12:21 pm
Thiago, fui pego pelas palavras aqui.
O ambiente de execução é baseado em máquinas virtuais, porém não usa propriamente uma. Uma vez que a VM é escrita na mesma linguagem da aplicação e está aberta as mesmas operações sobre forma e função, a barreira entre elas some e a máquina virtual característica de hoje se dissolve e some no meio dos objetos da aplicação.
Dizer ou não que o ambiente usa uma máquina virtual é uma questão de gosto, eu diria. Pois no fundo Coke roda em cima de um ambiente gerenciado típico de máquinas virtuais: GC, carga e transformação dinâmica de código, ambiente fortemente tipado com introspecção e por ai vai.
6 Thiago Silva // Jun 17, 2008 at 1:08 pm
Ah, esclarecido :)
Agora, eu me pergunto se (ou “como”) eles colocariam o GC exposto ao usuário como se fosse qualquer outro objeto…
7 kumpera // Jun 19, 2008 at 11:26 am
Thiago, implementar um GC em uma linguagem gerenciada é perfeitamente factivel, o MMtk é prova disso.
Basta prover acesso ao modelo de objetos e acesso de baixo nível a memória.
Porém permitir que ele seja modificado em tempo de execução não seria muito simples, mas facilitar a exploração é perfeitamente possível.
Leave a Comment