Quelles sont les cinq choses que vous détestez à propos de votre langue préférée?

Il y a eu un groupe de haine Perl sur Stack Overflow ces derniers temps, alors j’ai pensé poser ma question « Cinq choses que vous détestez sur votre langue préférée » à Stack Overflow. Prenez votre langue préférée et dites-moi cinq choses que vous détestez à ce sujet. Celles-ci peuvent être des choses qui vous ennuient, admettent des défauts de conception, des problèmes de performance reconnus ou toute autre catégorie. Vous devez juste le détester, et cela doit être votre langue préférée.

Ne le comparez pas à une autre langue et ne parlez pas de langues que vous détestez déjà. Ne parlez pas des choses que vous aimez dans votre langue préférée. Je veux juste entendre les choses que vous détestez mais que vous tolérez afin que vous puissiez utiliser toutes les autres choses, et je veux entendre parler du langage que vous souhaitiez que d’autres personnes utilisent.

Je le demande à chaque fois que quelqu’un essaie de repousser ma langue préférée sur moi, et parfois comme question d’interview. Si quelqu’un ne peut pas trouver cinq choses à détester à propos de son outil préféré, il ne le sait pas assez pour le préconiser ou en retirer les gros dollars en l’utilisant. Il ne l’a pas utilisé dans suffisamment de situations différentes pour l’explorer complètement. Il le préconise en tant que culture ou religion, ce qui signifie que si je ne choisis pas sa technologie préférée, je me trompe.

Je me fiche de savoir quelle langue vous utilisez. Vous ne voulez pas utiliser une langue particulière? Alors ne le faites pas. Vous faites preuve de diligence raisonnable pour faire un choix éclairé et ne l’utilisez toujours pas? Bien. Parfois, la bonne réponse est “Vous avez une équipe de programmation solide avec de bonnes pratiques et une grande expérience de Bar. Changer pour Foo serait stupide.”


Ceci est une bonne question pour les revues de code aussi. Les personnes qui connaissent vraiment une base de code auront toutes sortes de suggestions, et ceux qui ne la connaissent pas ont des plaintes non spécifiques. Je demande des choses comme “Si vous pouviez recommencer ce projet, que feriez-vous différemment?” Dans ce monde fantastique, les utilisateurs et les programmeurs se plaignent de tout et de rien. “Je veux une meilleure interface”, “Je veux séparer le modèle de la vue”, “J’utiliserais ce module au lieu de celui-ci”, “Je renomme cet ensemble de méthodes”, ou quoi que ce soit d’autre n’aime pas la situation actuelle. C’est comme ça que je sais à quel point un développeur particulier connaît la base de code. C’est aussi un indice sur la part de l’ego du programmeur dans ce qu’il me dit.

La haine n’est pas la seule dimension de savoir combien de personnes savent, mais je l’ai trouvé très bon. Les choses qu’ils détestent me donnent également une idée de la façon dont ils pensent au sujet.

    Cinq choses que je déteste à propos de Java:

    • Pas de fonctions de première classe.
    • Aucune inférence de type.
    • Manque de valeurs par défaut, par exemple dans les graphiques.
    • NullPointerException ne contenant pas plus d’informations sur ce qui est nul.
    • La prolifération des interfaces / fournisseurs de services / classes d’usine / systèmes d’dependency injections «configurables» inutiles. La configurabilité n’est quasiment jamais utilisée, le DRY est violé de manière flagrante et la taille et la moitié de la lisibilité du code sont multipliées par quatre.

    Je sais, je devrais vérifier Scala.

    Wow, je suis surpris que SQL ne soit pas encore arrivé. Devinez cela signifie que personne n’aime ça 🙂

    • Syntaxe incohérente à travers les implémentations
    • Des différences de code subtiles peuvent avoir d’importantes répercussions sur les performances pour des raisons apparemment obscures
    • Mauvaise prise en charge de la manipulation de texte
    • Coût d’entrée facile mais apprentissage rapide vers la maîsortingse de la langue
    • Normalisation minimale dans la communauté pour les meilleures pratiques, cela inclut le style de syntaxe.

    … Et quelques bonnes raisons de le détester, sans frais supplémentaires

    • La clause WHERE va en dernier, ce qui facilite l’exécution prématurée d’un UPDATE ou DELETE, détruisant la table entière. Au lieu de cela, le WHERE devrait aller quelque part à l’avance.
    • Il est difficile de mettre en œuvre une division relationnelle.
    • Je peux définir une valeur sur NULL, mais je ne peux pas la tester pour une égalité avec NULL. Je peux vérifier IS NULL, mais cela ne fait que compliquer le code – inutilement, à mon avis.
    • Pourquoi devons-nous complètement redéfinir la formule pour une colonne GROUPed, plutôt que de définir un alias sur la colonne et ensuite GROUP BY l’alias (ou l’index de colonne comme avec SORT)?

    JavaScript :

    1. Toutes les choses les plus cool sont incroyablement complexes, mais ensuite, toute la fraîcheur est aussi tellement petite que vous vous sentez stupide de la suivre.

    2. ‘+’ est un choix absurde d’opérateur de concaténation dans un langage faiblement typé. Étaient-ils en train de faire peur aux noobs?

    3. C’est un champ de mines compatible avec tous les navigateurs (peu importe s’il est allumé ou non)

    4. Il n’est généralement pas fiable – associé au scummery tel que le blocage du bouton de retour, les pop-ups qui ne meurent jamais, etc.

    5. Il est presque impossible de déboguer car il n’y a que quelques messages d’erreur différents et quelques types différents (Number, Ssortingng, Object, etc.)

    Si ce n’était pas pour jQuery, je le détesterais probablement encore autant qu’avant 🙂

    PHP:

    1) me force à créer des variables inutiles:

     $parts = explode('|', $ssortingng); $first = $parts[0]; 

    2) Une implémentation de lambdas tellement boiteuse équivaut à peu près à utiliser eval() et si horriblement faux que je ne l’ai jamais utilisée (voir http://www.php.net/create_function ).

    3) Un système try / catch qui ne peut capter que 80% des erreurs éventuelles.

    4) Regex supporte tout aussi peu que le support lambda car il doit être écrit à l’intérieur de chaînes régulières, ce qui rend l’un des outils de programmation les plus difficiles à apprendre environ trois fois plus difficile. Et PHP est censé être un langage “facile”?!?!?

    5) Aucun moyen de retirer en toute sécurité des trucs de $ _POST sans les écrire deux fois, ni créer votre propre fonction, ni utiliser l’opérateur ‘@’:

     $x = isset($_POST['foo']['bar']) ? $_POST['foo']['bar'] : null; 

    6) Réponse en bonus: ‘@’. Si vous ne pouvez pas vous soucier d’écrire votre code correctement, ajoutez simplement “@”, et tant pis pour quiconque doit déboguer votre code ultérieurement.

    C ++

    • Il est beaucoup trop facile de corrompre au hasard la mémoire et de créer des bogues presque impossibles à trouver (bien que Valgrind fasse beaucoup de chemin pour corriger cela).
    • Messages d’erreur de modèle.
    • Lorsque vous utilisez des modèles, il est facile de tout inclure dans un seul fichier et d’obtenir des temps de compilation stupides.
    • La bibliothèque standard est une blague à l’ère moderne (toujours pas de threads ou de réseau par défaut?)
    • Beaucoup de petits morceaux de C piquant (en particulier, toutes les conversions entre short / int / unsigned / etc ..)

    C # / .NET:

    • Les classes doivent être scellées par défaut
    • Il ne devrait y avoir aucune instruction de lock – au lieu de cela, vous devriez avoir des objects de locking spécifiques, et il devrait y avoir des méthodes telles que Acquire qui renvoient des jetons de locking jetables. Corollaire: il ne devrait pas y avoir de moniteur pour chaque object.
    • GetHashCode() et Equals() ne devraient pas être dans System.Object – tout ne convient pas au hachage. A la place, ayez un IdentityComparer qui fait la même chose et conservez les IComparer , IComparable , IEqualityComparer et IEquatable pour des comparaisons personnalisées.
    • Mauvaise prise en charge de l’immuabilité
    • Mauvaise façon de découvrir les méthodes d’extension – cela devrait être une décision beaucoup plus consciente que le simple fait d’utiliser un espace de noms.

    Celles-ci étaient sur le dessus de ma tête – demandez-moi demain et je vais vous proposer un autre 5 🙂

    C

    • manipulation de chaîne.

    Avoir à traiter manuellement avec les tampons de chaîne est une douleur sujette aux erreurs. Étant donné que tant d’informatique bouge et modifie vraiment les chaînes (les ordinateurs ne sont pas autant utilisés pour les calculs importants que ceux qui pensaient qu’ils remonteraient très loin), il est vraiment agréable de pouvoir utiliser les langages gérés ou les chaînes C ++. objects à traiter avec eux. Quand je dois le faire en C droite, on a l’impression de nager dans les sables mouvants.

    Que dirais-tu de cinq choses que je déteste à propos des listes “Choses que je déteste à propos de certaines langues”? :RÉ

    5- Peindre un rouge orange n’en fait pas une pomme.

    Lorsqu’une langue est conçue, les concepteurs ont généralement en tête ce qui est utile. L’utiliser pour quelque chose de complètement différent peut fonctionner, mais se plaindre quand ce n’est pas le cas est stupide. Prenez Python. Je suis sûr que quelqu’un ou quelqu’un va un jour créer un utilitaire pour créer des exe à partir de code Python. Pourquoi sur la terre de Dieu voudriez-vous faire cela? Ce serait bien, ne vous méprenez pas, mais cela ne sert à rien. Alors arrête de te plaindre!

    Un projet bien conçu contiendrait probablement du code de plusieurs langues. Cela ne veut pas dire que vous ne pouvez pas terminer un projet avec une seule langue. Certains projets peuvent être dans les capacités de la langue que vous utilisez.

    4- Êtes-vous debout sur des jambes en bois?

    La plate-forme peut avoir une grande influence sur ce que le langage peut faire. Avec de nos jours les éboueurs, ou même les pascals tentent tôt le “ramassage des ordures”, peuvent aider à la mémoire fondue (peut-être plus malloc). Les ordinateurs sont plus rapides et, bien sûr, nous attendons plus de nos langues. Et franchement, nous devrions probablement. Cependant, le compilateur doit payer un prix énorme pour créer des tables de hachage, des chaînes de caractères ou divers autres concepts. Ces choses peuvent ne pas être héritées de la plate-forme sur laquelle elles sont utilisées. Dire qu’ils sont faciles à inclure dans une langue me dit simplement que vous n’avez peut-être pas de jambe sur

    3- Qui est la faute est-ce vraiment?

    Bogues. Tu sais. J’adore les insectes. Pourquoi est-ce que j’aime les insectes? Parce que ça veut dire que je peux garder mon travail. Sans insectes, il y aurait beaucoup de pizzerias fermées. Cependant, les utilisateurs détestent les bogues. Mais voici un peu d’eau froide. Chaque bug est la faute du programmeur. Pas la langue. Un langage avec une syntaxe si ssortingcte qui réduirait de manière significative le nombre de bogues possibles à générer serait un langage totalement inutile. Ses capacités pourraient probablement être comptées sur une main. Vous voulez de la flexibilité ou du pouvoir? Vous avez des bugs. Pourquoi? Parce que vous n’êtes pas parfait et que vous faites des erreurs. Prenons un exemple vraiment identifiable en C:

     int a[10]; for (int idx = 0; idx < 15; idx++) a[idx] = 10; 

    Nous soaps tous ce que cela va faire. Cependant, ce que certains d'entre nous ne réalisent peut-être pas, c'est que cette fonctionnalité peut être très bénéfique. Selon ce que vous faites. Les dépassements de tampon représentent le coût de cette fonctionnalité. Ce code ci-dessus. Si j'ai effectivement rendu cela au public. C'est encore une fois ... dis-le avec moi .. "Ma faute". Pas C pour m'avoir permis de le faire.

    2- Ne devrions-nous pas mettre ça dans la corbeille?

    Il est très facile de désigner une fonctionnalité dans une langue que nous ne comprenons pas parce que nous ne l'utilisons pas souvent et que nous l'appelons stupide. Se plaindre que c'est là, etc. Goto me divertit toujours. Les gens se plaignent toujours que goto soit dans une langue. Pourtant, je parie que votre dernier programme comprenait un type de goto. Si vous avez déjà utilisé une pause ou une pause, vous avez utilisé un goto. C'est ce que c'est Certes, c'est un "sûr" goto, mais c'est ce que c'est. Goto a ses utilisations. Si des gotos "implicites" tels que continue ou break sont utilisés ou des gotos explicites (en utilisant le mot clé "goto" pour n'importe quelle langue). Ce ne sont pas les développeurs de langues qui sont parfaits, mais généralement ... si la fonctionnalité existe depuis la nuit des temps (pour cette langue). Cet aspect est probablement une qualité déterminante de cette langue. Signification .. il est utilisé et ne traîne probablement pas à cause de la compatibilité ascendante. Il est utilisé aujourd'hui. Comme il y a 5 minutes. Et utilisé correctement. Eh bien, sans doute quelqu'un l'utilise mal aussi, mais cela se rapporte à # 3 sur ma liste.

    1. - Tout est un object.

    Ok .. celui-ci est vraiment un sous-ensemble de # 2. Mais c'est de loin la plainte la plus ennuyeuse que je vois dans les listes de haine. Tout n'est pas un object. Il y a beaucoup de concepts qui n'appartiennent pas ou doivent être des objects. Mettre des choses auxquelles elles n'appartiennent pas est tout simplement laid et peut nuire à l'efficacité d'un programme. Sûr. Peut-être pas beaucoup en fonction de la langue. Cela concerne également le numéro 5. Cela signifie que oui. Global sont ok. Les fonctions telles qu’appliquées aux méthodes statiques sont correctes. La combinaison de la programmation OO avec les fonctions globales est correcte. Maintenant, cela ne signifie pas que nous devrions tous sortir et "libérer" notre code à partir de ses modèles d'object. Lors de la conception d'une section de code ou d'un projet entier, ce qui se passe en coulisse doit être pris en compte lors de la mise en place. Pas seulement où ce concept vit et de nombreux autres facteurs. Pourquoi envelopper des fonctions globales dans des classes ou des concepts d'espace de noms si cela ne sert à rien? Prendre des variables membres statiques. Cela m'amuse énormément parce que .. bien..Selon le langage et la mise en œuvre bien sûr, mais en général, vous venez de déclarer un global. Oui, il y a des raisons d'encapsuler ces concepts non-OO dans des encapsuleurs OO. L'un étant bien sûr un code d'auto-documentation. Cela peut avoir du sens. Donc ... comme je le dis. Ne sortez pas et "libérez" votre code. Mais tout bon langage moderne aura un concept global en dehors de la modélisation OO. Oui, je veux dire que le langage de programmation OO sans concept global a probablement un sérieux défaut de conception. Encore une fois, .. dépend de l'intention et de la conception du langage, donc je n'essaie pas de choisir une langue spécifique et il y a beaucoup trop de choses à parsingr ici. Anywho, Considérez où le code devrait vivre et être le plus efficace. L'ajout d'un flare à quelque chose qui n'ajoute pas de fonctionnalités ou de support ne fait que réduire le temps de travail du clavier. Cela ne sert à personne. Eh bien, sauf si vous aimez les points brownie de la personne qui vous a probablement appris à tort que tout est un object.

    En bref, la programmation ne consiste pas simplement à taper sur le clavier. Il y a beaucoup de considérations de conception à tout projet. Je sais que c'est un cliché, mais vous devez le regarder sous tous les angles. Même avec les langages de type actuel. Vous ne devez pas simplement supprimer le code et vous attendre à ce qu'il fonctionne correctement. Bien sûr ... ça peut marcher, mais ce n'est peut-être pas la bonne façon de s'y prendre. Dans l'ensemble, choisissez la langue et le format les mieux adaptés au travail spécifique et à l'environnement. Mais aucune langue n'enlève la pensée. Si vous ne pensez pas, vous ne faites que taper.

    Cinq choses que je déteste à propos de Java (qui, actuellement, est ma langue préférée) sans ordre particulier.

    1. Même si je suis un fan de Java Generics, il y a beaucoup de bizarreries dans sa conception. En tant que tel, il existe une myriade de limitations gênantes avec les génériques (dont certains résultent d’un effacement de type).
    2. La façon dont fonctionnent Object.clone () et les interfaces clonables est totalement rompue.
    3. Au lieu de prendre la route et de tout transformer en object (par exemple SmallTalk), Sun a créé deux catégories distinctes de types de données: les objects et les primitives. En conséquence, il existe maintenant deux représentations pour les types de données fondamentaux et les curiosités bizarres telles que la boxe / unboxing et l’impossibilité de placer des primitives dans une collection.
    4. Le swing est trop complexe. Ne vous méprenez pas: il y a beaucoup de choses intéressantes à faire avec Swing, mais c’est un excellent exemple d’ingénierie.
    5. Cette plainte finale est également la faute de Sun et de ceux qui ont écrit des bibliothèques XML pour Java. Les bibliothèques Java XML sont bien trop compliquées. Pour simplement lire dans un fichier XML, je dois souvent m’inquiéter de quel parsingur j’utilise: DOM ou SAX? Les API pour chacun sont également déroutantes. Un support natif dans le langage pour parsingr / écrire facilement du XML serait très bien.
    6. java.util.Date est nul. Non seulement est-il inutilement compliqué, mais toutes les méthodes utiles ont été désapprouvées (et remplacées par d’autres qui augmentent la complexité).

    Ruby a beaucoup de défauts liés à sa vitesse, mais je ne les déteste pas. Cela a aussi des défauts avec l’évangélisation de la communauté qui va à la mer, mais ça ne me dérange pas vraiment. Voilà ce que je déteste:

    • Les fermetures (blocs) ont 4 syntaxes de création différentes et aucune n’est optimale. La syntaxe élégante est incomplète et ambiguë avec les hachages, et la syntaxe complète est laide.
    • La communauté a tendance à être contre la documentation réelle, favorisant «lire le code». Je trouve ça enfantin et paresseux.
    • L’abus de métaprogrammation, en particulier dans les bibliothèques, fait du bogue un cauchemar à suivre.
    • Dans un même ordre d’idées, la métaprogrammation omniprésente rend difficile, voire impossible, un IDE complet.
    • La manière dont le blocage des fonctions est effectué est stupide. Il n’y a pas de raison pour laquelle les blocs doivent être passés en dehors de la liste des parameters, ou avoir une syntaxe spéciale étrange pour y accéder (rendement). Je suis d’avis que les blocs auraient dû avoir une syntaxe moins ambiguë (ou que les hachages auraient pu utiliser des délimiteurs différents, peut-être <> plutôt que {}), et que passer en paramètre aux méthodes aurait dû être comme tous les autres paramètres.

       object.method(1, {|a| a.bar}, "blah") 

      Ces bizarreries, comme le bloc doit être le dernier paramètre passé et le passage de plusieurs blocs est différent avec une syntaxe plus longue, cela m’agace vraiment.

    Perl

    • Usage mixte de sigils

       my @array = ( 1, 2, 3 ); my $array = [ 4, 5, 6 ]; my $one = $array[0]; # not @array[0], you would get the length instead my $four = $array->[0]; # definitely not $array[0] my( $two, $three ) = @array[1,2]; my( $five, $six ) = @$array[1,2]; # coerce to array first my $length_a = @array; my $length_s = @$array; my $ref_a = \@array; my $ref_s = $array; 
      • Par exemple, aucun de ces éléments n’est identique:

         $array[0] # First element of @array @array[0] # Slice of only the First element of @array %array[0] # Syntax error $array->[0] # First element of an array referenced by $array @array->[0] # Deprecated first element of @array %array->[0] # Invalid reference $array{0} # Element of %array referenced by ssortingng '0' @array{0} # Slice of only one element of %array referenced by ssortingng '0' %array{0} # Syntax error $array->{0} # Element of a hash referenced by $array @array->{0} # Invalid reference %array->{0} # Deprecated Element of %array referenced by ssortingng '0' 

      En Perl6 il est écrit :

       my @array = ( 1, 2, 3 ); my $array = [ 4, 5, 6 ]; my $one = @array[0]; my $four = $array[0]; # $array.[0] my( $two, $three ) = @array[1,2]; my( $five, $six ) = $array[1,2]; my $length_a = @array.length; my $length_s = $array.length; my $ref_a = @array; my $ref_s = $array; 
    • Manque de vrai OO

       package my_object; # fake constructor sub new{ bless {}, $_[0] } # fake properties/atsortingbutes sub var_a{ my $self = shift @_; $self->{'var_a'} = $_[0] if @_; $self->{'var_a'} } 

      En Perl6 il est écrit :

       class Dog is Mammal { has $.name = "fido"; has $.tail is rw; has @.legs; has $!brain; method doit ($a, $b, $c) { ... } ... } 
    • Fonctionnalités de regex mal conçues

       /(?=regexp)/; # look ahead /(?<=fixed-regexp)/; # look behind /(?!regexp)/; # negative look ahead /(?regexp)/; # independent sub expression /(capture)/; # simple capture /(?:don't capture)/; # non-capturing group /(?regexp)/; # named capture /[AZ]/; # character class /[^AZ]/; # inverted character class # '-' would have to be the first or last element in # the character class to include it in the match # without escaping it /(?(condition)yes-regexp)/; /(?(condition)yes-regexp|no-regexp)/; /\b\s*\b/; # almost matches Perl6's  /(?{ print "hi\n" })/; # run perl code 

      En Perl6 il est écrit :

       /  /; # lookahead /  /; # lookbehind / regexp :: pattern /; # backtracking control / ( capture ) /; # simple capture / $=[ regexp ] /; # named capture / [ don't capture ] /; # non-capturing group / <[A..Z]> /; # character class / <-[A..Z]> /; # inverted character class # you don't generally use '.' in a character class anyway /  /; # Smart whitespace match / { say 'hi' } /; # run perl code 
    • Absence de répartition multiple

       sub f( int $i ){ ... } # err sub f( float $i ){ ... } # err sub f($){ ... } # occasionally useful 

      En Perl6 il est écrit :

       multi sub f( int $i ){ ... } multi sub f( num $i ){ ... } multi sub f( $i where $i == 0 ){ ... } multi sub f( $i ){ ... } # everything else 
    • Surcharge de l’opérateur

       package my_object; use overload '+' => \&add, ... ; 

      En Perl6 il est écrit :

       multi sub infix:<+> (Us $us, Them $them) | (Them $them, Us $us) { ... } 

    Je vais faire PHP comme je le souhaite parfois et Python sera fait beaucoup trop.

    • Pas d’espace de nom tout est dans une sorte de très grand espace de nommage qui est l’enfer dans des environnements plus grands

    • Manque de normes en matière de fonctions: les fonctions de tableau prennent une aiguille comme premier argument, haystack comme seconde (voir array_search ). Les fonctions de cordes prennent souvent la botte de foin en premier, l’aiguille seconde (voir strpos ). D’autres fonctions utilisent simplement des schémas de nommage différents: bin2hex , strtolower , cal_to_jd

      Certaines fonctions ont des valeurs de retour étranges, hors de la normale: Cela vous oblige à avoir une troisième variable déclarée de nulle part alors que PHP pourrait efficacement interpréter un tableau vide comme faux avec son type de jonglage. Il n’y a presque pas d’autres fonctions faisant la même chose.

       $var = preg_match_all('/regexp/', $str, $ret); echo $var; //outputs the number of matches print_r($ret); //outputs the matches as an array 
    • Le langage (jusqu’à PHP6) fait de son mieux pour respecter une compatibilité ascendante presque retardée, ce qui le rend porteur de mauvaises pratiques et de fonctions quand il n’est pas nécessaire (voir mysql_escape_ssortingng vs. mysql_real_escape_ssortingng ).

    • Le langage a évolué d’un langage de gabarit à un langage complet. Cela signifie que tout le monde peut produire n’importe quoi quand il le souhaite, et il y a abus. Vous vous retrouvez avec des moteurs de template pour un langage de template …

    • Il craint d’importer des fichiers. Vous avez 4 façons différentes de le faire (include, include_once, require, require_once), elles sont toutes lentes, très lentes. En fait, la langue entière est lente. Au moins, assez lent que python (même avec un framework) et RoR de ce que je rassemble.

    J’aime toujours PHP, cependant. C’est la tronçonneuse du développement Web: vous voulez qu’un site soit petit à moyen, rapide et que tout le monde puisse l’héberger (même si les configurations peuvent différer)? PHP est juste là, et il est tellement omniprésent qu’il ne faut que 5 minutes pour installer une stack LAMP ou WAMP complète. Eh bien, je reviens au travail avec Python maintenant …

    Voici certaines choses que je n’aime pas à propos de Java (qui n’est pas ma langue préférée):

    • Effacement de type générique (pas de générique réifié)
    • Incapacité à intercepter plusieurs exceptions (de types différents) dans un même bloc catch
    • Manque de destructeurs (finalize () est un très mauvais substitut)
    • Aucune prise en charge des fermetures ou des fonctions de traitement en tant que données (les classes internes anonymes sont un substitut très verbeux)
    • Les exceptions vérifiées en général, ou plus spécifiquement, en vérifiant les exceptions irrécupérables (par exemple, SQLException)
    • Aucune prise en charge de niveau linguistique pour les collections littérales
    • Aucune inférence de type lorsque des constructeurs de classes génériques sont appelés, c’est-à-dire que le ou les parameters de type doivent être répétés des deux côtés du ‘=’

    C ++

    1. Syntaxe du modèle
    2. Problèmes d’inheritance du diamant
    3. La pléthore / manque de librairies standard que les langages modernes ont (bien que boost soit proche).
    4. IOStreams
    5. La syntaxe utilisée autour des stream IOS

    Python

    1. Les espaces sont significatifs (parfois)
    2. mots clés soulignés
    3. Support de thread limité (au moins actuellement)
    4. “self” au lieu de “this”
    5. Les espaces sont significatifs (parfois)

    Objectif c

    1) Pas d’espaces de noms, juste des conventions de dénomination manuelle – Cela ne me dérange pas en termes de séparation de classes, mais je ne peux pas importer toutes les définitions de classes dans un espace de noms sur une seule ligne (comme import com.me.somelibrary. *).

    2) Les bibliothèques ont encore des lacunes dans des domaines importants comme le support RegEx.

    3) La syntaxe des propriétés est un peu maladroite, nécessitant trois lignes (dans deux fichiers distincts) pour déclarer une propriété.

    4) J’aime le modèle de rétention / libération, mais il est plus facile qu’il ne le devrait de publier une référence et de l’utiliser par la suite accidentellement.

    5) Although not really a language feature, Xcode is so intertwined with use of Objective-C I can’t help thinking about that aspect… basically the autocompletion, is very iffy. It’s more like a system that rewards you for finding something you want exists, and then presents it as a choice afterwards. But then I suppose I never have liked autocomplete engines.

    C ++

    • Ssortingngs.
      They are not interoperable with platform ssortingngs, so you end up using std::vector half of the time. The copy policy (copy on write or deep copy) is not defined, so performance guarantees can not be given for straightforward syntax. Sometimes they rely on STL algorithms that are not very intuitive to use. Too many libraries roll their own which are unfortunately much more comfortable to use. Unless you have to combine them.

    • Variety of ssortingng representations
      Now, this is a little bit of a platform problem – but I still hope it would have been better when a less obstinate standard ssortingng class would have been available earlier. The following ssortingng representations I use frequently:

      • generic LPCTSTR,
      • LPC(W)STR allocated by CoTaskMemAlloc,
      • BSTR, _bstr _t
      • (w)ssortingng,
      • CSsortingng,
      • std :: vector
      • a roll-my-own class ( sigh ) that adds range checking and basic operations to a (w)char * buffer of known length
    • Build model.
      I am sick to death of all the time spent muddling around with who-includes-what, forward declarations, optimizing precomstackd headers and includes to keep at least incremental build times bearable, etc. It was great in the eighties, but now? There are so many hurdles to packing up a piece of code so it can be reused that even moms dog gets bored listening to me.

    • Hard to parse
      This makes external tools especially hard to write, and get right. And today, we C++ guys are lacking mostly in the tool chain. I love my C# reflection and delegates but I can live without them. Without great refactoring, I can’t.

    • Threading is too hard
      Language doesn’t even recognize it (by now), and the freedoms of the comstackr – while great – are to painful.

    • Static and on-demand initialization Technically, I cheat here: this is another puzzle piece in the “wrap up code for reuse”: It’s a nightmare to get something initialized only when it is needed. The best solution to all other redist problems is throwing everything into headers, this problem says “neeener – you cannot”.


    Granted, a lot of that is beyond ssortingct language scope, but IMO the entire toolchain needs to be judged and needs to evolve.

    JavaScript :

    • The Object prototype can be modified. Every single object in your program gets new properties, and something probably breaks.

    • All objects are hash maps, but it’s difficult to safely use them as such. In particular, if one of your keys happens to be __proto__ , you’re in trouble.

    • No object closure at function reference time. In fact, no object closure at all — instead, this is set whenever a function is called with object notation or the new operator. Results in much confusion, particularly when creating event callbacks, because this isn’t set to what the programmer expects.

      • Corollary: calling a function without object notation or the new operator results in this being set equal to the global object, resulting in much breakage.
    • Addition operator overloaded to also perform ssortingng concatenation, despite the two operations being fundamentally different. Results in pain when a value you expect to be a number is in fact a ssortingng.

    • == and != operators perform type coercion. Comparisons between different types involve a list of rules that no mortal can remember in full. This is mitigated by the existence of === and !== operators.

    • Both null and undefined exist, with subtly different, yet redundant meanings. Pourquoi?

    • Weird syntax for setting up prototype chains.

    • parseInt(s) expects a C-style number, so treats values with leading zeroes as octal, etc. You can at least parseInt(s, 10) but the default behaviour is confusing.

    • No block scope.

    • Can declare the same variable more than once.

    • Can use a variable without declaring it, in which case it’s global and probably breaks your program.

    • with { } .

    • Really difficult to document with JavaDoc like tools.

    Python:

    • Lack of static typing
    • Default argument handling (specifically the fact that you can change the default argument for future callers!)
    • Too many required underscores (constructors must be called __init__ )
    • Lack of proper private members and functions (convention just says that most things that start with underscore are private, except for all the stuff like __getattr__ that isn’t)
    • Funny syntax for print ing to a file (but they’re fixing that in Python 3)

    C #

    • I wish I could switch() on any type, and that case could be any expression.

    • Can’t use object initializer syntax with ‘readonly’ fields / private set autoprops. Generally, I want language help with making immutable types.

    • Use of {} for namespace and class and method and property/indexer blocks and multi-statement blocks and array initializers . Makes it hard to figure out where you are when they’re far apart or mismatched.

    • I hate writing (from x in y ... select).Z() . I don’t want to have to fall back to method call syntax because the query syntax is missing something.

    • I want a do clause on query syntax, which is like foreach . But it’s not really a query then.

    I’m really reaching here. I think C# is fantastic, and it’s hard to find much that’s broken.

    PHP

    1. No debugging features if you don’t control the server, and even then they kinda suck
    2. The extreme amount of bad PHP code floating around gives all PHP programmers a bad name
    3. Inconsistent function naming
    4. Inability to have a static typed variable if I want one (I’m a big fan of dynamic typing 90% of the time)
    5. REGISTER_GLOBALS is the devil

    C (OK, it’s not my favorite, but it hadn’t been done yet.)

    • Socket library syntax.
    • No function overloading.
    • C-style ssortingngs.
    • Buffer overruns.
    • Cryptic syntax. I don’t know how many times I’ve looked up stuff like atoi, slapped my forehead, and shouted “Of course!”

    EDIT: I could probably come up with more if I resorted to more library code (like I did with sockets, but those are particularly bad), but I already felt like I was cheating for picking on C. So many languages exist only to take the good parts of C and replace the bad that it’s kind of like beating a dead horse.

    Common Lisp:

    1. Keywords are often too wordy.
    2. Library support is pitiful.
    3. Doesn’t work well in OSes that want to handle memory more ssortingctly.
    4. Doesn’t have good facilities for interacting with the OS.
    5. The “loop” facility is not well defined, and sure doesn’t look Lispy.

    BrainF*ck

    • Your highlight is that you’re Turing complete ?! I can do more in Perl regular expressions!

    • Lack of objects. C’mon, people! It’s like, hello

    • No networking libraries. All I want is to scrape a web page, GOSH.

    • No first-class functions. Congratulations — you get to commiserate with your Java friends.

    • An infinite tape for storage and nothing else. This is so anally pretentious that we might as well be writing Lisp.

    JavaScript

    1. numbers as ssortingngs – Math can be frustrating when numbers are intpreted as ssortingngs. 5 + 2 = 52? Grrr…
    2. permissions – all the best stuff requires permission from the user!
    3. screen updates – The browser must be in the steady state to update the screen. There doesn’t seem to be a way to force the screen to update in the middle of a script.
    4. Slow – although Google’s Chrome is nice…
    5. Browser differences make using the language a [censored].

    PHP:

    • One can never be sure that certain almost common extensions are available on all webservers.
    • sortinges to be everything in future ( goto, closures, … )
    • many security risks for unexperienced users
    • more operator overloading would be nice
    • all the poor programmers that don’t learn how to make it work properly, and give it a bad name

    Nevertheless PHP is the (scripting) language. 😉

    VB6

    1. Windows uniquement
    2. No longer supported.
    3. Arrays can start at any number, rather then all being normalized to 0.
    4. comstackd applications depends on many dll’s to run properly.
    5. Many complicated controls like a browser control or complicated pieces of code tend to break the IDE when you run code uncomstackd, but work just fine when comstackd.

    Ruby is my favourite language, here’s what I don’t like:

    • Green threads + blocking C libraries = giant fail
    • SO PAINFULLY SLOW
    • The standard library itself is inconsistent with its use of bang! méthodes
    • Module include + extend is messy.
    • “Open Classes” can’t be scoped – I want to add a Ssortingng#dostuff, but I don’t want that to leak into all the third party libraries
    • No binary deployment packaging solution.

    Delphi:

    • IDE is a bit unstable.
    • Code insight is sometimes confused.
    • Debugging is sometimes buggy.
    • Updating several project files can be cumbersome.
    • If starting up when one or more packages are unavailable, the error message is popped several times.

    JavaScript

    • Every script is executed in a single global ‘namespace’…something which you have to look out for when working with scripts from different sources

    • If a variable is used but hasnt been defined before hand, it is considered a global variable

    • Browser vendors making up standards as they please, making coding for us developers using such a beautiful language harder than it should be

    • Case-Sensitivity – considering that there is no decent IDE for developing js with comstack-time checking

    • Workarounds (such as the use of hasOwnProperty method) to perform some, otherwise simple operations.

    Haskell:

    1. Space leaks from lazy evaluation.
    2. Numeric Hierarchy not constructed with regard to mathematical abstractions.
    3. Ssortingct monadic IO can make it harder to debug.
    4. The big implementations handle I/O in ways that don’t seem quite compatible with the standard. (In particular, outputting characters only outputs the low 8 bits — and then code gets built that uses this assumption to do binary I/O. Ick.)
    5. Associativity of ($) operator could be changed to make some expressions prettier.

    Most of these don’t rise to the level of hate, and there are people trying to fix or construct solid workarounds for each of these.

    Edit: There’s been some confusion about point 5. In particular some people seem to think I meant the order of arguments, which I don’t. Rather than explaining what I meant, I’ll just point people to the following link, http://hackage.haskell.org/trac/haskell-prime/wiki/ChangeDollarAssociativity , which expresses it well.