Não importa o quanto você goste de uma linguagem de programação, sempre há alguns detalhes que não são tão bons quanto poderiam ser.

Nesta pergunta, eu gostaria de focar especificamente nos elementos de sintaxe. Em uma linguagem de programação que você usa com freqüência (talvez a sua linguagem de programação favorita ou a que você é forçada a usar no trabalho), qual elemento de sintaxe você acha mais ilegível, obscuro, inconveniente ou desagradável?

Inserção de ponto e vírgula em JavaScript.

Eu realmente não fui mordido por isso com frequência, mas é uma idéia tão fenomenalmente ruim que faz minha cabeça girar.

Aqui estão as regras (da seção 7.9 da ECMA-262)

1. Quando o programa contém um token que não é permitido pela gramática formal, um ponto-e-vírgula é inserido se (a) houver uma quebra de linha nesse ponto ou (b) o token inesperado for uma chave de fechamento.
2. Quando o final de um arquivo é atingido, se o programa não puder ser analisado de outra forma, um ponto-e-vírgula é inserido.
3. Quando uma "produção restrita" é encontrada e contém um terminador de linha em um local onde a gramática contém a anotação "[sem LineTerminator aqui]" ", um ponto-e-vírgula é inserido.

Exemplo:

return 1; // returns 1

return
1; // returns undefined

Sintaxe de Java-bean devido à falta de propriedades de C #

/**
 * Name of user
 */
private String name;

/**
 * Gets name of user
 * @return Name of user
 */
public String getName() {
    return this.name;
}

/**
 * Sets name of user. 
 * @param name
 */
public void setName(final String name) {
    this.name = name;
}

GAH !!!

Problemas que tenho com isso

• Demasiado código - Tenha um campo documentado, um método getter que esteja documentado e um método setter que esteja documentado. Este exemplo extremamente básico possui 20 linhas de código para uma única propriedade
• Clutter método listas - "Deixe-me encontrar esse método, mão em: getX, getY, getZ, getAnotherAnnoyingField, getWhyIHateJavaBeans, getThisIsVerbose, getGAH... ah lá está, hashCode.
• Várias áreas de documentação levam a documentação ruim, desatualizada ou ausente - irritante ao tentar entender o que o código faz
• Tão irritante que um terceiro tenha que criar um plugin para fazer isso facilmente - Spoon , Shark , entre outros.

Sensibilidade de espaço em branco.

Python me irrita a esse respeito. Quero dizer, eu recuo corretamente de qualquer maneira, mas me incomoda que eu precise . Tornar a apresentação parte da sintaxe me irrita.

A switchinstrução (em C, C ++, C #, Java etc.)

Aqui está um exemplo de por que considero altamente inconveniente:

switch (someVariable)
{
    case 1:
        int i = something();
        doSomething(i);
        break;

    case 2:
        int i = somethingElse();
        doSomethingElse(i);
        break;
}

Isso não é compilado porque a variável ié redeclarada no mesmo escopo. Parece um pequeno detalhe, mas me morde com muita frequência. Posso adicionar colchetes para atenuá-lo, mas seria bom se os colchetes fossem parte obrigatória da sintaxe e não houvesse um nível extra redundante de recuo. Eu também odeio ter que escrever o extra break. Isso seria muito melhor:

switch (someVariable)
case 1
{
    int i = something();
    doSomething(i);
}
case 2
{
    int i = somethingElse();
    doSomethingElse(i);
}
default
{
    ...
}

Isso faz com que pareça mais com uma cadeia if/ else, o que é uma coisa boa porque é semanticamente semelhante também. Pelo menos em C #, ainda assim não seria a mesma coisa, porque em uma switchdeclaração a ordem dos rótulos dos casos não importa, mas em um if/ elseisso importa.

Declarações de matriz em VB.NET

Sempre esqueço que, ao inicializar matrizes fixas no VB.NET, você especifica o limite superior da matriz e não o número de elementos, como em C / C ++, PHP ou Java. Além do VB6 (não vamos lá ...), não consigo pensar em outra linguagem que faça dessa maneira:

Dim myArray(20) as Integer  '# Creates an array with 21 elements,
                            '# indexed from 0 to 20

VB6 - Declaração e atribuição de variáveis ​​separadas

A maioria dos idiomas permite declarar uma variável e atribuí-la em uma linha de código; O VB6, por outro lado, força você a usar dois.

Dim i as Integer
i = 0

Dim derpderp as Collection
Set derpderp = new Collection

Você pode usar dois pontos para colocar dois comandos em uma linha, mas rapidamente fica confuso no código real.

Dim i as Integer: i = 0
Dim derpderp as Collection: Set derpderp = new Collection

Comentando em CSS

//não comenta linhas de código como em muitas outras línguas, como PHP e Javascript. Embora /* this is commented out */funcione, eu prefiro usar //.

É um incômodo, porque na metade do tempo eu esqueço que estou editando CSS e depois tenho que voltar e corrigir o erro.

PHP - ordenação consistente de argumentos

O PHP possui várias funções úteis para executar praticamente todas as operações que você pode imaginar em um array ou string. Muitas dessas operações requerem o uso de a $needlee a $haystack, mas funções diferentes as levam em ordens diferentes. Qual função requer quais argumentos é um daqueles fatos que meu cérebro se recusa a absorver, não importa quantas vezes eu os encontre!

Tome as funções in_array e strstr :

// Check whether $needle occurs in array $haystack
bool in_array (mixed $needle, array $haystack [, bool $strict])

// Check whether $needle is a substring of $haystack
string strstr (string $haystack, mixed $needle [, bool $before_needle=false])

Curiosamente, o PHP parece ser internamente consistente com essas ordenações, pois todas as funções de string parecem usar $haystack, $needleenquanto as funções de array são inversas, mas isso pode demorar um pouco para se acostumar com alguém novo no PHP. Há um bom post no ExpressionEngine falando sobre essa peculiaridade específica em mais detalhes, bem como uma discussão na lista de bugs do PHP , que apresenta uma resposta muito curta da equipe do PHP!

helly@php.net
Use um IDE decente então.

Python

self parâmetro nas definições de método da instância

Java

Período. Ponto final. Fim da história.

Onde começar? Ah, eu sei por onde começar: os genéricos incrivelmente complicados, feios, estúpidos e inerentemente quebrados de Java . Preciso dizer mais? :( Ok, tudo bem, então: digite apagamento .

Depois, há um gerenciamento não determinístico de recursos. Kewl footcher!

O que vem a seguir? Ah, sim: as expressões estúpidas de Java são a minha carne mais irritante e fervilhante. Não sei contar quantas vezes fui manejado por não ter barras invertidas suficientes. Isso é ainda pior do que não ter acesso a nenhuma propriedade Unicode deste milênio - o que é um touro completo. Dez anos de desatualização desatualizados !!! Completamente inútil. Jogue fora.

Depois, há o erro de que os atalhos da classe de caracteres não funcionam em não-ASCII. Que dor real! E nem pense em usar \p{javaWhiteSpace}; ele não faz a coisa certa com vários pontos de código de espaço em branco Unicode muito comuns.

Você sabia que há um \p{javaJavaIdentifierStart} propriedade? O que eles estavam pensando? Tão contentes por terem peepers tão espertos que se desentendem.

Já tentou usar o sinalizador CANON_EQ? Você sabe o que realmente faz e o que não faz? Que tal o chamado "caso Unicode"? Um monte de coisas normais da caixa simplesmente não funcionam.

Eles dificultam a criação de regexes de manutenção. O Java ainda não descobriu como escrever strings de múltiplas linhas, então você acaba escrevendo coisas insanas como esta:

    "(?= ^ [A-Z] [A-Za-z0-9\\-] + $)      \n"
  + "(?! ^ .*                             \n"
  + "    (?: ^     \\d+      $            \n"
  + "      | ^ [A-Z] - [A-Z] $            \n"
  + "      | Invitrogen                   \n"
  + "      | Clontech                     \n"
  + "      | L-L-X-X                      \n"
  + "      | Sarstedt                     \n"
  + "      | Roche                        \n"
  + "      | Beckman                      \n"
  + "      | Bayer                        \n"
  + "    )      # end alternatives        \n"
  + ")          # end negated lookahead   \n" 

Quais são todas essas novas linhas? Oh, apenas estupidez em Java. Eles usaram comentários Perl, não comentários Java ( idiotas! ), Que vão até o final da linha. Portanto, se você não colocar as que \nestão lá, corta o restante do seu padrão. Duh e double duh!

Não use expressões regulares em Java: você acabará querendo esmagar as coisas, tudo é tão doloroso e quebrado. Não acredito que as pessoas aguentam isso. Alguns não .

Então podemos começar a falar sobre o absurdo idiota de Java com codificações. Primeiro, há o fato de que a codificação da plataforma padrão é sempre uma codificação sem graça de 8 bits, mesmo que os charchars de Java sejam Unicode. Depois, há como eles não geram uma exceção em um erro de codificação. Você está garantido para receber porcaria. Ou que tal:

OutputStreamWriter(OutputStream out) 
          Creates an OutputStreamWriter that uses the default character encoding.
OutputStreamWriter(OutputStream out, Charset cs) 
          Creates an OutputStreamWriter that uses the given charset.
OutputStreamWriter(OutputStream out, CharsetEncoder enc) 
          Creates an OutputStreamWriter that uses the given charset encoder.
OutputStreamWriter(OutputStream out, String charsetName) 
          Creates an OutputStreamWriter that uses the named charset.

Qual é a diferença? Você sabia disso apenas um deles gerará uma exceção se você tiver um erro de codificação? O resto apenas açaima.

Depois, há a idiotice dos caracteres Java que não são suficientes para conter um caractere! Que diabos eles estão pensando? É por isso que eu os chamo de caracteres. Você precisa escrever um código como este se espera que funcione corretamente:

private static void say_physical(String s) { 
    System.out.print("U+");
    for (int i = 0; i < s.length(); i++) {
        System.out.printf("%X", s.codePointAt(i));
        if (s.codePointAt(i) > Character.MAX_VALUE) { i++; }  // UG!
        if (i+1 < s.length()) { System.out.printf("."); }
    }
}

E quem pensa em fazer isso? Ao lado de ninguém.

Quantos caracteres existem "\uD83D\uDCA9"? Um ou dois? Depende de como você os conta. É claro que o mecanismo regex lida com caracteres lógicos, portanto, um padrão ^.$será bem-sucedido e ^..$falhará. Essa loucura é demonstrada aqui:

String { U+61, "\u0061", "a" }  =~ /^.$/ => matched.
String { U+61, "\u0061", "a" }  =~ /^..$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" }  =~ /^.$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" }  =~ /^..$/ => matched.
String { U+DF, "\u00DF", "ß" }  =~ /^.$/ => matched.
String { U+DF, "\u00DF", "ß" }  =~ /^..$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" }  =~ /^.$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" }  =~ /^..$/ => matched.
String { U+3C3, "\u03C3", "σ" }  =~ /^.$/ => matched.
String { U+3C3, "\u03C3", "σ" }  =~ /^..$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" }  =~ /^.$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" }  =~ /^..$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "💩" }  =~ /^.$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "💩" }  =~ /^..$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "💩💩" }  =~ /^.$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "💩💩" }  =~ /^..$/ => matched.

Essa idiotice é tudo porque você não pode escrever o texto perfeitamente razoável \u1F4A9 , nem é claro que recebe qualquer aviso de que não pode fazer isso. Apenas faz a coisa errada.

Stoooopid.

Enquanto estamos nisso, toda a \uXXXXnotação é congenitamente com morte cerebral. O pré-processador Java ( sim, você me ouviu ) chega antes do Java, então você está proibido de escrever coisas perfeitamente razoáveis ​​como "\u0022", porque, quando o Java vê isso, seu pré-processador o transformou """, então você perde. Oh espere, não se estiver em um regex! Então você pode usar"\\u0022" muito bem.

Riiiiiiiight!

Você sabia que não há como o Java fazer uma isatty(0) ligação? Você nem tem permissão para pensar em tais pensamentos. Não seria bom para você.

E depois há toda a abominação do caminho de classe.

Ou o fato de que não há como especificar a codificação do seu arquivo de origem Java no mesmo arquivo de origem para não perdê-lo? Mais uma vez eu exijo saber: O QUE diabos eles estavam pensando‽‽‽

Pare a loucura! Não acredito que as pessoas suportam esse lixo. É uma piada completa. Prefiro ser um cumprimentador do Walmart do que sofrer os golpes e flechas da insanidade ultrajante em Java. Está tudo quebrado, e eles não apenas não podem consertar, mas não consertam.

Isso pelas mesmas pessoas engraçadas que se orgulhavam de uma linguagem que tornava ilegal ter uma printf()função. Puxa, isso certeza funcionou muito bem, não foi !?

Pura numbskulls. Tapa na puta é muito gentil para eles. Se eu quisesse programar em assembler, faria. Esta não é uma linguagem salvável. O imperador não tem nenhuma roupa.

Nós odiamos isso. Nós odiamos isso para sempre . Deixe morrer, morrer, morrer !

Sintaxe de declaração de ponteiro de função em C e C ++:

(int)(*f)(int, int);

Isso declara um ponteiro de função chamado fcujo pontapé pode levar dois se intretornar um int.

Eu preferiria uma sintaxe como esta:

f: (int, int) => int

Digamos que você queira declarar um ponteiro de função gcujo pontapé pode levar dois se intuma função de inte intpara inte retornar um int.

Com a notação C ou C ++, você a declararia como:

(int)(*g)(int, int, int(int, int));

Com a notação proposta acima, pode-se declarar a mesma coisa que:

g: (int, int, (int, int) => int) => int

O último é IMO muito mais intuitivo.

Além: A linguagem de programação chamada OOC corrige esta sintaxe (e vários outros problemas sintáticos em C e C ++). Confira sua página inicial aqui .

Verbosidade em Java.

ou seja:

public static final int 

\ we \ wouldnt \ fixar \ nossa \ sintaxe do espaço para nome do analisador no PHP

A sintaxe não é apenas feia, mas também gera confusão quando os desenvolvedores mais novos precisam pensar em namespaces em strings. (O PHP interpola barras invertidas em seqüências de caracteres com aspas duplas como seqüências de escape. Tentar representar um espaço para nome como \you\should\never\do\thatem uma sequência de aspas duplas em vez de uma sequência de aspas simples levará a novas linhas, guias e desastres.)

Eu desprezo o fato de que o aparelho pode ser opcional após uma declaração if / while / for.

Especialmente quando vejo código como,

if (...)
    for(...)
        ... One line of stuff ...

Por favor, apenas coloque os aparelhos e termine com isso.

O VBScript não possui operadores lógicos

Diferente de quase toda linguagem sensata, o VBScript usa operadores bit a bit em vez de operadores lógicos. O que isso significa na prática? Bem, como Eric Lippert aponta :

If Blah = True Then Print "True!" Else Print "False!"

e

If Blah Then Print "True!" Else Print "False!"

NÃO são iguais no VBScript!

Pior ainda, isso significa que não há avaliação de curto-circuito no VBScript, de modo que a instrução a seguir irá travar seu programa se BlahforNothing

If (Not Blah Is Nothing) And (Blah.Frob = 123) Then
...

É isso mesmo, o VBScript avaliará as duas partes da comparação AND, mesmo que a primeira seja falsa! Apenas deixe isso afundar ...

EDIT: Após a discussão nos comentários, decidi atualizar esta resposta para me explicar melhor.

Eu realmente odeio a maneira como os ponteiros de função aparecem em C. Normalmente, qualquer declaração de variável se parece com uma tupla de: type varname; Declarações de ponteiros de função, por outro lado, parecem com uma declaração da função com * antes do nome da função. Eu posso aceitar isso como uma descrição de um tipo de ponteiro, mas em C isso declara o tipo e o nome de uma variável desse tipo. Isso me parece inconsistente porque as declarações de tipo são diferentes das declarações de variáveis. struct myStruct{int X; int Y;}define apenas um tipo, que não define uma variável chamada myStruct. Da mesma forma, não vejo razão para as declarações de tipo e variável serem agrupadas em uma instrução atômica em ponteiros de função, nem aprecio o desvio da type varname;estrutura.

Alguém apontou que é consistente com alguma regra em espiral, e esse pode ser o caso, mas a marca de uma boa sintaxe é que ela é auto-explicativa e sua lógica interna é óbvia. A regra da espiral não é óbvia de forma alguma.

Ponto e vírgula no VBScript - ou a falta dela

Passo o dia inteiro trabalhando em idiomas que esperam ponto e vírgula no final de cada linha. Adicione um ao final da linha no VBScript e seu código não será mais executado.

Argumentos de entrada / saída. Sou a favor de argumentos (que bom que sou), argumentos fora também são bons, mas um argumento que deve transmitir esses dois estados me irrita.

O que eu alvo aqui são funções que recebem entrada de um parâmetro e substituem essa entrada com alguma saída. Não há problema em passar um objeto por referência para atualizá-lo. Mas, principalmente para tipos primitivos, pegar um objeto, usá-lo e depois alterá-lo completamente, não é certo para mim. Você não deve alterar o significado do argumento através de uma entrada.

Declarações de matriz em C e C ++.

Normalmente, uma declaração variável é do formato type variable_name. Você pode facilmente ler essas declarações da esquerda para a direita. Mas, int foo[size]a princípio, parece que ele está declarando foocomo int, e então você lê mais e vê os foo do tipo "matriz de números inteiros". int[size] foolê muito melhor.

E eu também odeio quando programadores declarar ponteiros como este por um motivo semelhante: int *foo. Por alguma razão eu não descobri, esse é o típico jeito que está escrito.

Parametrização redundante em Java:

HashMap<String,HashMap<String,String>> foo = new HashMap<String, HashMap<String, String>>();

Que outro tipo de parametrização o compilador acha que foo poderia ter?

Como as pessoas já se queixaram de =vs. ==, deixe-me apontar uma alternativa muito pior. O PL / eu tinha ambos :=e =, mas quando algo era "obviamente" uma tarefa, isso permitiria que você se =desse bem. Usando:= permite forçar algo a ser uma atribuição em uma situação em que o compilador o interpretaria como uma comparação.

Infelizmente, o compilador nem sempre decidiu as coisas da maneira que você poderia esperar. Considere apenas um exemplo óbvio:

A = B = 0;

Agora, para a maioria das pessoas familiarizadas com a maioria das linguagens "comuns", o significado disso é bastante óbvio - atribua 0 a A e B. PL / I é apenas um pouco ... diferente. Por razões conhecidas apenas pelos designers (insanos) da linguagem, o primeiro =é interpretado como uma tarefa, mas o segundo= é interpretado como uma comparação. Portanto, isso compara B a 0 e atribui o resultado dessa comparação a A (seguindo a convenção no estilo C que "false" resulta em 0 e "true" em 1).

Portanto, se B era 0, então A se torna 1. Caso contrário, A se torna 0. Em outras palavras, em vez de atribuir o mesmo valor a A e B, isso realmente garante que A não possa ter o mesmo valor que B.

Conclusão: embora o estilo C / C ++ / PHP pareça inicialmente uma dor, a alternativa é muito pior ¹ .

¹ Bem, tecnicamente, há outra alternativa: o estilo Pascal, onde =sempre significa comparação e atribuição sempre exige :=. Depois de usar isso por um tempo, é bastante óbvio (pelo menos para mim) que a tarefa é bastante mais comum do que a comparação. Se você precisar de "coisas" extras para desambiguar os dois, você definitivamente deve manter as tarefas limpas e simples e exigir o "grunge" extra nas comparações, não vice-versa.

Perl

1. Desejo que Perl me deixe escrever if($x < 10) do_something();. No momento, você deve escrever isso como do_something() if($x < 10);ou como if($x < 10) { do_something(); }.

reinterpret_cast<unsigned long>em c ++. Essa operação é útil para lidar com APIs estrangeiras e garantir precisão numérica. Por que seria tão difícil digitar e tão feio de se olhar?

A construção for ... in em JavaScript e a construção foreach em PHP ao fazer um loop sobre matrizes. Ambos facilitam a gravação de bugs do que o código correto.

Ponteiros de matrizes ou matrizes de ponteiros em C / C ++. Eu ainda estou confuso sobre isso.

O fato de o Python confiar na formatação de texto.

Javascript / Java etc, é igual a comparação, por exemplo, se (a == 1)

Quantas vezes escrevo se (a = 1)?

Como humano, eu li isso perfeitamente. Mas o danado intérprete / compilador diz: "ei, atribuirei 1 a a, depois verifico se a é igual a 1 e você acreditaria que sim!

Me leva até a parede.

se (a == 1) é muito menos legível, e o intérprete / compilador deve saber o que quero dizer; muitos outros idiomas menores (VB) vêm trabalhando com êxito há centenas de anos.

Verbosidade em classes anônimas Java. Esperemos que seja corrigido em breve.

structPointer->memberem C / C ++. Pode ser bom para ler o código de outra pessoa, mas não gosto. Dois caracteres em vez de um ... que desperdício de espaço!

Código multi-linhas Scala entre parênteses

Por exemplo:

class Foo(
         val bar: String,
         val baz: Int,
         val bing: String,
         val bong: Boolean
 ) extends Model {
   // body here
 }

O que você realmente obtém é fantástico. Ele gera o construtor e os getters e setters para você. Mas com certeza é feio e quebra todos os meus modelos mentais de como recuar código e basicamente me deixa como se eu estivesse em uma espécie de sanduíche bizarro com Java de um lado e Lisp do outro. (Oh, espere ... esse é o ponto de Scala.)