Des nouvelles du front nous informent que la pourriture Javascript s’étends tous les jours un peu plus comme une tumeur maligne incurable. Le pronostic vital est engagé, les chances de survie sont maigres.



Comment après tant d’années d’informatique avons nous pu en arriver la ?



Le premier facteur qui vient à l’esprit, ce sont tout ces développeurs qui suivent les modes sans aucune capacité de réflexion. Et surtout sans aucunes connaissances de bas niveau. Pourquoi utilisez vous Node.js ? Parce que le voisin l’utilise, tout simplement. Tout le monde en parle, donc ça doit forcément être bien…



Regardez plutôt ce qu’en disent des vrais développeurs expérimentés.



Déja, à la base, le Langage Javascript est mauvais de chez mauvais. Bricolé et sur-bricolé, pas de typage fort. C’est vraiment tout sauf l’idéal. Oui, le changement, pourquoi pas. Mais certainement pas pour ça…



Alors que vous penseriez logiquement qu’un bidule médiocre, on l’abandonne pour en créer de meilleurs, ce n’est pas du tout le réflexe des développeurs modernes.



Non, eux, quand un truc est mauvais, ils y ajoutent des couches et des couches de framework pour cacher la misère, fragmenter la base de code et bouffer de la puissance. Et puis, tant qu’on y est, on met la maladie à toutes les sauces, on commence à voire du Node.js dans des microcontrôleurs. Et bientôt ils vont repeindre les murs avec… Voila résumé en quelques mots les symptômes de la maladie Javascript.



Enfin, NodeJs est fondé sur un paradigme à mourir de rire : le multitâche coopératif. Et oui, rappelez vous ce cache misère qu’on utilisait au début des années 80 dans les Os qui n’avaient pas encore de vrai noyau multitâche.



Si tant est que ce concept avait eu le moindre intérêt technique(ce dont beaucoup de programmeurs expérimentés doutent) à l’heure ou l’on multiplie le nombre de coeurs , n’importe quel étudiant en informatique devrait être capable d’imaginer que le langage pourrait facilement l’appliquer de manière transparente.



Mais non, c’est tellement plus amusant de bousiller la structure de votre code pour la transformer en plat de nouille de “callbacks”. En plus, ça vous donnera un petit côté “roots” pour impressionner vos copains.



Parfois je me demande si dans quelques années, la programmation spaghetti a coup de Goto ne reviendra pas. Ca pourrait faire fureur…



Comme si des années d’évolution des langages ne nous avaient pas appris que la structure devait compter avant tout et que c’est le langage qui devait s’occuper des aspects techniques.



Oh, j’entends venir les experts autoproclamés venir nous asséner d’un ton docte qu’on ne sait pas programmer et qu’un bon programmeur saura faire un truc structuré, qu’en fait ça parait mauvais, mais que c’est bon… blablaba blabla.



Outre que les exemples que j’ai pu voir ne m’ont jamais convaincu de cette affirmation, on sait tout comment cela se terminera en pratique, c’est à dire “in real life” quand vous, programmeur devrez reprendre un programme écrit par un stagiaire. Je vous souhaite d’avance un bon courage. Et surtout, n’abusez pas de l’aspirine.



Quand on connait le monde informatique, on connait le cynisme de sa réalité et du fait que personne ne se préoccupe réellement d’avoir de bons outils, ni de faire les choses bien.



Après tout, plus un logiciel deviendra incompréhensible, immense et bogués, plus il fournira de travail à une armée d’informaticiens pendant très longtemps.



D’avance un grand merci pour vos réponses pleines d’insultes…

zefling a écrit :



Je te dirais que le web est aussi une mauvaise plateforme : pas de typage fort des arguments, tout ce qui transite est du texte… non, je ne vois vraiment pas pourquoi tu l’utilises aussi. Ceux qui l’ont créé devraient vraiment être des buses.







En tant que programmeur, peux tu réellement affirmer que tu utilises ces technologies par choix ?



N’ayons pas peur de le dire, un certain nombre de technologies sur lequel est basé le web, c’est carrément de la merde. Et beaucoup des sites web tiennent en réalité plus de l’immonde bricolage que du programme sérieux. On peut toujours accuser les programmeurs, mais sont t’ils vraiment les seuls responsables ?



Ceux qui ont développé ces technologies n’étaient pas des buses. Ils n’avaient simplement pas prévu leur extrapolation à un tel point.



Quand ils ont pondu sur un coin de table ce qu’ils imaginaient être des petits langages de scripts ou un petit format de présentation de document, ils n’imaginaient pas un instant que tout une génération de codeurs construiraient un jour des choses très ambitieuses avec.



Et au lieu de s’autoriser à penser que cette base est mauvaise, beaucoup de programmeurs se contraignent mentalement à s’y adapter.



Ils transforment idéologiquement la merde en or avec de la propagande pour esclave : “les bons y arrivent”.



Ils écrivent des framework pour encapsuler la merde. Comme si cacher la merde sous le tapis était une bonne façon de procéder.





Bon, à titre perso, je navigue entre Java (typage fort), Js (typage faible), SQL (typage faible, pour les requêtes), PHP (typage faible), bash (pas de typage). Et perso, je trouve que chaque philosophie à ses avantages et ses inconvenants. En tout cas, il y a plein de petits trucs de PHP que j’aimerais avoir en Java et vise versa.





Il y a de bonnes idées dans tous les langages.



Mais l’absence de typage fort est simplement une hérésie pour écrire de vraies applications. Trop d’effets de bord qui ne valent pas les maigres avantages.



Outre la longue liste de problèmes que cela pose à haut niveau, on pourrait également parler du manque d’optimisation à bas niveau.



Car il est plus lent de traiter une opération sur des variables non typées.





Ça fait plus de 10 ans que je fais du dév, et je n’ai pas du tout le même ressentis sur les langues à typage faible. Je n’ai pas l’impression d’être un expert pour autant.





Et pour une bonne raison, tu fait partie d’une génération formatée pour travailler avec ça.



Je te prédit que dans 20 ou 30 ans, ton avis aura changé, quand tu aura plus du recul sur les choses.



Comme tu le verra plus tard, les modes, ça change.







martino a écrit :



Le bon et le mauvais développeur donc ?

Et pour toi le bon developpeur il developpe comme à l’époque ou tu avais encore envie d’apprendre.

Du coup on se complaît dans ses acquis, on survole  et chie sur le reste.







D’un point de vue de la science informatique, rien de tout cela n’est nouveau.



Pour le reste, chaque époque de l’histoire de l’informatique à eu sa mode à la con.

Fuinril a écrit :



Faut reprendre un peu PHP avant d’écrire n’importe quoi.







Voyons cela…





Effectivement y a pas de typage fort, par contre tu peux très bien typer tes arguments, simplement pas avec des types natifs. Mais soyons sérieux, dans une vraie appli, dans 99% des cas, les types d’arguments ne sont pas natifs.





Le but du typage fort, c’est de s’assurer que le type de toutes les variables utilisés tout à long de la chaîne est bien fixé pour tout et surtout, en tout point et à tout moment. C’est très différent du fait de simplement vérifier le type d’une variable à un point donné, celui ci n’étant pas fixé dans intervalle.



D’un point de vue technique, quand on ignore le type d’une variable, le doute subsiste sur la façon dont elle doit être traitée. Le problème impacte aussi bien la façon de stocker les variables que leur traitement tout à long de la chaîne. Et cela est valable aussi bien pour les types natifs que pour ceux qui ne le sont pas.





En majorité on retrouve des objets abstraits ou des interfaces…. ce que PHP permets….





Et qui n’est pas du tout l’idéal au point de vue traitement avec ce langage…





Pour le temps de traitement on est sur de l’interprété donc c’est pas le typage fort ou faible qui fait la différence,





Justement, la question qu’il faut se poser, c’est pourquoi un langage aussi utilisé a une aussi large échelle n’est même pas compilé….



Imaginez vous seulement ce que cela coûte en cycles CPU et donc en énergie à l’échelle du monde entier…





et les pré-compilo déterminent un typage fort (ce qui entraine des bugs étranges d’ailleurs parfois).





C’est justement la tout le problème. En l’absence de typage fort, il est impossible d’être certain du type d’une variable. D’ou un énorme problème quand on veut rendre ces langages plus rapides en allant vers la compilation.

Et tout cela sans compter certaines structures du langage qui se prêtent assez mal à l’optimisation, comme par exemple les tableaux associatifs. Et cela, la compilation n’y changera rien.



Il serait bon que les jeunes apprennent plus comment fonctionnent les langages à l’intérieur et pas seulement apprendre leur utilisation.



Cela étant dit, PHP dispose d’une marge de progression possible sur le plan des performances. Il est bon de constater que PHP 7 va dans cette direction.





Bref, PHP part d’un langage écrit sur un coin de table, mais aujourd’hui il y a vraiment peu de différences avec des langages plus élaborés…





Malheureusement, il s’avère qu’un langage ne s’affranchit jamais réellement de ses orientations de départ.



Les langages qui sont les plus efficient sur le plan de la vitesse d’exécution sont ceux qui ont été conçus au départ pour cela. Les autres ne le deviennent jamais.



D’ailleurs, il faut oublier le mythe du compilateur magique qui pourrait transformer avec la même efficacité n’importe quel langage.



Essaye C/C++ tu verra la différence de puissance et de rigueur. Même si ce langage n’est pas parfait et n’est pas adapté à tout, il montre un certain nombre de voies qui n’auraient jamais du être abandonnées. Et la première d’entre elle, celle de la rapidité d’exécution.





Quant à la merde que l’on peut retrouver, il y en a plus en PHP parce qu’il y a plus d’amateurs. Mais de la merde j’en ai vu en C#, en Java, en PHP, en VB, etc….





Certes, il faut se montrer juste, PHP n’est pas du tout le pire langage dans la pratique.



Je suis persuadé que les stagiaires arriveront à faire pire avec Node.js.





Edit : d’ailleurs la plus grosse bouse que j’ai eu à reprendre c’était un projet en Java…





Cela ne m’étonne pas une seule seconde.



Un certain nombre de concepts très utilisés en java aboutissent en pratique a une forte tendance à produire de la déstructuration et des plats de nouille…

Par contre, d’un point de vue performance, le langage lui même est plus facile à optimiser.

Reste que Java est un langage qui possède des carences, certaines complètement ridicules comme l’absence de type entier non signé.



Mais le plus amusant, c’est que l’évolution de tous les langages semble aller vers le pire. Je vous laisse deviner la prochaine révolution, celle qui pourrait bien cumuler les tares de Java avec celles de PHP… " />

…suite





D’ailleurs c’est intéressant de noter que PHP va dans cette direction avec l’intégration d’OPcache en natif dans PHP 5.6…. ce qui permet de ne pas perdre la flexibilité de l’interprété tout en gagnant en perfs





Opcache ne fait que mettre en cache une forme d’opcodes. On reste encore très loin d’un langage compilé.



Certes, on ne peut que saluer cette optimisation. Mais pour ma part, je dirais plutôt que c’était juste la moindre des choses.



Comment as t’on pu utiliser aussi longtemps un langage qui n’avait même pas dans sa version standard une optimisation aussi triviale…. Un bon BASIC d’il y a 30 ans permettait déjà de sauvegarder/recharger les programmes sous forme d’opcodes…