Quelles sont les cinq choses que vous détestez dans votre langue préférée? [fermé]

Il y a eu un groupe de Perl-haine sur Stack Overflow récemment, alors j'ai pensé apporter ma question " Cinq choses que vous détestez au sujet de 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. Ce sont peut-être des choses qui vous ennuient, qui admettent des défauts de conception, des problèmes de performances reconnus ou toute autre catégorie. Il suffit de le détester et ce 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 tolérez afin que vous puissiez utiliser toutes les autres choses, et je veux entendre la langue que vous souhaitez que les autres utilisent.

Je pose cette question chaque fois que quelqu'un essaie de pousser sa langue préférée sur moi, et parfois comme une question d'entrevue. Si quelqu'un ne peut pas trouver cinq choses à détester à propos de son outil préféré, il ne le sait pas assez bien pour le défendre ou retirer les gros dollars en l'utilisant. Il ne l'a pas utilisé dans suffisamment de situations différentes pour l'explorer pleinement. 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.

Peu m'importe la langue que vous utilisez. Vous ne voulez pas utiliser une langue particulière? Alors ne le fais pas. Vous passez par une 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 beaucoup d'expérience dans Bar. Changer pour Foo serait stupide."

C'est aussi une bonne question pour les revues de code. Les gens qui connaissent vraiment une base de code auront toutes sortes de suggestions à ce sujet, et ceux qui ne la connaissent pas si bien ont des plaintes non spécifiques. Je demande des choses comme "Si vous pouviez recommencer ce projet, que feriez-vous différemment?" Dans ce pays fantastique, les utilisateurs et les programmeurs peuvent se plaindre de tout et de tout ce qu'ils n'aiment pas. "Je veux une meilleure interface", "Je veux séparer le modèle de la vue", "J'utiliserais ce module à la place de cet autre", "Je renommerais cet ensemble de méthodes", ou tout ce qu'ils font vraiment 'aime pas la situation actuelle. C'est ainsi que je sais combien un développeur particulier connaît la base de code. C'est aussi un indice sur la part du programmeur »

La haine n'est pas la seule dimension pour déterminer ce que les gens savent, mais je l'ai trouvé assez 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 saines dans les graphiques par exemple.
• NullPointerException ne contenant pas plus d'informations sur ce qui est nul.
• La prolifération d'infrastructures / d'interfaces de fournisseurs de services / de classes d'usine / de systèmes d'injection de dépendances «configurables» inutiles. La configurabilité n'est presque jamais utilisée, DRY est violé de manière flagrante et le code quadruple en taille et divise par deux la lisibilité.

Je sais, je devrais vérifier Scala.

Wow, je suis surpris que SQL ne soit pas encore arrivé ici. Je suppose que cela signifie que personne ne l'aime :)

• Syntaxe incohérente entre les implémentations
• Des différences de code subtiles peuvent avoir des ramifications de performances massives pour des raisons apparemment obscures
• Prise en charge médiocre de la manipulation de texte
• Coût d'entrée facile mais courbe d'apprentissage abrupte vers la maîtrise de la langue
• Normalisation minimale à travers la communauté pour les meilleures pratiques, cela inclut le style de syntaxe.

... Et quelques raisons bonus 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'avant.
• Il est difficile de mettre en œuvre la division relationnelle.
• Je peux définir une valeur sur NULL, mais je ne peux pas tester son égalité avec NULL. Je peux vérifier IS NULL, mais cela complique simplement le code - inutilement, à mon avis.
• Pourquoi devons-nous repécifier complètement la formule d'une colonne GROUPed, plutôt que de définir un alias sur la colonne, puis 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 également enveloppée dans une si petite quantité de code que vous vous sentez stupide d'avoir du mal à le suivre

2. '+' est un choix absurde d'opérateur pour la concaténation dans un langage faiblement typé. Ont - ils essayé d'effrayer les noobs?

3. C'est un champ de mines de compatibilité multi-navigateur (peu importe s'il est même activé ou non)

4. Ce n'est généralement pas fiable - associé à des escroqueries telles que le blocage du bouton de retour, des 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, String, Object, etc.)

Si ce n'était pas pour jQuery, je le détesterais probablement autant que je le faisais :)

PHP:

1) Me force à faire des variables inutiles:

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

2) Une implémentation de lambdas si boiteuse qu'elle est à peu près équivalente à l'utilisation eval()et si horriblement erronée que je ne l'ai jamais utilisée (voir http://www.php.net/create_function ).

3) Un système try / catch qui ne peut détecter qu'environ 80% des erreurs qui pourraient se produire.

4) Le support Regex est tout aussi boiteux que le support lambda car il doit être écrit dans des 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) Pas moyen d'extraire des éléments de $ _POST en toute sécurité sans l'écrire deux fois ou créer votre propre fonction, ou en utilisant l'opérateur '@':

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

6) Réponse bonus: '@'. Si cela ne vous dérange pas d'écrire votre code correctement, ajoutez simplement '@', et tant pis pour quiconque doit déboguer votre code plus tard.

C ++

• Beaucoup trop facile de corrompre aléatoirement la mémoire et de créer des bogues presque impossibles à trouver (bien que Valgrind fasse beaucoup pour résoudre ce problème ).
• Messages d'erreur de modèle.
• Lorsque vous utilisez des modèles, il est facile de devoir tout inclure dans un seul fichier, puis 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 méchants petits morceaux de C à travers (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 lockinstruction - à la place, vous devriez avoir des objets de verrouillage spécifiques, et il devrait y avoir des méthodes telles que celles Acquirequi renvoient des jetons de verrouillage jetables. Corollaire: il ne devrait pas y avoir de moniteur pour chaque objet.
• GetHashCode()et Equals()ne devrait pas être dedans System.Object- tout ne convient pas au hachage. Au lieu de cela, avoir un IdentityComparerqui fait la même chose, et garder la IComparer<T>, IComparable<T>, IEqualityComparer<T>etIEquatable<T> les interfaces pour les comparaisons personnalisées.
• Mauvais support pour 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.

C'étaient du haut de ma tête - demandez-moi demain et je trouverai un 5 différent :)

C

• manipulation de chaînes.

Devoir gérer manuellement les tampons de chaîne est une douleur sujette aux erreurs. Étant donné que l'informatique bouge et modifie vraiment les chaînes (les ordinateurs ne sont pas autant utilisés pour les gros calculs que les gens pensaient qu'ils seraient à l'époque), il est vraiment agréable de pouvoir utiliser des langages gérés ou la chaîne C ++ des objets pour y faire face. Quand je dois le faire en C droit, j'ai l'impression de nager dans des sables mouvants.

Que diriez-vous de cinq choses que je déteste à propos des listes "Choses que je déteste à propos d'une langue"? :RÉ

5- Peindre un rouge orangé n'en fait pas une pomme.

Lorsqu'une langue est conçue, les concepteurs ont généralement à l'esprit à quoi elle sert. L'utiliser pour quelque chose de complètement différent peut fonctionner, mais se plaindre quand ce n'est pas le cas est simplement stupide. Prenez Python. Je suis sûr que quelqu'un a ou quelqu'un fera un jour un utilitaire pour créer des exes à partir du code Python. Pourquoi la terre de Dieu vous voulez faire cela? Ce serait bien — ne vous méprenez pas — mais cela ne sert à rien. Alors arrêtez de vous en plaindre!

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

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

La plateforme peut avoir une grande influence sur ce que la langue peut faire. Avec les collecteurs d'ordures de nos jours, ou bien même les premières tentatives pascales de "collecte des ordures", peuvent aider à l'effacement de la mémoire (peut-être plus de RAM malloc ??). Les ordinateurs sont plus rapides et donc bien sûr, nous attendons plus de nos langues. Et franchement, nous devrions probablement le faire. Cependant, il y a un prix énorme à payer pour la commodité du compilateur pour créer des tables de hachage ou des chaînes ou une variété d'autres concepts. Ces éléments peuvent ne pas être hérités de la plate-forme dont ils sont utilisés. Dire qu'ils sont faciles à inclure dans une langue me dit simplement que vous n'avez peut-être pas de jambe sur laquelle vous tenir.

3- Qui est vraiment la faute?

Bugs. Tu sais. J'adore les insectes. Pourquoi j'aime les bugs. Parce que cela signifie que je dois garder mon travail. Sans insectes, il y aurait de nombreuses 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 aussi stricte qui réduirait considérablement le nombre de bogues pouvant être générés serait un langage complètement inutile. Ses capacités pourraient probablement être comptées d'une part. Vous voulez de la flexibilité ou du pouvoir? Vous avez des bugs. Pourquoi? Parce que tu n'es pas parfait et que tu fais des erreurs. Prenons un exemple vraiment identifiable en C:

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

Nous savons 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 sont le coût de cette fonctionnalité. Ce code ci-dessus. Si je l'ai effectivement rendu public. C'est encore .. dites-le avec moi .. "Ma faute". Pas C pour m'avoir permis de le faire.

2- Ne devrions-nous pas mettre cela dans la corbeille?

Il est très facile de pointer une fonctionnalité dans un langage que nous ne comprenons pas, car nous ne l'utilisons pas souvent et nous l'appelons stupide. Se plaindre qu'il est là, etc. Goto me divertit toujours. Les gens se plaignent toujours du fait que goto est 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 continuation, vous avez utilisé un goto. Voilà ce que c'est. Certes, c'est un goto "sûr", mais c'est ce que c'est. Les Goto ont leur utilité. Que des gotos "implicites" comme continuer ou rompre soient utilisés ou des gotos explicites (en utilisant le mot clé réel "goto" pour n'importe quelle langue). Non pas que les développeurs de langage soient sans défaut, 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 .. c'est ' s utilisé et n'est probablement pas traîner en raison de la compatibilité descendante. Il est utilisé aujourd'hui. Comme il y a 5 minutes. Et utilisé correctement. Eh bien .. sans doute quelqu'un l'utilise également de manière incorrecte, mais cela se rapporte au numéro 3 sur ma liste.

1. - Tout est un objet.

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 objet. Il existe un grand nombre de concepts qui n'appartiennent pas ou doivent être des objets. Mettre des choses là où elles n'appartiennent pas est tout simplement moche et peut diminuer l'efficacité d'un programme. Sûr. Peut-être pas beaucoup selon la langue. Cela concerne également le n ° 5. Cela signifie ... oui. Global sont ok. Les fonctions associées aux méthodes statiques sont correctes. La combinaison de la programmation OO avec des fonctions globales est correcte. Maintenant .. cela ne signifie pas que nous devrions tous sortir et "libérer" notre code de ses modèles d'objets. Lors de la conception d'une section de code ou d'un projet entier, ce qui se passe dans les coulisses doitêtre pris en compte lors de la mise en place. Non seulement où ce concept réside et de nombreux autres facteurs. Pourquoi envelopper des fonctions globales dans des classes ou des concepts d'espace de nom si cela ne sert à rien? Prenez des variables membres statiques. Cela m'amuse énormément parce que ... eh bien ... En fonction du langage et de la mise en œuvre bien sûr, mais d'une manière générale, vous venez de déclarer un global. Oui, il existe des raisons d'encapsuler ces concepts non OO dans des wrappers OO. L'un étant bien sûr le code auto-documenté. Cela peut avoir du sens. Alors .. comme je dis. Ne sortez pas et "libérez" votre code. Mais tout bon langage moderne aura un concept global en dehors de sa modélisation OO. Oui, je veux spécifiquement souligner qu'un langage de programmation OO sans concept global a très probablement un grave défaut de conception. Encore une fois cependant .. dépend de l'intention et de la conception de la langue, donc je n'essaie pas de choisir une langue spécifique et il y en a beaucoup trop à analyser ici. Quoi qu'il en soit, considérez où le code doit vivre et être le plus efficace. L'ajout d'un tas de reflets à quelque chose qui n'ajoute pas de fonctionnalité ou de support épuise simplement le clavier plus rapidement. Cela ne fait de bien à personne. Eh bien ... à moins que vous n'aimiez les points brownie de la personne qui vous a probablement incorrectement appris que tout est un objet.

En bref, la programmation ne consiste pas simplement à taper sur le clavier sans réfléchir. Il y a beaucoup de considérations de conception dans tout projet. Je sais que c'est un cliché, mais il faut le regarder sous tous les angles. Même avec les langages sûrs de nos jours. Vous ne vous contentez pas de jeter du code et vous attendez à ce qu'il fonctionne bien. Bien sûr .. cela peut fonctionner, mais ce n'est peut-être pas la bonne façon de procéder. Dans l'ensemble, choisissez la langue et le format les mieux adaptés au travail spécifique ET à l'environnement. Mais aucun langage n'enlève la pensée derrière lui. Si vous ne pensez pas .. vous tapez simplement.

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

1. Autant que je suis fan de Java Generics, il y a beaucoup de bizarreries qui découlent de la façon dont il a été conçu. En tant que tel, il existe une myriade de limitations ennuyeuses avec les génériques (dont certaines sont le résultat de l'effacement de type).
2. Le fonctionnement d'Object.clone () et des interfaces clonables est totalement rompu.
3. Au lieu de prendre la route et de faire de tout un objet (a.la. SmallTalk), Sun a créé deux catégories distinctes de types de données: les objets 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 trucs sympas que l'on peut faire avec Swing mais c'est un excellent exemple de suringénierie.
5. Cette dernière plainte est également imputable à Sun et à ceux qui ont écrit des bibliothèques XML pour Java. Les bibliothèques XML Java sont beaucoup trop compliquées. Afin de simplement lire dans un fichier XML, je dois souvent me soucier de quel analyseur j'utilise: DOM ou SAX? Les API pour chacune sont également déroutantes. Un support natif dans la langue pour analyser / écrire facilement du XML serait très agréable.
6. java.util.Date craint. Non seulement c'est inutilement compliqué, mais toutes les méthodes utiles ont été dépréciées (et remplacées par d'autres qui augmentent la complexité).

Ruby a de nombreux défauts liés à sa vitesse, mais je ne les déteste pas. Cela a également des défauts avec l'évangélisation communautaire qui va trop loin, mais cela ne me dérange pas vraiment. Voici ce que je déteste:

• Les fermetures (blocs) ont 4 syntaxes de création différentes, et aucune d'entre elles n'est optimale. La syntaxe élégante est incomplète et ambiguë avec des hachages, et la syntaxe complète est laide.
• La communauté a tendance à s'opposer à une véritable documentation, favorisant la «lecture du code». Je trouve cela puéril et paresseux.
• L'abus de métaprogrammation, en particulier dans les bibliothèques, fait des bugs un cauchemar à retrouver.
• Sur une note connexe, la métaprogrammation omniprésente rend un IDE complet difficile, voire impossible, à réaliser.

• La façon dont le passage de bloc aux fonctions est effectué est idiot. Il n'y a aucune raison pour que les blocs soient passés en dehors de la liste des paramètres, ou aient une syntaxe spéciale étrange pour accéder (rendement). Je suis d'avis que les blocs auraient dû avoir une syntaxe moins ambiguë (ou que les hachages auraient pu utiliser différents délimiteurs; peut-être <> plutôt que {}), et passer des paramètres 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 passer plus d'un bloc est différent avec une syntaxe plus longue, ça m'ennuie vraiment.

Perl

• Utilisation mixte des sceaux

  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 string '0'
    @array{0}   # Slice of only one element of %array referenced by string '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 string '0'
    

  Il Perl6est é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/attributes
  sub var_a{
    my $self = shift @_;
    $self->{'var_a'} = $_[0] if @_;
    $self->{'var_a'}
  }
  

  Il Perl6est écrit :

  class Dog is Mammal {
      has $.name = "fido";
      has $.tail is rw;
      has @.legs;
      has $!brain;
      method doit ($a, $b, $c) { ... }
      ...
  }
  

• Fonctionnalités regex mal conçues

  /(?=regexp)/;           # look ahead
  /(?<=fixed-regexp)/;    # look behind
  /(?!regexp)/;           # negative look ahead
  /(?<!fixed-regexp)/;    # negative look behind
  /(?>regexp)/;           # independent sub expression
  /(capture)/;            # simple capture
  /(?:don't capture)/;    # non-capturing group
  /(?<name>regexp)/;      # named capture
  /[A-Z]/;                # character class
  /[^A-Z]/;               # 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 <ws>
  /(?{ print "hi\n" })/;  # run perl code
  

  Il Perl6est écrit :

  / <?before pattern>  /;   # lookahead
  / <?after pattern>   /;   # lookbehind
  / regexp :: pattern  /;   # backtracking control
  / ( capture )        /;   # simple capture
  / $<name>=[ 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
  / <ws>               /;   # Smart whitespace match
  / { say 'hi' }       /;   # run perl code
  

• Absence d'envoi multiple

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

  Il Perl6est écrit :

  multi sub f( int $i ){ ... }
  multi sub f( num $i ){ ... }
  multi sub f( $i where $i == 0 ){ ... }
  multi sub f(     $i ){ ... } # everything else
  

• Mauvaise surcharge de l'opérateur

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

  Il Perl6est écrit :

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

Je vais faire du PHP comme je l'aime parfois et Python sera fait beaucoup trop.

• Pas d'espace de noms; tout est dans une sorte de très grand espace de noms qui est un enfer dans des environnements plus grands

• Manque de normes en matière de fonctions: les fonctions de tableau prennent une aiguille comme premier argument, la botte de foin comme deuxième (voir array_search ). Les fonctions de chaîne prennent souvent la botte de foin en premier, l'aiguille ensuite (voir strpos ). D'autres fonctions utilisent simplement différents schémas de dénomination: bin2hex , strtolower , cal_to_jd

  Certaines fonctions ont des valeurs de retour étranges, hors de ce qui est normal: cela vous oblige à avoir une troisième variable déclarée de nulle part tandis que PHP pourrait efficacement interpréter un tableau vide comme faux avec son type de jonglage. Il n'y a presque aucune autre fonction faisant de même.

  $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 rétrocompatibilité presque retardée, ce qui le rend porteur de mauvaises pratiques et de fonctions lorsqu'il n'est pas nécessaire (voir mysql_escape_string contre mysql_real_escape_string ).

• Le langage est passé d'un langage de modèles à un langage complet. Cela signifie que n'importe qui peut sortir n'importe quoi quand il le souhaite, et cela est abusé. Vous vous retrouvez avec des moteurs de template pour un langage de template ...

• Ça 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, toute la langue est lente. Au moins, assez lent que python (même avec un framework) et RoR d'après ce que je comprends.

Mais j'aime toujours PHP. C'est la tronçonneuse du développement Web: vous voulez qu'un site petit à moyen soit fait très rapidement et que tout le monde puisse l'héberger (bien que les configurations puissent différer)? PHP est là, et il est tellement omniprésent qu'il ne faut que 5 minutes pour installer une pile LAMP ou WAMP complète. Eh bien, je recommence à travailler avec Python maintenant ...

Voici certaines choses que je n'aime pas à propos de Java (qui n'est pas mon langage préféré):

• Effacement de type générique (c.-à-d. Pas de générique réifié)
• Incapacité à intercepter plusieurs exceptions (de types différents) dans un seul bloc de capture
• Manque de destructeurs (finalize () est un très mauvais substitut)
• Pas de prise en charge des fermetures ou du traitement des fonctions comme des données (les classes internes anonymes sont un substitut très prolixe)
• Exceptions vérifiées en général, ou plus spécifiquement, vérification des exceptions irrécupérables (par exemple, SQLException)
• Pas de prise en charge au niveau de la langue pour les collections littérales
• Pas d'inférence de type lorsque des constructeurs de classes génériques sont appelés, c'est-à-dire que le ou les paramètres de type doivent être répétés des deux côtés du '='

C ++

1. Syntaxe du modèle
2. Problèmes d'héritage diamant
3. La pléthore / le manque de bibliothèques standard que les langues modernes ont (bien que le boost approche).
4. IOStreams
5. La syntaxe utilisée autour des IOStreams

Python

1. Les espaces ont du sens (parfois)
2. mots-clés soulignés
3. Prise en charge limitée des threads (au moins actuellement)
4. "soi" au lieu de "ceci"
5. Les espaces ont du sens (parfois)

Objectif c

1) Pas d'espaces de noms, juste des conventions de nommage manuelles - 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 trous 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 retenue / libération, mais il est plus facile qu'il ne devrait l'être de libérer une référence et de l'utiliser accidentellement plus tard.

5) Bien que ce ne soit pas vraiment une fonction de langage, Xcode est si étroitement lié à l'utilisation d'Objective-C que je ne peux m'empêcher de penser à cet aspect ... fondamentalement, la saisie semi-automatique, est très incertaine. Cela ressemble plus à un système qui vous récompense pour avoir trouvé quelque chose que vous voulez, puis le présente ensuite comme un choix. Mais je suppose que je n'ai jamais aimé les moteurs de saisie semi-automatique.

C ++

• Cordes.
  Ils ne sont pas interopérables avec les chaînes de plate-forme, donc vous finissez par utiliser std :: vector la moitié du temps. La politique de copie (copie en écriture ou copie complète) n'est pas définie, de sorte que les garanties de performances ne peuvent pas être données pour une syntaxe simple. Parfois, ils s'appuient sur des algorithmes STL qui ne sont pas très intuitifs à utiliser. Trop de bibliothèques roulent les leurs, ce qui est malheureusement beaucoup plus confortable à utiliser. Sauf si vous devez les combiner.

• Variété de représentations de chaîne
  Maintenant, c'est un peu un problème de plate-forme - mais j'espère toujours que cela aurait été mieux quand une classe de chaîne standard moins obstinée aurait été disponible plus tôt. Les représentations de chaîne suivantes que j'utilise fréquemment:

  • LPCTSTR générique,
  • LPC (W) STR alloué par CoTaskMemAlloc,
  • BSTR, _bstr _t
  • (w) chaîne,
  • C chaîne,
  • std :: vecteur
  • une classe roll-my-own ( soupir ) qui ajoute la vérification de la plage et les opérations de base à un tampon (w) char * de longueur connue

• Construire un modèle.
  Je suis malade à mort de tout le temps passé à me brouiller avec qui-inclut-quoi, les déclarations avancées, l'optimisation des en-têtes précompilés et inclut de garder au moins les temps de construction incrémentiels supportables, etc. C'était génial dans les années 80, mais maintenant? Il y a tellement d'obstacles à emballer un morceau de code afin qu'il puisse être réutilisé que même les mamans de chien s'ennuient à m'écouter.

• Difficile à analyser
  Cela rend les outils externes particulièrement difficiles à écrire et à bien faire. Et aujourd'hui, nous, les gars C ++, manquons surtout dans la chaîne d'outils. J'adore ma réflexion C # et mes délégués mais je peux vivre sans eux. Sans grande refactorisation, je ne peux pas.

• Le threading est trop difficile Le
  langage ne le reconnaît même pas (à l'heure actuelle), et les libertés du compilateur - bien que géniales - sont trop douloureuses.

• Initialisation statique et à la demande Techniquement, je triche ici: c'est une autre pièce du puzzle du "code de réutilisation": C'est un cauchemar de faire initialiser quelque chose seulement quand c'est nécessaire. La meilleure solution à tous les autres problèmes de redistribution est de tout jeter dans les en-têtes, ce problème dit "neeener - vous ne pouvez pas".

Certes, beaucoup de choses dépassent le cadre du langage strict, mais l'OMI toute la chaîne d'outils doit être jugée et doit évoluer.

JavaScript :

• Le Objectprototype peut être modifié. Chaque objet de votre programme obtient de nouvelles propriétés et quelque chose se casse probablement.

• Tous les objets sont des cartes de hachage, mais il est difficile de les utiliser en toute sécurité en tant que tels. En particulier, si l'une de vos clés se trouve __proto__, vous avez des ennuis.

• Pas de fermeture d'objet au moment de la référence de la fonction. En fait, aucune fermeture d'objet du tout - à la place, thisest définie chaque fois qu'une fonction est appelée avec la notation d'objet ou l' newopérateur. Entraîne beaucoup de confusion, en particulier lors de la création de rappels d'événements, car il thisn'est pas réglé sur ce que le programmeur attend.

  • Corollaire: l'appel d'une fonction sans notation d'objet ou l' newopérateur entraîne thisune valeur égale à l'objet global, ce qui entraîne de nombreuses ruptures.

• Opérateur d'addition surchargé pour effectuer également la concaténation de chaînes, bien que les deux opérations soient fondamentalement différentes. Il en résulte une douleur lorsqu'une valeur que vous attendez à être un nombre est en fait une chaîne.

• ==et les !=opérateurs effectuent une coercition de type. Les comparaisons entre différents types impliquent une liste de règles dont aucun mortel ne peut se souvenir complètement. Ceci est atténué par l'existence de ===et d' !==opérateurs.

• Les deux existent nullet ont undefineddes significations subtilement différentes mais redondantes. Pourquoi?

• Syntaxe étrange pour la mise en place de chaînes de prototypes.

• parseInt(s)attend un nombre de style C, traite donc les valeurs avec des zéros en tête comme octaux, etc. Vous pouvez au moins parseInt(s, 10)mais le comportement par défaut est déroutant.

• Pas de portée de bloc.

• Peut déclarer la même variable plusieurs fois.

• Peut utiliser une variable sans la déclarer, auquel cas elle est globale et casse probablement votre programme.

• with { }.

• Vraiment difficile à documenter avec des outils comme JavaDoc.

Python:

• Manque de frappe statique
• Gestion des arguments par défaut (en particulier le fait que vous pouvez changer l'argument par défaut pour les futurs appelants!)
• Trop de soulignements requis (les constructeurs doivent être appelés __init__)
• Manque de membres et de fonctions privés appropriés (la convention dit simplement que la plupart des choses qui commencent par un trait de soulignement sont privées, à l'exception de toutes les choses comme __getattr__ qui ne l'est pas)
• Syntaxe drôle pour printing dans un fichier (mais ils corrigent cela dans Python 3)

C #

• J'aimerais pouvoir switch()sur n'importe quel type, et cela casepourrait être n'importe quelle expression.

• Impossible d'utiliser la syntaxe d'initialisation d'objet avec des champs / private setautoprops 'en lecture seule' . En général, je veux une aide linguistique pour créer des types immuables.

• Utilisation de {}pour l' espace de noms et la classe et la méthode et les blocs de propriété / indexeur et les blocs multi-instructions et les initialiseurs de tableau . Il est difficile de savoir où vous êtes quand ils sont éloignés ou mal assortis.

• Je déteste écrire (from x in y ... select).Z(). Je ne veux pas avoir à revenir à la syntaxe d'appel de méthode, car il manque quelque chose à la syntaxe de la requête.

• Je veux une doclause sur la syntaxe de requête, qui est comme foreach. Mais ce n'est pas vraiment une requête alors.

J'atteins vraiment ici. Je pense que C # est fantastique, et il est difficile de trouver beaucoup de choses cassées.

PHP

1. Aucune fonctionnalité de débogage si vous ne contrôlez pas le serveur, et même alors, ils sont un peu nul
2. La quantité extrême de mauvais code PHP flottant donne un mauvais nom à tous les programmeurs PHP
3. Dénomination de fonction incohérente
4. Impossibilité d'avoir une variable typée statique si j'en veux une (je suis un grand fan de la frappe dynamique 90% du temps)
5. REGISTER_GLOBALS est le diable

C (OK, ce n'est pas mon préféré, mais cela n'a pas encore été fait.)

• Syntaxe de la bibliothèque de sockets.
• Pas de surcharge de fonction.
• Cordes de style C.
• Dépassements de tampon.
• Syntaxe cryptique. Je ne sais pas combien de fois j'ai recherché des trucs comme atoi, giflé mon front et crié "bien sûr!"

EDIT: Je pourrais probablement trouver plus si je recourais à plus de code de bibliothèque (comme je l'ai fait avec les sockets, mais ceux-ci sont particulièrement mauvais), mais j'avais déjà l'impression de tricher pour avoir choisi C. C. Beaucoup de langues n'existent que pour prendre les bonnes parties de C et remplacer les mauvaises que c'est un peu comme battre un cheval mort.

Lisp commun:

1. Les mots-clés sont souvent trop verbeux.
2. Le soutien de la bibliothèque est pitoyable.
3. Ne fonctionne pas bien dans les systèmes d'exploitation qui souhaitent gérer la mémoire plus strictement.
4. N'a pas de bonnes installations pour interagir avec le système d'exploitation.
5. La fonction "boucle" n'est pas bien définie et ne ressemble pas à Lispy.

BrainF * ck

• Votre point fort est que vous avez terminé Turing ?! Je peux faire plus dans les expressions régulières Perl!

• Manque d'objets. Allez, les gens! C'est comme, bonjour ...

• Pas de bibliothèques de réseautage. Tout ce que je veux, c'est gratter une page Web, GOSH.

• Pas de fonctions de première classe. Félicitations - vous pouvez compatir avec vos amis Java.

• Une bande infinie pour le stockage et rien d'autre. C'est tellement prétentieux que nous pourrions aussi bien écrire Lisp.

Javascript

1. les nombres comme chaînes - Les mathématiques peuvent être frustrantes lorsque les nombres sont interprétés comme des chaînes. 5 + 2 = 52? Grrr ...
2. autorisations - toutes les meilleures choses nécessitent la permission de l'utilisateur!
3. mises à jour de l'écran - Le navigateur doit être en régime permanent pour mettre à jour l'écran. Il ne semble pas y avoir de moyen de forcer la mise à jour de l'écran au milieu d'un script.
4. Lent - bien que Google Chrome soit agréable ...
5. Les différences de navigateur font de l'utilisation de la langue un [censuré].

PHP:

• On ne peut jamais être certain que certaines extensions presque communes sont disponibles sur tous les serveurs Web.
• essaie d'être tout à l'avenir (goto, fermetures, ...)
• de nombreux risques de sécurité pour les utilisateurs inexpérimentés
• plus de surcharge d'opérateur serait bien
• tous les pauvres programmeurs qui n'apprennent pas comment le faire fonctionner correctement et lui donnent une mauvaise réputation

Néanmoins, PHP est le langage (de script). ;-)

VB6

1. Windows seulement.
2. N'est plus pris en charge.
3. Les tableaux peuvent commencer à n'importe quel nombre, plutôt que tous étant normalisés à 0.
4. les applications compilées dépendent de nombreuses DLL pour fonctionner correctement.
5. De nombreux contrôles complexes comme un contrôle de navigateur ou des morceaux de code compliqués ont tendance à casser l'IDE lorsque vous exécutez du code non compilé, mais fonctionnent très bien lors de la compilation.

Le rubis est ma langue préférée, voici ce que je n'aime pas:

• Fils verts + bibliothèques C bloquantes = échec géant
• SI DOUCEMENT LENT
• La bibliothèque standard elle-même est incompatible avec son utilisation de bang! les méthodes
• Le module include + extend est désordonné.
• Les "classes ouvertes" ne peuvent pas être étendues - je veux ajouter une chaîne # dostuff, mais je ne veux pas que cela fuit dans toutes les bibliothèques tierces
• Aucune solution d'emballage de déploiement binaire.

Delphes:

• L'IDE est un peu instable.
• La compréhension du code est parfois confuse.
• Le débogage est parfois bogué.
• La mise à jour de plusieurs fichiers de projet peut être fastidieuse.
• Si vous démarrez lorsqu'un ou plusieurs packages ne sont pas disponibles, le message d'erreur s'affiche plusieurs fois.

Javascript

• Chaque script est exécuté dans un seul 'espace de noms' global ... quelque chose que vous devez surveiller lorsque vous travaillez avec des scripts provenant de différentes sources

• Si une variable est utilisée mais n'a pas été définie au préalable, elle est considérée comme une variable globale

• Les fournisseurs de navigateurs élaborent des normes à leur guise, rendant le codage pour nous, développeurs utilisant un si beau langage, plus difficile qu'il ne devrait l'être

• Respect de la casse - considérant qu'il n'y a pas d'IDE décent pour développer js avec une vérification à la compilation

• Solutions de contournement (telles que l'utilisation de la hasOwnPropertyméthode) pour effectuer certaines opérations, sinon simples.

Haskell:

1. Fuites d'espace suite à une évaluation paresseuse.
2. Hiérarchie numérique non construite en ce qui concerne les abstractions mathématiques.
3. Des E / S monadiques strictes peuvent rendre le débogage plus difficile.
4. Les grandes implémentations gèrent les E / S d'une manière qui ne semble pas tout à fait compatible avec la norme. (En particulier, la sortie de caractères ne produit que les 8 bits bas - puis le code est construit qui utilise cette hypothèse pour effectuer des E / S binaires. Ick.)
5. L'associativité de l' ($)opérateur pourrait être modifiée pour rendre certaines expressions plus jolies.

La plupart d'entre eux n'atteignent pas le niveau de haine, et il y a des gens qui essaient de corriger ou de construire de solides solutions de contournement pour chacun d'eux.

Edit: Il y a eu une certaine confusion au sujet du point 5. En particulier, certaines personnes semblent penser que je voulais dire l'ordre des arguments, ce que je ne pense pas. Plutôt que d'expliquer ce que je voulais dire, je vais simplement pointer les gens vers le lien suivant, http://hackage.haskell.org/trac/haskell-prime/wiki/ChangeDollarAssociativity , qui l'exprime bien.