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


38

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.


Dizer que a sintaxe é apenas um detalhe da implementação está completamente errado. O design de sintaxe é uma parte fundamentalmente importante no design de uma linguagem. E muitos dos pontos que você não quer ver postado pode realmente envolver sintaxe. Pena. Parecia uma pergunta interessante.
Konrad Rudolph

O que eu quero evitar é a guerra das chamas. Se você pode discutir a sintaxe sem iniciar uma guerra de chamas, faça isso.
Berin Loritsch

Respostas:


49

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.


2
+1 De fato, o próprio idioma deve permitir que você use qualquer caractere para seus identificadores. Nós não somos todos ingleses.
Berin Loritsch

13
@Berin: Na verdade, mesmo sendo francês, prefiro programas de inglês. O problema é a comunicação, se você escreve programas com identificadores húngaros, espanhóis ou portugueses, não espere que eu seja capaz de entrar ... em um contexto de internacionalização, é extremamente importante que os desenvolvedores possam se comunicar entre si , e isso implica o uso de um idioma comum para identificadores, comentários e documentação. Inglês é a língua franca dos desenvolvedores.
Matthieu M.

11
Eu acrescentaria que o suporte unicode deve ser natural ao usar o idioma. Se possível, não deve ser necessário nenhum esforço extra para "adicioná-lo", deve "apenas funcionar" (onde for razoável).
precisa saber é o seguinte

4
De maneira semelhante, o idioma deve fazer uma distinção fundamental entre dados de texto (sequência de caracteres) e binários (sequência de bytes). C # acerta isso com stringe byte[]. Assim como o Python 3.x com stre bytes. C (++) charentende isso terrivelmente errado.
dan04

1
@RHSeeger - de fato !!! Mesmo em Python, você precisa digitar u'My Unicode Štring'. Eu gostaria que você esquecesse com que tipo de string você está lidando e com o código de gravação inicial.
Orokusaki #

25

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.


2
"bom suporte a datas" é um requisito bastante acentuado! Afinal, o que isso quer dizer? Eu acho que datas e horários é uma daquelas coisas em que você não consegue obtê-lo totalmente bom. ou você o torna simples e errado, ou o torna certo e incrivelmente complicado. é realmente difícil encontrar um bom meio termo.
sara

@kai O ponto é que o suporte a datas geralmente é bastante terrível. O velho java.util.Datetem quase todas as possíveis pegadas e problemas. Conheço apenas uma parte do novo java.time.*pacote, mas é limpo, fácil de usar e livre de erros do AFAICT. Usuários mais avançados podem encontrar problemas, mas é uma grande melhoria. +++ O problema parece ser que é um problema complicado e a primeira versão é apressada e quebrada.
Maaartinus 21/07

24

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.


Belo colapso.
Qix

23

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.


4
Isso pode ser verdade até certo ponto. No entanto, se você nunca ouve seus usuários, nunca conhece a dor que inflige a eles quando eles tentam usar seu cérebro. Sem ouvir / sentir essa dor, você nunca terá a próxima grande idéia que resolve esse problema e outros. Nenhum homem é uma ilha. A dor pode ser um grande motivador para a inovação.
Berin Loritsch

5
@Berin: Eu não acho que o ponto é que você nunca deve ouvir seus usuários, mas não ouça os usuários que desejam usar o idioma para algo que não foi projetado para fazer. Se você projetou um idioma para resolver um conjunto ou problemas específicos, deve atender aos usuários que também precisam resolver esses problemas. No entanto, você aborda o extremo e, às vezes, um idioma pode encontrar um nicho em um novo domínio, então marque com +1.
Jeremy Heiler

2
@ Jeremy, sim, é exatamente isso que estou dizendo, mas acho incomum que um idioma funcione bem em um domínio para o qual não foi projetado.
dan_waterworth

@dan_waterworth: idiomas de sucesso geralmente funcionam, geralmente bem, em domínios para os quais não foram projetados.
David Thornley

8
Em vez de "não escutar usuários", o conselho é melhor formulado como "não escute usuários que você não possui".
chrisaycock

16

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.


2
+1. A depuração é um dos lugares em que alguns idiomas são melhores que outros - e alguns IDEs fazem toda a diferença entre um idioma utilizável e um que fica no seu caminho.
Berin Loritsch

2
Vou adicionar um pouco a isso e dizer, sempre que possível, rastreamentos de pilha úteis. Se houver um erro (ou exceção não capturada ou qualquer outra coisa, dependendo do seu idioma), desejo poder visualizar toda a pilha de chamadas que chegou a ela, juntamente com os valores dos argumentos usados. O Tcl faz isso excepcionalmente bem .. mas, para ser justo, tudo é uma string no Tcl, para que você possa imprimir o valor de tudo com relativa facilidade.
precisa saber é o seguinte

1
Não apenas depurando, mas tornando difícil escrever bugs. Fiquei muito feliz quando o Java introduziu a verificação automática de limites em matrizes ... mas aqui estamos, 15 anos depois, ainda cometendo esses erros em outras linguagens.
Alex Feinman

3
Não seria melhor ter uma linguagem que encontre os erros em tempo de compilação? Por exemplo, quando eu uso Ada, gasto significativamente menos tempo no depurador do que quando eu uso C ou C ++.
Martin

12

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. :-)


4
Considero duas outras coisas mais importantes, especialmente no nível do design da linguagem: "Casos especiais não são especiais o suficiente para violar as regras". porque é difícil usar uma linguagem com mil casos especiais ou regras misteriosas, em conjunto com "Embora a praticidade supere a pureza". porque senão você entra no reino dos tarpits.

15
Se explícito é melhor que implícito, por que você não precisa declarar variáveis? Quando um erro de digitação simples pode causar erros difíceis de depurar (em oposição a erros capturados em tempo de compilação ou erros em tempo de execução que são óbvios e fáceis de depurar), esse é um grande golpe contra o idioma IMO.
Mason Wheeler

4
@ Wheeler Mason: O único motivo para declarar variáveis ​​em outros idiomas é que você deve declarar que tipo elas são. Python é dinâmico, portanto, a declaração de tipo não é necessária e, portanto, a declaração não é necessária. Não vejo como isso tem algo a ver com implícito / explícito. Os tipos em Python são explícitos. O mesmo acontece com as variáveis. Após dez anos, um erro de digitação nunca causa um erro difícil de depurar. Na verdade, eles são triviais para depuração.
Lennart Regebro

8
+1 para a lista, -1 para o fanboy-ness. Prestar atenção a todos os idiomas que obtiveram sucesso significativo e tentar incorporar, ou pelo menos analisar a aplicabilidade desses elementos, parece ser a abordagem mais pragmática.
Steven Evers

3
@Ennart: eu diria que ser capaz (mas não obrigatório, consulte a regra 4) de declarar explicitamente os tipos de função é uma coisa boa. É semelhante ao design por contrato. Esse é o ponto que quero enfatizar.
Theo Belaire

11

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.


Interessante. Pode ser difícil acertar um bom suporte à metaprogramação, mas muito poderoso quando é. Ouvi de pessoas que gostam do Lisp que a implementação do Lisp está entre as melhores - mas elas dizem isso sobre tudo no Lisp. Alguns exemplos do que você acha que a meta programação é feita corretamente?
Berin Loritsch

A "metaprogramação feita corretamente" deve estar onde é simples fazer o certo (bem, para atividades razoáveis ​​e simples) e onde o resultado final parece uma parte natural da linguagem.
Donal Fellows

1
Modificação não apenas modificável, mas decifrável. Se você reformulou algo no idioma, eu, como leitor, seria capaz de descobrir rapidamente. Anotações ou outros marcadores extrínsecos podem ajudar com isso.
precisa saber é o seguinte

Eu acho que Mata-Lua ou Template Haskell fazem um bom trabalho por fornecer isso. (Não tão bom quanto o esquema de macro, mas isso é o que você paga para usar mais de parens em um idioma)
Theo Belaire

10

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.

2
Em outras palavras, o idioma deve ter um princípio abrangente de design e o idioma deve ser consistente com esse princípio. Os comentários sobre a evolução da linguagem são garantidos (eu já vi isso estragado algumas vezes).
Berin Loritsch

1
Lembra-me da minha citação favorita em C ++ ... Um polvo feito pregando pernas extras em um cachorro.
Ocodo

4
Prove que isso não pode ser feito em uma biblioteca . +1
Qix

2
Eu gosto do petisco da biblioteca. É legal como linguagens como haskell não possuem itens de fluxo de controle internos, como loops, exceções ou continuações. eles são realmente simples de definir dentro do idioma, mantendo a sintaxe realmente limpa e promovendo a extensibilidade e a composição ao criar vários recursos inteligentes de idioma.
Sara

10

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.


9

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.


2
Os tipos inteiros limitados ala C, C ++, D, Java, C # etc. têm seu lugar com certeza. Alguns tipos de programação não se importam e simplesmente precisam da distinção entre número inteiro e ponto flutuante. Mesmo assim, talvez precisemos apenas de um tipo de número e depois nos preocupemos com a parte integrante do número? Em resumo, a programação de negócios é menos sensível ao tipo inteiro específico do que ao fato de um número ser um número inteiro. Quando você está implementando um protocolo em um nível baixo, as regras mudam drasticamente.
Berin Loritsch

2
O que eu pensei onde tipos como no Ada, onde você pode simplesmente dizer type Date_Of_Month is 1 .. 31;e deixar decisões como 16 ou 32 bits para o otimizador. Porém, mais importante, atribuir 32 ou 0 ou -5 a uma variável do tipo fornece um RANGE_ERROR.
Martin Martin

As faixas funcionam bem para coisas como Date_Of_Month(ou Month_Of_Year) onde há um alcance óbvio para usar, mas muitos - provavelmente a maioria - dos casos são imprecisos. type Persons_Age is 0..120? E se alguém quebrar o recorde de longevidade? type Year is 0..9999? E se você é egiptólogo?
dan04 19/02/11

Se você é egiptólogo, precisa inconscientemente type Egyptian_Year is -9999 .. 300;. Na minha experiência, você pode encontrar limites úteis para números inteiros na maioria das vezes. A esse respeito, você deve considerar type Scrolls_Found is array Egyptian_Year of Natural;Você não pode / não deve ter um tipo ilimitado como índice de matriz. É apenas um vetor de ataque para hackers. Entre: Ada permite que os limites do intervalo sejam calculados em tempo de execução.
Martin Martin

1
@kai ninguém disse que esse recurso específico de sistemas de tipos deve ser usado em todos os lugares, sem exceções. Tenho certeza de que Ada também permite usar tipos numéricos "regulares". E os tipos numéricos limitados são certamente úteis para alguns problemas (bastante comuns).
precisa saber é o seguinte

8

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.


8

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


Menos um problema de design de linguagem, no entanto. Claro, você sempre tem que manter um olho sobre o que entra na biblioteca padrão, mas os designers de linguagem não pode impor convenções de nomenclatura;)

3
Você pode para a biblioteca padrão.
Malfist

3
Nem mencione PHP. Pior idioma comumente usado ao redor. Não projetado por um cientista da computação, apenas um cara que queria modelos e esteróides foram adicionados.
Keyo 4/01/11

@ delnan: alguns idiomas, como Mercury ou Eiffel, impõem convenções de nomenclatura (todos os nomes de classe de capital, variáveis ​​que começam com um capital, etc.) e são aplicadas pelo compilador. Fortran disse que variáveis ​​começando com i, j, k são inteiros (daí o uso tradicional como variáveis ​​de loop na maioria dos idiomas ...). E assim por diante. De alguma forma irritante, se você não gosta da convenção, mas bom para a consistência dos códigos-fonte, pelo menos.
PhiLho 24/02

@ PhiLho: Isso é muito limitado. Ele não pode impor - apenas um exemplo - o uso consistente e significativo (para leitores humanos) de maiúsculas ou sublinhados (poderia tentar, mas arriscaria a sanidade dos programadores no processo).

7

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?


Você quer dizer algo como ASIS (ISO / IEC 15291: 1999 "Ada Semantics Interface Specification")? O ASIS não cobre tudo o que você deseja, mas bastante. Eu sempre desejei algo como o ASIS para outras linguagens de programação. Veja sigada.org/wg/asiswg para detalhes.
Martin

Algumas dessas coisas são relativamente baratas ou são gratuitas a partir do seu IDE: organização do código, destaque de sintaxe, dobragem de código, controle de versão, modelos / macros. Outros exigem muito mais esforço: depuração em tempo de execução, depuração estática, conclusão inteligente / digitação preditiva, refatoração, etc. Embora muitas vezes negligenciado, projetar uma linguagem consistente é muito mais difícil quando você também precisa se preocupar com os plugins IDE.
Berin Loritsch

6

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.


Outro exemplo seria Erlang. Um tema comum entre idiomas desse tipo é uma abordagem de nada compartilhado , onde o estado é essencialmente passado junto com a mensagem. A abordagem escala bem.
Berin Loritsch

@Berin: Você está certo, mesmo que eu não tenha citado Erlang na mensagem porque sei pouco, lembro-me corretamente de que implementa o modelo de ator.
Matthieu M.

6

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.


JavaDoc, CppDoc, RubyDoc, etc. têm sido um grande trunfo para entender as bibliotecas padrão, bem como as bibliotecas que você cria. Eles não são todos criados iguais e alguns são mais fáceis de navegar do que outros.
Berin Loritsch

Concordado, o site da API Java é um excelente ativo. É ótimo ter um formato padrão para criar a documentação da API também. Os ganhos de produtividade com o uso de um IDE com suporte embutido para análise de JavaDoc (netbeans) são surpreendentes. Embora eu tenha uma memória horrível, isso provavelmente me beneficia mais do que outros.
toc777 31/03

6

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.


Essencialmente uma maneira eficiente de verificar limites? Isso seria bem legal. Embora, pelo menos, eu queira que isso seja incluído na verificação do tempo de execução, bem como na verificação do tempo de compilação. Ao extrair informações de um banco de dados ou da interface do usuário, você sempre garante que o valor será válido. Se esse fosse um recurso de linguagem, eu também gostaria de usá-lo para esses fins.
Berin Loritsch

3
Você deveria usar Pascal. Você pode definir um tipo que cubra um intervalo arbitrário de números, como -5..25, que o compilador pode verificar em tempo de compilação. (Contanto que você está atribuindo apenas constantes, é claro.)
Mason Wheeler

1
@ Kugel: O que mais, mas um recurso de compilador é afirmado? E o teste de unidade não verifica o código na produção. E não fazer o check-in da produção é como tirar os barcos vivos depois da viagem inaugural. Para economizar combustível e acelerar o navio.
Martin

1
Eu usaria o Ada, exceto que a plataforma em que estou trabalhando não possui um compilador Ada. Ele só tem um compilador C, então tudo isso é acadêmico.
Rocketmagnet 17/01

1
Eu já uso muitas afirmações, mas seria ainda melhor ter isso e outras coisas como recursos de idioma.
Rocketmagnet 17/01

5

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.


4
Eu acho que o pior exemplo são as línguas em que você diz public static void.
Joey Adams

1
A idéia não é nova e já foi implementada no formato SmallTalk, que não possui palavras-chave. Portanto, você deve ter usado o SmallTalk como exemplo positivo para sua reivindicação. BTW: Se você não sabe para que ISserve, então você não entende o Ada (você já programou o Ada?): ISSepara a declaração do procedimento da declaração das variáveis ​​locais e também distingue uma especificação da implementação. É claro que você só notaria ao comparar a especificação e a implementação de uma função para ver que isso ISfaz todo o sentido e não é um preenchedor.
Martin

1
Esqueci de mencionar: A sintaxe do SmallTalk também se encaixa no verso de um cartão postal. Por isso, também satisfaz o seu desejo de "pequeno". É claro que a maioria das idéias aqui já está implementada em algum idioma em algum lugar e a maioria dos pôsteres aqui usa esses idiomas como exemplo positivo, em vez de fazer um exemplo negativo com defeito . Eu votaria em você se eu tiver reputação suficiente. Não porque sua ideia é ruim - mas por usar exemplos negativos.
Martin

7
Palavras de preenchimento podem realmente servir a um propósito se ajudarem a desambiguar a sintaxe. Por exemplo, eu prefiro muito mais if x then …para if (x) …. Trocamos um par de parênteses por uma palavra-chave contextual. Isso faz sentido porque a condição xpode ser uma expressão complexa com seus próprios parênteses. A eliminação do par mais externo pode aumentar drasticamente a legibilidade. Uma alternativa, é claro, é usar dois pontos aqui, como no Python. De fato, acredito que a maioria dessas cargas desambiguantes poderia ser substituída por dois pontos. Não tenho certeza de qual método eu prefiro.
Konrad Rudolph

3
@ Konrad: Se disambguates a sintaxe, é não um enchimento. O is é um preenchedor porque Ada poderia ter permitido procedure Hello begin ... endsem ambiguidade.
Dan04

4

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.


2
Como a composição da função de Haskell é, de alguma maneira, inversa? É uma tradução direta de (f ∘ g)(x) = f(g(x)).
Jon Purdy

@ Jon Purdy: Isso significa que você deve escrever as funções na ordem inversa da sua aplicação. Nas duas formas, gé aplicado ao argumento primeiro, seguido por f. Se você deseja classificar uma lista, agrupá-la e obter o primeiro item dessas listas, escreva (map head . group . sort) listou map head $ group $ sort listou map head (group (sort list)). Em todos os casos, você acaba gravando as operações ao contrário. A propósito, importar Control.Arrowpermite que você diga (sort >>> group >>> map head) list, mas o >>>operador parece um pouco estranho e detalhado para mim.
Joey Adams

2
Não sei, ainda acho que o da direita para a esquerda faz sentido. (map head . group . sort) listlê como "o primeiro item de cada grupo em uma espécie de list", o que é bastante natural - e, para mim, mais funcional do que (sort >>> group >>> map head) list, que lê de forma imperiosa e retrógrada como "classifique e agrupe, em seguida, pegue o primeiro item de cada grupo". .. list"
Jon Purdy

@JoeyAdams - o >>>operador parece um pouco estranho e detalhado - Algumas linguagens funcionais mais recentes começaram a ser usadas |>como um operador de encadeamento da esquerda para a direita, o que talvez seja um pouco mais fácil para os olhos ... #
307 Jules

4

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 ...)


Estou com você 100% para obter uma especificação completa. Multi-paradigma e consistência serão definitivamente um ato de equilíbrio. Você pode especificar um conjunto de comportamentos para um paradigma dinâmico como um subconjunto de comportamentos para verificação estática - mas acho que essas duas abordagens podem se prestar a estilos de programação muito diferentes. Eles realmente precisam ser idiomas separados nesse ponto. Talvez um par de idiomas consistentes com 100% de compatibilidade seja o que você está procurando?
Berin Loritsch

Idiomas como Scala (e talvez Haskell? Eu não o conheço o bastante) têm um forte sistema de tipo estático e dispersão, graças à inferência de tipos e implícitos.
PhiLho 24/02

2
Os recursos dependentes da arquitetura são bons quando uma linguagem permite que um programador especifique o que é ou não importante. O que torna C horrível é que não há como declarar "tipo numérico que envolve o módulo 65536"; mesmo que uma plataforma implemente uint16_t, o padrão exige que algumas implementações considerem a diferença entre dois uint16_tvalores como assinadas e outras considerem a diferença como não assinada; não fornece nenhuma maneira para o programador especificar qual comportamento é desejado.
Supercat

Eu discordo de multiparadigm; isso deixa muito espaço de manobra para batalhas de estilo de codificação. A biblioteca A é escrita com vários paradigmas dinâmicos . A Biblioteca B é escrita com vários paradigmas estáticos . Bem, agora a Biblioteca A precisa conversar com a Biblioteca B; onde está o meio termo? Se você precisar escrever cola entre dois pedaços de código no mesmo idioma, o idioma é inerentemente defeituoso no IMO.
Qix

3

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.



O Scala possui recursão de cauda e é compilado na JVM. O compilador IBM Java também pode fazer recursão de cauda - às vezes.
Martin Martin

3

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)


O Ruby tem "formas especiais" para fazer loop, pelo menos no sentido de que objetos iteráveis ​​geralmente têm um método como eachesse, que leva um bloco de código como argumento. (Rubi também tem fore whileloops, mas não se preze Rubi programador realmente usa-los.)
mipadi

@mipadi: Eu sou um grande fã de blocos de Ruby e os idiomas associados.
dietbuddha

talvez eles pensem - Você vai atirar nos seus olhos. :) Meu palpite foi a associação de todos vocês "Python" poderoso e "nenhuma boa razão para isso". No entanto, a metaprogramação é um problema válido de design de linguagem que geralmente é negligenciado. É por esse motivo que vou aprovar isso.
Berin Loritsch

@ Berin: Na verdade, eu uso e sou fã de Python, o que o torna mais divertido.
dietbuddha

Um tipo de loop tornaria o fluxo de código obscuro. Por exemplo, como seria um do..whileloop se houvesse um tipo de loop que tivesse a avaliação no topo? Não pareceria um loop de fazer ... enquanto.
Qix

2

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.


8
Mas pode ser um recurso de biblioteca padrão muito bem.
Donal Fellows

@Donal: Eu nunca disse o contrário (ou pelo menos não pensava assim), a questão está aberta aos recursos da linguagem e da biblioteca. Meu ponto é apenas que, se você receber um pacote de idioma e não há capacidade de rede lá, você vai preencher a dor mais cedo ou mais tarde :)
Matthieu M.

3
A biblioteca padrão é realmente parte da experiência linguística e deve ser tratada com o mesmo cuidado e respeito. Também concordo com este requisito para uma biblioteca padrão.
Berin Loritsch

1

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.


Ortogonal significa que cada recurso faz algo diferente. Veja ferramentas como grep ou awk. Eles fazem uma coisa, bem. Em seguida, você os liga em diferentes ordens para fazer o que precisar.
Theo Belaire

1
  • 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.

1
Desculpe, mas eu tenho que dar um -1 por estar completamente errado nisso. A dispersão ajuda a escrever o código mais rapidamente, mas definitivamente não torna o código mais legível, além de um determinado mínimo. Um certo nível de verbosidade torna o código muito mais fácil de ler, porque essas palavras e símbolos extras significam algo e transmitem informações significativas ao programador, especialmente se ele foi originalmente escrito por outra pessoa e você não tem a vantagem de já ter uma mentalidade mental. modelo disso em sua cabeça.
Mason Wheeler

Para mim, código limpo é código legível. Eu também disse o menor: ter ":" em vez de "=>" em matrizes PHP ou ter "." em vez de "->", certamente seria uma melhoria (e eu já gosto do PHP).
dukeofgaming

4
@Mason: Eu e muitos bons escritores técnicos (por exemplo, William Zinsser) discordo. A verbosidade é inimiga da legibilidade, não da discrepância.
Konrad Rudolph

2
Procuro uma forma de concisão que é definida em termos de símbolos . Estou muito feliz com os símbolos de vários caracteres, desde que sejam coisas que o leitor naturalmente trate como um único símbolo (por exemplo, uma palavra é um símbolo).
Donal Fellows

1
Seu primeiro ponto entra em conflito direto com os dois últimos.
Qix

1

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 #

2
Esta é uma enorme simplificação excessiva. Um exemplo muito melhor seria a diferença entre C e Objective-C.
Jon Purdy

0

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.


3
Os computadores já são poderosos o suficiente para fazer isso. Isso simplesmente não é prático, pois você precisará entrar no código por algum motivo ou outro .
precisa saber é o seguinte

2
Ainda é uma espécie de linguagem. Houve mais de uma tentativa de tornar isso uma realidade. As ferramentas UML geram uma certa quantidade de código, mas quando o modelo é suficientemente detalhado para produzir um produto em funcionamento, não é mais possível entender o código. Acredito que havia algo no ambiente Unix para a fiação gráfica de aplicativos, mas era necessária muita configuração para corrigi-lo. Os mecanismos de fluxo de trabalho usam esse metaphore para permitir que não programadores projetem o fluxo de trabalho.
Berin Loritsch

1
Em resumo, embora eu duvide muito da utilidade dessa abordagem em termos gerais, há aplicativos específicos nos quais ela é usada atualmente e funciona bem para essa aplicação. Re: seus pontos ... 1. Os computadores têm o poder computacional, o lado técnico não é o problema. 2. O problema é fornecer uma linguagem visual expressiva o suficiente para fazer o trabalho no sentido geral sem se perder nos detalhes. Fora dos aplicativos de nicho, o texto parece ser uma representação muito mais compacta de um programa. Votei positivamente porque é aplicável à questão colocada.
Berin Loritsch

1
@Amir: Então explique por que os computadores precisam ser mais poderosos para que a "programação gráfica" conduza o desenvolvimento de software?
Jeremy Heiler

7
@Amir: Você está confundindo uma limitação técnica com uma mais fundamental. A razão pela qual não temos muitas linguagens gráficas de computador é que não sabemos como fazê-las bem (e não sabemos se elas podem ser bem executadas). Estou ciente do LabView e já ouvi muitas reclamações sobre fazer coisas complicadas ou alterar coisas simples. Também não precisamos de computadores mais potentes para projetar essa linguagem; portanto, tente esboçar alguns exemplos de programas em uma linguagem tão hipotética.
precisa saber é o seguinte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.