Não sei exatamente para onde as novas linguagens estão nos levando.
Existem muitos desejos sobre o que uma linguagem de programação deve
ser e fazer.
Um destes desejos é tornar a linguagem de programação mais
declarativa. É dizer o que deve ser feito sem precisar dizer como
fazer. Um exemplo é o SQL, onde se diz qual a consulta se deseja, mas
não é necessário dizer como fazer a consulta.
Isto faz parte do dia-a-dia do programador em vários níveis
diferentes. Por exemplo, quando usamos um vector estamos dizendo que
precisamos de uma lista, sem precisarmos dizer como será feita a
alocação e deslocação dos itens. No entanto, ainda temos o “como
fazer” em mente, pois afinal por que escolhemos um vector ao invés de
um list?
Quanto maior e mais completo o framework que se usa mais declarativo
se torna o programa. No C++ vivemos entre estes dois mundos, e
declarativo e o imperativo aonde dizemos as operações e trocas de
estado das variáveis. São níveis de abstrações sobrepostos.
Algumas pessoas têm grande dificuldade de criar esta camada
declarativa e acabam criando um código que é um aglomerado de
operações. A manutenção deste software é uma engenharia reversa, pois
a lógica do que deve ser feito é perdida.
O C++ evolui de uma forma que a parte imperativa é importante, pois é
uma linguagem aonde se tem pleno controle do código gerado. E a parte
das abstrações é o desafio de tornar o código mais declarativo sem
prejuízo no desempenho. Existe ajuda de todos os lados. Acho que as
linguagens vão progredir na forma declarativa toda vez que for
descoberto uma maneira de gerar o código eficiente para tal declaração
e seja um problema genérico. O LINQ do C# é um exemplo.
Me parece que o Haskell e outras linguagem como F# se encaminham para
criar outras formas de declarações. Este artigo do link foi
interessante por mostrar esta ligação dos conceitos com vários
exemplos no C++.
Apenas como exemplo, recentemente coloquei aqui um link para um
exemplo na minha página (http://www.thradams.com/codeblog/pattern.htm)
aonde é feito um expressão regular de forma declarativa e o código é
gerado automaticamente. Não é a solução ideal de implementação pois
não minimiza estados etc..
Acho que a metaprogramaçào pode evoluir ( e esta evoluindo) de forma
que consigamos fazer o compilador programar por nós.
Mas existe um ponto também em que eu acho que vale mais a pena criar
uma representação separada e fazer um gerador de código. Por exemplo,
acho melhor pegar uma gramática EBNF e gerar um parser do que tentar
fazer isso com metaprogramaçao.
|
