A sintaxe realmente importa em uma linguagem de programação? [fechadas]

Um dos meus professores diz que "a sintaxe é a interface do usuário de uma linguagem de programação", linguagens como Ruby têm grande legibilidade e estão crescendo, mas vemos muitos programadores produtivos com C \ C ++, portanto, como programadores, isso realmente importa que a sintaxe deve ser aceitável?

Eu adoraria saber sua opinião sobre isso.

Isenção de responsabilidade: não estou tentando iniciar uma discussão. Eu pensei que este é um bom tópico de discussão.

Atualização: Este acaba sendo um bom tópico. Fico feliz que todos vocês estejam participando.

Sim. Se você estiver em dúvida, use APL , J ou Brainfuck , ou mesmo Lisp ou Forth puro e simples, e tente entender qualquer programa não inteiramente trivial. Em seguida, compare com, por exemplo, Python.

Em seguida, compare o mesmo Python (ou Ruby, ou mesmo C #) com coisas como Cobol ou VB6.

Não estou tentando dizer que a sintaxe peluda é ruim e a linguagem natural é boa em todas as circunstâncias. Mas a sintaxe óbvia faz uma enorme diferença. Em suma, tudo o que você pode escrever na linguagem de programação mais bonita, também pode escrever como um programa de máquina de Turing - mas você geralmente não quer, não é?

Na prática, acho que isso importa. A legibilidade já foi discutida acima. Outra questão pode ser quantas teclas são necessárias para expressar uma ideia / algotitmo? Outra questão é como é fácil para os erros de digitação ser difícil para o olho humano captar, e quanto dano eles podem causar.

Também achei útil em alguns contextos analisar e / ou gerar fragmentos de código por meio de outro programa de computador. A dificuldade de analisar o idioma e / ou gerar o código correto afeta diretamente quanto esforço é necessário para criar / manter essas ferramentas.

Acredito que seu professor esteja se referindo ao açúcar sintático .

Açúcar sintático é um termo de ciência da computação que se refere à sintaxe em uma linguagem de programação projetada para facilitar a leitura ou a expressão, enquanto existem formas alternativas de expressá-las .

Então, o que seu professor está sugerindo é que qualquer código / sintaxe escrito em uma linguagem de programação pode ser expresso em outras linguagens da mesma maneira - ou mesmo na mesma linguagem.

Robert Martin, retirando do teorema da Programação Estruturada , abstraiu o que os programadores fazem fundamentalmente com as linguagens de programação em sua palestra no RailsConf 2010: Robert Martin (vídeo do YouTube, veja após 14 minutos, embora eu recomende a coisa toda):

• Sequência (atribuição)
• Seleção (se declarações)
• Iteração (loops)

É o que todos os programadores fazem, de uma linguagem de programação para outra, apenas em uma sintaxe ou interface de usuário (UI) diferente. Acho que isso é o que seu professor estava falando, se ele está falando abstratamente sobre linguagens de programação.

Portanto, em essência , a sintaxe não importa . Mas se você quiser ser específico, obviamente algumas linguagens e sintaxes são mais adequadas para determinadas tarefas do que outras, nas quais você pode argumentar que a sintaxe é importante.

Sim e não.

Existem alguns aspectos diferentes da sintaxe.

• legibilidade
• expressividade
• parsability

A legibilidade já foi mencionada.

Expressividade é um caso interessante. Vou usar a passagem de função como exemplo, porque é uma espécie de ponto de inflexão de dor semântica / sintática.

Vamos pegar C ++, por exemplo. Eu posso criar uma função de primeira ordem desta maneira:

class funcClass
{
  int operator()(int);
}
funcClass fun;

void run_func(funcClass fun)
{
   fun();
}

Esse idioma específico é comumente usado nos Elementos de Programação de Stepanov .

Por outro lado, posso imitá-lo no Common Lisp com algo como isto :

(defun myfunc() )

(defun run_func(fun)
  (fun))

Ou, em Perl -

   sub myfunc
   {
   }

   sub run_func
   {
      my $func = shift;
      $func->();          #syntax may be a little off.
   }

Ou, em Python -

def myfunc():
    pass

def run_func(f):
    f()

Todos eles têm - essencialmente - o mesmo conteúdo semântico, embora o exemplo C ++ contenha alguns metadados de tipo. Qual idioma expressa a idéia de passar melhor uma função de ordem superior? Lisp comum mal faz uma variação sintática. O C ++ exige que uma classe seja criada apenas para 'transportar' a função. Perl é bastante direto em fazer algum nível de diferenciação. O mesmo acontece com o Python.

Qual abordagem melhor se adequa ao domínio do problema? Qual abordagem melhor pode expressar os pensamentos em sua cabeça com o mínimo de 'incompatibilidade de impedância'?

Parsability é - na minha opinião - um grande negócio. Em particular, refiro-me à capacidade do IDE de analisar e cortar a linguagem sem cometer erros. Reformatar é útil. Idiomas delimitados por token tendem a analisar bem - ruby ​​/ c / pascal, etc.

Considere, no entanto, que todos os tipos de sistemas foram criados com todos os idiomas sérios para resolver problemas do mundo real. Embora a sintaxe seja uma barreira para expressar algumas coisas, é uma barreira que pode ser contornada. Equivalência de Turing e tudo isso.

A sintaxe definitivamente importa, apesar de você perceber mais quando não é intuitiva e incentiva bugs. Por exemplo, a piada infame "último bug do mundo":

if (AlertCode = RED)
   {LaunchNukes();}

A sintaxe importa, e posso dar dois exemplos de suporte: Dylan, que é um Lisp com uma sintaxe mais convencional, e Liskell, que é Haskell com sintaxe semelhante ao Lisp. Em cada caso, foi proposta uma variante da linguagem que tinha exatamente a mesma semântica, mas uma sintaxe radicalmente diferente.

No caso de Dylan, pensava-se que abandonar expressões s em favor de algo mais convencional ajudaria a atrair uma gama maior de programadores. Aconteceu que a sintaxe não era a única coisa que impedia os programadores de usar o Lisp.

No caso de Liskell, pensava-se que o uso de expressões s permitiria um uso mais fácil das macros. Acontece que as macros realmente não são necessárias em Haskell, portanto esse experimento também não funcionou.

Aqui está a coisa: se a sintaxe não importasse para ninguém, nenhum experimento teria sido tentado.

A resposta pode estar na separação do que "importa" em fatores computacionais e humanos . Existem muitos fatores humanos na sintaxe:

• Legibilidade
• Sucinteness
• Manutenção
• Pedagogia
• Prevenção de erros
• Adequação para o objetivo - é uma linguagem REPL, uma linguagem de script ou uma linguagem de grandes sistemas?

No que diz respeito ao computador, o único problema de sintaxe é se há ou não ambiguidades que precisam ser resolvidas e quanto tempo leva para tokenizar / analisar o código na compilação / interpretação - e é apenas no caso dos últimos, onde a sobrecarga da análise é um problema significativo.

Talvez seja por isso que você sempre terá uma resposta "sim e não" a esta pergunta - porque há dois aspectos nela.

Sem sintaxe, não teríamos um "modelo" comum para comunicar, em nível humano, a intenção de um bloco de código. A sintaxe fornece uma estrutura comum a partir da qual os compiladores podem ser padronizados; métodos podem ser compartilhados; a manutenção pode ser simplificada.

Acho que realmente importa é o acesso à API e a disponibilidade de funcionalidades de baixo nível (como controle e bloqueio de memória) quando necessário. A maioria dos outros idiomas vem com esses recursos incluídos. O problema é que, quando você precisa de funcionalidade adicional, geralmente precisa usar uma linguagem como C para implementá-la. E é complicado fazer uma interface C com o idioma que você está usando.

Para tudo, exceto desenvolvimento web (e matemática), descobri que C / C ++ ainda é a linguagem de um sistema operacional e de um aplicativo. É o que é suportado na maioria das vezes para o verdadeiro desenvolvimento de aplicativos multiencadeados, pré-formados e multiplataforma. E a sintaxe de C está bem. Apenas muito simples e relativamente detalhado. Sintaxe incrível realmente não importa muito. Disponibilidade de energia e API Todos precisamos interagir com o código de outras pessoas (que na maioria das vezes é escrito em C ou em seus derivados).

Sintaxe definitivamente importa. É extremamente valioso se a sintaxe do idioma for flexível o suficiente para permitir que você crie um idioma específico do domínio conveniente e legível para o seu aplicativo. Se você duvida, imagine imaginar problemas de álgebra em latim prosaico, como foi feito antes do século 18, ou imagine fazer cálculos sem a notação agora conhecida de Leibniz. Certamente, um texto de cálculo é ilegível para um iniciante, mas com a prática podemos usar o cálculo e a notação de Leibniz para resolver rapidamente uma classe de problemas que exigiam páginas de matemática com métodos clássicos. A programação é apenas mais um pouco de matemática. Uma notação conveniente, próxima ao domínio do problema, pode fazer uma enorme diferença na produtividade.

Aqui está um programa que calcula a faculdade de 6:

S(K(S(S(SI(KK))(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)
(S(KS)(S(K(SI))K))))(KK)KK))))))(S(K(S(S(K(SI))(SII)(S(K(SI))(SII))
(S(K(S(S(KS)(S(KK)(S(SI(KK))(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)KK)))))))
(S(K(S(S(KS)(S(K(SI(KK)))(SI(K(KI)))))))(S(K(S(K(S(S(K(SI))(SII)(S(K(SI))
(SII))(S(K(S(S(KS)(SI(KK)))))(S(S(KS)(S(K(S(KS)))(S(K(S(KK)))(S(S(KS)K)
(K(SI(K(KI))))))))(K(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)))))))))))
(S(S(KS)K)(K(SI(K(KI)))))))))))(S(S(KS)K)(K(SI(K(KI))))))(S(S(KS)(S(KK)(S(KS)
(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)
(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)
(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)
(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)KK)))))))

A sintaxe é mínima:

expression: expression term | term
term: ‘(‘ expression ‘)‘ | combinator
combinator: 'S' | 'K' | 'I' 

Parece haver uma crença comum de que a sintaxe é o que dificulta uma linguagem. Como tantas vezes acredita comumente, exatamente o oposto é verdadeiro.

Observe que a sintaxe LISP é legível apenas (se houver), pois possui muito mais sintaxe que a anterior. Portanto, se os fãs do LISP lhe disserem que "a sintaxe não importa", peça que eles sejam conseqüentes e tente o cálculo do SKI. Eles terão que admitir que uma sintaxe pouco não é tão ruim, afinal.

Eu não acho que isso importe além da preferência pessoal. Como todas as coisas (desempenho, capacidades, etc.) são iguais, entendo por que alguém colocaria maior peso em uma sintaxe de idioma, mas optando por ignorar o desempenho de idiomas como c / c ++ ou qualquer outro idioma mais adequado para o trabalho, simplesmente por causa de sintaxe pareceria uma má ideia ao redor.

Sim, a sintaxe é importante, embora realmente apenas para facilitar a leitura. Comparar:

for i in range(10):
   print(i)

(Sim, isso é Python) com

FOR(i<-RNG-<10){PRN<-i}

(Sim, essa é uma linguagem que acabei de criar). Ambos fariam exatamente a mesma coisa, da mesma maneira, mas a sintaxe é diferente e o Python é mais fácil de ler. Então, sim, a sintaxe definitivamente importa. Até o "açúcar sintático" é importante.

 @property
 def year(self):
     return self._date.year

É mais fácil de ler do que

 def year(self):
     return self._date.year
 year = property(year)

Sim, claro.

Se você deseja iniciar uma grande chama, pergunte ao pessoal, onde eles colocam o bracelete de abertura em idiomas do tipo C. Quero dizer

void foo() {
  // blah
}

VS

void foo()
{
  // blah
}

ou mesmo VS

void foo() 
{ // blah
}

E esta é apenas a mesma linguagem! Além disso, pergunte a eles sobre os espaços onde eles os colocam (nome da função e pulseira, operadores etc.).

1000 respostas garantidas!

Sintaxe importa. No entanto, hoje em dia, eu diria que isso importa quase inteiramente por causa da legibilidade e não realmente em termos da quantidade de pressionamentos de tecla necessários. Por quê?

• A menos que você esteja realmente escrevendo algo tão simples, se o número de teclas pressionadas for o fator limitante na criação de um programa, você será realmente uma porcaria na digitação ou pensará muito rapidamente.
• Atualmente, todos os IDEs decentes têm um grande número de atalhos, o que significa que você não precisa digitar todos os caracteres que está usando na maioria das vezes.

Dito isto, se for muito detalhado, pode chegar ao ponto em que afeta a legibilidade. Eu preferiria ver algo como:

foreach (String em stringList)

Para:

para cada String que está na lista, conforme referenciado pela variável stringlist

...qualquer dia!

A sintaxe é importante para quem está aprendendo, quanto menor a barreira de entrada, mais popular o idioma pode ser inicialmente. Mas se a linguagem é difícil ou impossível de se expressar rica e sucintamente, ela começará a murchar em popularidade.

Muito conciso e opaco (Perl) é tão ruim quanto excessivamente detalhado e prolixo (AppleScript).

É preciso haver equilíbrio, menor barreira à entrada, alta produtividade e fácil manutenção.

Outra coisa a considerar é que as linguagens de programação com sintaxe mais agradável são mais fáceis de analisar, tornando o compilador mais fácil de escrever, mais rápido e menos propenso a erros.

Simplificando: a sintaxe, como tal, não importa. A semântica que você pode expressar através dela é importante.