Em que você deseja que os designers de idiomas prestem atenção? [fechadas]

O objetivo desta pergunta não é montar uma lista completa de recursos da linguagem de programação que você não pode viver sem, ou gostaria que estivesse na sua principal linguagem de escolha. O objetivo desta pergunta é trazer à luz os cantos do design de linguagem que a maioria dos designers de idiomas talvez não considere. Então, em vez de pensar no recurso de linguagem X, pense um pouco mais filisoficamente.

Um dos meus preconceitos, e talvez possa ser controverso, é que o lado mais suave da engenharia - os porquês e o que prega - são muitas vezes mais importantes que o lado mais concreto. Por exemplo, Ruby foi projetado com um objetivo declarado de melhorar a felicidade do desenvolvedor. Embora suas opiniões possam ser confusas, seja ou não entregue, o fato de ser uma meta significa que algumas das opções no design da linguagem foram influenciadas por essa filosofia.

Por favor, não poste:

• Guerras de chama de sintaxe. Vamos ser sinceros, temos nossas preferências e a sintaxe é importante no que diz respeito ao design da linguagem. Eu só quero evitar batalhas épicas da natureza do emacs vs. VI (sobre as quais um grande número de pessoas hoje em dia não sabe nada).
• "Qualquer idioma que não tenha o recurso X não merece existir" comenta o tipo. Há pelo menos um motivo para todas as linguagens de programação existirem - boas ou ruins.

Por favor , poste:

• Idéias filosóficas que os designers de linguagem parecem sentir falta.
• Conceitos técnicos que parecem ser mal implementados com mais frequência do que não. Por favor, forneça um exemplo da dor que ela causa e se você tem alguma idéia de como você prefere que ela funcione.
• O que você deseja estava na biblioteca comum da plataforma, mas raramente o é. Da mesma forma, as coisas que geralmente estão em uma biblioteca comum que você deseja não estavam.
• Recursos conceituais, como suporte interno para tratamento de teste / asserção / contrato / erro, que você deseja que todas as linguagens de programação implementem corretamente - e definam corretamente.

Minha esperança é que este seja um tópico divertido e estimulante.

Edit: Esclarecido o que quero dizer com Syntax Flame Wars. Não estou tentando evitar toda discussão sobre sintaxe, principalmente porque a sintaxe é uma parte fundamental do design da linguagem de programa.

Suporte Unicode por padrão

Atualmente, os programas estão sendo desenvolvidos para serem utilizados internacionalmente ou sob a suposição de que possam ser utilizados internacionalmente. Eles devem fornecer suporte para seus conjuntos de caracteres ou tornar inúteis os programas escritos nesse idioma.

Eu tenho um par:

• Genéricos / modelos. Por exemplo, os genéricos Java são poderosos, mas não necessariamente flexíveis. Além disso, como eles usam apagamento de tipo, tenho visto problemas para implementá-los de maneira abstrata, especialmente em interfaces. E o compilador não deve avisar quando um genérico não específico é usado (como em Hashmapvez de Hashmap<String, int>). Eu acho que eles poderiam ser melhorados significativamente. Um bom modelo é muito útil, mas muitas vezes negligenciado.

• Bom suporte de data na biblioteca padrão. Quero dizer, poder adicionar e subtrair datas, horas e minutos, e não precisar lidar com o número de milissegundos desde 1º de janeiro de 1970.

Por favor, faça seu idioma analisável / auditável para pessoas de segurança de computadores.

O pessoal de segurança precisa encontrar vulnerabilidades em um programa antes de ele ser lançado. Idealmente, somos chamados no início e podemos comentar a base de código à medida que ela se desenvolve, mas geralmente não.

Quando uma nova versão da linguagem ou das bibliotecas principais é lançada, as coisas anteriormente seguras podem não ser mais:

1. bibliotecas podem se tornar mais poderosas: por exemplo, a biblioteca de URL agora suporta javascript:
2. pode haver novas maneiras de converter seqüências de caracteres ou bytes em código: por exemplo, evalou bibliotecas de desserialização
3. técnicas de reflexão de linguagem podem se tornar mais poderosas: por exemplo, expor variáveis ​​locais

Qualquer uma dessas alterações pode aumentar a quantidade de autoridade abusiva que um programa possui, mas como a quantidade de autoridade que o programa usa (ao lidar com clientes não maliciosos) não mudou, o pessoal da segurança é pressionado a descobrir isso sem uma intensa re-auditar.

Portanto, pense em nós ao projetar e fazer o versionamento da linguagem. Abaixo estão algumas dicas:

Defina algumas primitivas em que um programa pode ser decomposto.

O HTML5 é particularmente ruim dessa maneira. Obviamente, eles pensaram muito em segurança e têm pessoas muito inteligentes, mas, em vez de especificar novos elementos do programa, como <video>em termos de antigos, ou criar uma abstração comum na qual novos <video>e antigos <img>podem ser especificados em termos de, <video>ainda é outro elemento do programa pontual com suas próprias conseqüências de segurança.

Torne seu idioma passível de análise estática (mesmo se não for digitado estaticamente).

O pessoal da segurança costuma usar a análise estática para encontrar padrões e tentar descartar partes de um programa para que possam se concentrar nos bits realmente complicados.

Deveria ser óbvio quais identificadores são variáveis ​​locais e quais não são.

Por exemplo, não cometa o mesmo erro das versões antigas do JavaScript, o que impossibilitou dizer se xé uma referência de variável local a seguir (de acordo com uma leitura literal de uma versão antiga da especificação):

if (Math.random() > 0.5) {
  Object.prototype.x = 0;
}

function f() {
  var x = 1;
  (function () {
    alert(x);  // Might alert 0, might alert 1.
  })();
}

Permitir segurança decomponível

Muitos sistemas seguros são projetados em torno de um kernel seguro que preserva as propriedades de segurança, para que os profissionais de segurança possam concentrar seus esforços na análise de uma pequena quantidade de código e liberando a maioria dos programadores de lidar com pessoas de segurança {irritantes, pedantes e paranóicas} .

Deveria ser possível escrever um kernel no seu idioma. Se uma das propriedades de segurança do seu idioma é que apenas um determinado subconjunto de URLs será buscado, os criadores do kernel podem fazer algo para canalizar todas as URLs que buscam pelo código? Ou as verificações de construção estática (como observar as importações) podem ter a mesma função.

Algumas linguagens como o Newspeak usam um modelo de recursos de objetos. Isso é incrível e é uma ótima maneira de obter segurança decomponível.

Mas se você não puder fazer isso, tornar o gráfico do módulo um artefato estaticamente analisável pode lhe trazer um grande benefício. Se eu puder provar que um módulo não pode alcançar o módulo de E / S de arquivo (exceto chamando o código em um módulo no TCB), então posso descartar classes inteiras de problemas desse módulo.

Limitar a autoridade das linguagens de script incorporadas

Muitos sistemas úteis são organizados como um núcleo estático que inicia muito código escrito em linguagens dinâmicas (até funcionais).

E a incorporação de linguagens de script pode tornar um sistema muito mais extensível.

Mas uma linguagem de script não deve ter a autoridade total da VM.

Se você optar por permitir linguagens de script incorporadas, facilite ao invocador limitar o que ele pode fazer. Um modelo de recursos de objetos (veja o comentário no Newspeak acima) é muito apropriado aqui; portanto, ao avaliar o código em uma linguagem de script, o chamador deve passar o código para executar e todas as variáveis ​​globais para esse código.

Tratar evalcomo uma linguagem incorporada a si mesma como uma linguagem de script

Se o seu idioma puder invocar seu próprio compilador para transformar uma cadeia de caracteres em código, permita que ela seja colocada na área de proteção da mesma maneira que faria com qualquer linguagem de script incorporada.

Use um modelo de simultaneidade simples

Nós, pessoal de segurança, não gostamos de nos preocupar com as condições da corrida ao tentar descobrir se uma propriedade de segurança é mantida.

Por favor, considere alternativas ao encadeamento antes de instalar os encadeamentos como uma opção padrão quase impossível de proteger.

Uma simples é a simultaneidade de loop de eventos como a encontrada em E, Verilog e JavaScript.

Não incentive citando confusão

Alguns idiomas são colados e acabam lidando com strings em vários idiomas diferentes.

Por exemplo, o JavaScript geralmente compõe cadeias de caracteres de HTML, CSS, XML, JSON e até JavaScript. É muito difícil para os programadores lembrarem-se de codificar corretamente as strings de texto sem formatação ao combiná-las para criar strings em outras linguagens; assim, os programas JS, sem surpresa, têm todo tipo de citação de problemas de confusão: o XSS é o pior.

Se você deseja incluir recursos de composição de cadeias, tente reduzir a carga de segurança do programador. DSLs, macros higiênicas e linguagens de modelagem incorporadas podem ser uma ótima maneira de fazer isso, movendo o ônus de escapar adequadamente para os desenvolvedores de bibliotecas ou idiomas e para longe do desenvolvedor final.

Algumas das melhores línguas foram projetadas por pessoas que queriam criar uma língua para si mesmas.

Então, acho que os designers de linguagem devem prestar menos atenção aos seus usuários. Você não pode agradar a todos, nem deve tentar.

Apenas 5 a 10% do tempo é gasto realmente escrevendo código. Os designers de idiomas devem prestar atenção às dificuldades de realmente fazer o software funcionar, o que significa corrigir erros e bugs.

Isso significa que deve haver desde o início um bom depurador. Não é uma ferramenta com sintaxe arcana e comandos de chave que é apenas um pouco melhor do que toneladas de instruções de impressão.

Eu acho que eles devem prestar atenção ao Python, que faz mais coisas certas do que qualquer outra linguagem que eu encontrei (e que, mesmo que você não goste de alguns dos recursos). Isso não significa que eles devem emular o Python, mas é importante saber o que o Python fez de certo, mesmo que você não queira criar uma linguagem como o Python.

Quanto às idéias filosóficas relevantes, são as mais importantes do Zen de Python:

• Explícito é melhor que implícito.
• Legibilidade conta.
• Casos especiais não são especiais o suficiente para violar as regras.
• Embora praticidade supere a pureza.
• Deve haver uma - e preferencialmente apenas uma - maneira óbvia de fazê-lo.
• Se a implementação é difícil de explicar, é uma má ideia.
• Os espaços para nome são uma ótima idéia - vamos fazer mais!

Eu acho que uma linguagem que segue essas regras deve necessariamente ser bastante boa, mas eu sei apenas de uma que faz isso, e é Python. Por todas as semelhanças com, por exemplo, o Ruby na implementação, o Ruby perde coisas como legibilidade e o convida a fazer código de golfe, o que é divertido, mas não é útil em um ambiente profissional.

O único recurso técnico que eu sinto falta no Python é uma instrução "while" (como enquanto, mas não testando a expressão pela primeira vez). Existem muitas coisas nas bibliotecas padrão do Python e em outras linguagens que poderiam ser melhoradas, mas essas não são estritamente as linguagens , então essa é uma pergunta diferente. :-)

A capacidade de modificar o idioma para atender às suas necessidades é muito importante para mim. Para Lisp feito com macros, para Tcl com nível superior. Em menor grau, Ruby usa lambdas e similares. Eu só quero adicionar novas estruturas de controle que atendam ao problema, em vez de moldar meus problemas em torno das estruturas de controle disponíveis. Como um exemplo simples, a construção "do .. till" que existe em alguns idiomas, mas não em outros, é uma maneira mais limpa de lidar com alguns casos do que "while", podendo adicionar novas estruturas para atender a outros casos é extremamente útil.

No sentido mais geral, isso é metaprogramação ... mas eu o uso principalmente para construir novas estruturas de controle.

O mais importante é que seu idioma precise ter um "estilo". Por exemplo, eu chamaria C de uma linguagem de programação de sistemas baseada em ponteiro. Eu chamaria Erlang de uma linguagem de programação funcional altamente simultânea. Algumas outras linguagens (como C ++ e Java, sem dúvida) são o que Allan Kay chamou de linguagens "aglutinativas": as linguagens de Frankenstein consistiam em vários recursos reunidos.

O mais importante é que as alterações no próprio idioma devem ser o último recurso. Até o som mais benigno pode se tornar complexo quando combinado com os outros recursos do idioma. Eu diria que, para colocar um novo recurso em um idioma, você precisa:

1. Prove que é realmente necessário.
2. Prove que isso não pode ser feito em uma biblioteca.
3. Prove que ele pertence ao idioma.

Obrigado por uma ótima pergunta. Você está recebendo respostas muito boas.

Para não encobrir seus olhos, eu vejo um programador como um canal de informações. Ideias / conceitos / requisitos vão de um lado e o código sai do outro.

Se você pegar um conjunto de requisitos (não importa como eles são declarados) e o conjunto de códigos em um enorme quadro branco, e desenhar linhas mapeando cada requisito para o código que o implementa, a complexidade desse gráfico dependerá de quão bem o código expressa os requisitos. Idealmente, deve ser bem direto e individual, mas é difícil entrar em prática.

Eu medi a especificidade de domínio de uma linguagem como a extensão em que ela simplifica esse gráfico. Essa é uma propriedade extremamente desejável, e pode ser abordada de várias maneiras, desde apenas definindo as classes / rotinas corretas (substantivos / verbos), até macros, escrevendo seu próprio analisador e intérprete / compilador.

Deixe-me apenas dar um exemplo do que quero dizer. Para o problema de criar interfaces de usuário de diálogo flexíveis, essa técnica elimina a necessidade de escrever manipuladores de eventos, movimentação de dados, a maioria das coisas normalmente feitas nas UIs. Isso também resulta na redução do código fonte de aproximadamente uma ordem de magnitude. A meta-linguagem é realmente apenas algumas rotinas e macros em C / C ++ / Lisp, e eu também fiz isso em linguagens sem macros.

Se a implementação de um requisito puder ser feita com edições de 5 pontos no código, ou com 10, fazê-lo com 5 não é apenas menos código, mas menos chances de perder uma etapa e inserir um bug. Portanto, quanto mais específica uma linguagem de domínio, menor, mais sustentável e mais livre de erros é o código. Eu acho que precisamos saber como dirigir em direção a isso. Isso não significa que o código seja mais legível, a menos que o leitor tenha investido na curva de aprendizado para entender a técnica.

Tipos de números inteiros limitados e distintos, como em Pascal e Ada. Honestamente: com que frequência você precisa de todo o intervalo de qualquer número inteiro? Eu acho que há muito a ser melhorado nos tipos primitivos para melhor representar o mundo real.

Existem recursos que facilitam o uso das linguagens de programação depois que você os aprende e há recursos que facilitam o aprendizado do uso. Como os usuários de um idioma têm, idealmente, um relacionamento de longo prazo, otimizar para facilitar o uso é melhor do que otimizar para facilitar o aprendizado. Não torne as coisas mais difíceis do que o necessário, mas não sacrifique a expressividade (sendo capaz de escrever um pequeno código que faz muito) para facilitar a leitura para aqueles que não estão familiarizados com o idioma. Por outro lado, o idioma não deve parecer ruído de linha para as pessoas que trabalham com ele há anos; isso não seria fácil de usar ou aprender.

Convenções de nomenclatura (estou olhando para você PHP)

Integração de primeira classe com ambientes de desenvolvimento.

Atualmente, a codificação é feita em um ambiente rico. Para HTML / CSS / JS, temos o Firebug e outras ferramentas interativas. Para Java, Eclipse e IDEA e outros IDEs verdadeiros. E assim por diante. Existe uma ecologia de ferramentas, começando com o editor, mas não terminando aí:

• Organização do código dentro e entre arquivos
• Destaque inteligente
• Conclusão inteligente / digitação preditiva
• Depuração estática (sinalizando erros de sintaxe, semântica e de estilo)
• Criação e uso de modelos e macros
• Controle de versão (controle de versão, mesclagem, ramificação, ...)
• Desenvolvimento distribuído com vários autores (comentários, documentos em linha, anotações, ...)
• Depuração em tempo de execução (rastreios de pilha, etapas, relógios, ...)
• Depuração interativa "ao vivo" (como Firebug - comportamento de edição de um sistema ao vivo)
• ... nem sei o que vem a seguir.

Os idiomas devem ser construídos para fornecer suporte a essas atividades. Algum progresso foi feito - anotações em Java para ajudar outros desenvolvedores a entender a intenção do código, por exemplo.

Mas, na maioria das vezes, é hackeado, como usar $ Id $ em um comentário para que a fonte controlada pelo CVS possa conter um número de versão. Por que não consigo fazer algo assim a partir do próprio idioma?

Computação Distribuída

O almoço grátis acabou. Hoje, é necessário programas que sejam executados em múltiplos núcleos / múltiplos processadores (e em circunstâncias especiais, múltiplos computadores).

Infelizmente, escrever código multiencadeado é difícil conceitualmente, portanto, não há realmente necessidade de adicionar o idioma como uma barreira.

O uso futuro de C ++ 0x é certamente interessante, por tudo o que foi trazido como uma biblioteca e não o libera de problemas reais de sincronização (você sabe, aqueles que são fáceis de resolver ...)

Eu realmente gosto da abordagem de Go ao problema: o multithreading é incorporado, e a abordagem adotada (canais e goroutines) define uma mentalidade muito mais fácil do que as abordagens tradicionais de semáforo / mutex / bloqueio. Ainda é fácil acessar uma estrutura não sincronizada simultaneamente (o Go tem ponteiros) ou o impasse (ciclo de espera nos canais ...)

Penso que linguagens favoráveis ​​à imutabilidade de dados, como linguagens funcionais, podem ter o direito delas (embora eu goste de experiência lá).

Além disso, o modelo de ator pode ser nosso próximo alvo. Também se destinava à computação distribuída.

Chame-me de louco, mas um dos recursos mais importantes do idioma para mim é a disponibilidade de uma boa referência online, além de exemplos. Sei que posso encontrar bons resultados de pesquisa para qualquer idioma, mas gosto muito do site de APIs do MSDN e Java. Eles tornam a programação muito mais fácil para uma pessoa que não tem muita experiência no idioma específico.

Mais capacidade de ajudar o compilador a verificar seu código.

Sendo um programador de sistemas embarcados, sempre uso o C. Mas sempre desejei ter mais / melhores maneiras de dizer ao compilador o que espero do meu código para que ele possa verificá-lo.

EG eu posso ter uma função

f(int x)

mas eu preferiria

f(int range[-5..25] x)

Por exemplo, eu gostaria de poder escrever asserções sobre funções usando algum tipo de linguagem funcional de nível superior como Lisp ou Haskell. Eles não seriam compilados em código, mas poderiam ser usados ​​para análises estáticas ou dinâmicas.

Sintaxe pequena com o menor número possível de palavras-chave, porque é difícil aprender a sintaxe detalhada e não ajuda na legibilidade.

O pior exemplo é Ada:

procedure Hello is
begin
  Put_Line("Hello World!");
end Hello;

Palavras de preenchimento como is, as, .. não fazem sentido para linguagens de programação.

Eu gostaria de ver mais idiomas para aprender . Não apenas idiomas para iniciantes com restrições mais sérias do que você, como exigir um espaço entre cada token , mas idiomas para pessoas que já conhecem programação e desejam aprender novos conceitos ou melhorar a programação em geral.

Para mim, Haskell é um ótimo exemplo do que quero dizer com "linguagem de aprendizado" (embora também tenha crescido em popularidade e utilidade geral ao longo dos anos). Abandonando a sintaxe C familiar e tendo operadores de composição de funções anteriores (por exemplo, (+2) . (*3)é uma função que se multiplica por 3 e depois adiciona 2), Haskell me ensinou a escrever funções mais curtas. Seu verificador de tipos implacável me ajudou a aprender o idioma mais rapidamente e melhorou minha capacidade de pensar logicamente sobre o código. Esses dois benefícios se espalharam para outros idiomas, inclusive para montagem.

Os objetivos de aprender idiomas e os de idiomas de uso geral estão frequentemente em conflito. Um idioma de aprendizado deve ser desafiador e gratificante para o aprendizado, e deve impor um estilo específico, mesmo que esse estilo não seja o melhor para muitos aplicativos. Uma linguagem de propósito geral deve ser boa para fazer as coisas, e o uso de abstrações deve ser cuidadosamente medido e "fazer sentido". Por exemplo, ao consertar um site, aprender sobre mônadas seria a última coisa que um programador pensaria. Do outro lado da moeda, quando alguém está aprendendo a programar, não deveria ter que passar por bobagens de "vazio estático público" se ainda nem aprendeu sobre funções.

Se você é um designer de idiomas, decida se é um idioma de aprendizado ou aplicado. Isso determinará até que ponto você desejará empregar pureza em seu design.

Desde que estamos em 2011,

• uma especificação absolutamente completa. sem buracos dependentes da arquitetura como em C

• suporte multithreading; não apenas os recursos de sincronização (bloqueios), mas os recursos de linguagem que tornam o multithreading tão fácil quanto escrever um loop:

  all (o em myCollection) {o.someMethod ()}

• multiparadigma; deixe-me, o programador, decidir se eu quero a segurança em tempo de compilação de uma linguagem estática ou a dispersão de uma linguagem dinâmica, caso a caso; me dê recursos orientados a objetos, funcionais, etc.

• consistência (eu sei que está pedindo um pouco demais pela consistência e pelo multi-paradigma ...)

Processos leves

Eu gostaria de ter processos leves como em Erlang. É principalmente um problema para o tempo de execução. Está faltando na JVM e no .NET CLR. O LWP ajuda a criar software maciçamente simultâneo. Idealmente, não deve ser mais caro criar um processo, pois é criar um objeto em uma linguagem. Eu gostaria de criar milhões de processos em meus aplicativos.

Ele é implementado como um pool de encadeamentos com agendamento preventivo, para que uma única tarefa não bloqueie a outra, e as tarefas podem ser agendadas em qualquer núcleo de CPU disponível.

Suporte para recursão da cauda

Eu gostaria de ter suporte para recursão de cauda. Isso também pode ser um problema para o ambiente de tempo de execução. Por exemplo, a JVM não tem suporte para recursão de cauda.

Programação distribuída fácil

Eu gostaria de ter suporte para send ( ! ) E receber primitivas para partes do aplicativo em execução em outras máquinas na mesma netword que em Erlang. Isso facilita a criação de aplicativos escaláveis, por exemplo, datastores distribuídos. Adicionado a essa serialização embutida no idioma também é muito útil como em erlang. E não como em Java, tenho de fazê-lo manualmente.

Facilite a metaprogramação.

limitar formulários especiais

No Python, não há uma boa razão para imprimi-lo, não uma função interna. Parece e age como uma função, exceto por não querer nada com parênteses.

Será que realmente precisamos for, foreach, whilee assim por diante cada um como sua própria forma especial. Que tal uma construção de loop e algumas macros padrão para fornecer o açúcar sintático das formas de loop variantes.

metaprogramação para formulários especiais

form['if'](test-fn, body-fn)

Capacidades de rede

Um idioma que é enviado sem algum suporte de rede é bastante ruim no mundo de hoje.

A maioria dos aplicativos do mundo real precisa se comunicar através de algum tipo de rede:

• atualização automática
• acesso ao banco de dados
• serviços web

É também uma pedra angular do suporte à computação distribuída / na nuvem, é claro.

Gosto de uma linguagem de programação fácil de aprender e fácil de combinar para criar coisas novas.

Por exemplo, embora seja atraente ter várias maneiras de escrever alguma coisa, acho melhor ter apenas uma ou duas maneiras de escrever. Dessa forma, o programa é mais fácil de manter.

Uma linguagem cujos conceitos podem ser aplicados a todos os elementos é muito útil (acho que isso se chama ortogonalidade). Portanto, da próxima vez que você enfrentar um novo recurso de idioma, poderá deduzir como usá-lo.

Entendo que algumas vezes a sintaxe da linguagem precisa atrapalhar o desempenho na fase de compilação / interpretação, mas às vezes sinto que o designer da linguagem adia esse trabalho ao desenvolvedor. Por exemplo, cadeias de linhas múltiplas em Java ou Javascript.

Por fim, a sintaxe da linguagem é sua interface de usuário e, como tal, deve ser clara, concisa, intuitiva, fácil de usar e deve respeitar seus hábitos.

• Legibilidade : quanto menor / menor os símbolos usados ​​na gramática, mais limpo e melhor.
• Tipos orientados a objeto : Métodos, não funções.
• Compreensão : Interfaces fluentes incorporadas, nomes abrangentes e abreviados para classes / interfaces de bibliotecas e os tipos.

Adicionando um recurso a uma linguagem de programação existente. Portanto, o novo idioma B é o idioma antigo A mais o recurso X.

Exemplos existentes:

1. C adicionando classes => C ++
2. Java adicionando algumas coisas => C #

Quando se trata de tecnologia / plataforma / idioma / banco de dados, etc. na maioria das vezes se resume ao desempenho. No futuro, muitos softwares atuais podem ser projetados usando uma linguagem gráfica, pois temos mais poder computacional.

Espero que tenhamos um poder computacional e uma linguagem na qual você projete seu aplicativo e não precise se preocupar com detalhes do idioma .

Atualizar: envio um link para esse idioma LabView

Atualização: devo explicar mais o que quero dizer com "poderoso computacional". O desempenho do software compilado pode não ser tão poderoso quanto o software compilado com base na linguagem de sintaxe. Estou pensando em programação gráfica como um nível mais alto de programação e pode haver mais sobrecarga. Os computadores de hoje podem e executam facilmente linguagens de programação gráfica.