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:
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 🙂
… Et quelques bonnes raisons de le détester, sans frais supplémentaires
JavaScript :
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.
‘+’ est un choix absurde d’opérateur de concaténation dans un langage faiblement typé. Étaient-ils en train de faire peur aux noobs?
C’est un champ de mines compatible avec tous les navigateurs (peu importe s’il est allumé ou non)
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.
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 ++
C # / .NET:
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. Celles-ci étaient sur le dessus de ma tête – demandez-moi demain et je vais vous proposer un autre 5 🙂
C
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.
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:
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.
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):
C ++
Python
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:
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.
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:
__init__
) __getattr__
that isn’t) 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
C (OK, it’s not my favorite, but it hadn’t been done yet.)
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:
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
PHP:
Nevertheless PHP is the (scripting) language. 😉
VB6
Ruby is my favourite language, here’s what I don’t like:
Delphi:
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:
($)
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.