javascript un langage compliqué !?

Version imprimable

Bonjour à tous,

Récemment j'ai regardé les dérivés du C++ :
managed C++, C++/CLI, C++/CX, C#, et dans un autre domaine C++0x (ou C++11) Je dois dire que c'est un sacré fouilli, mais avec un peu de patience on comprend assez bien le concept général.

Ensuite, je regarde javascript/actionscript. Et là, surprise ! J'avais déjà bidouillé, comme tout le monde, dans ma jeunesse, en javascript et actionscript, mais je ne m'étais jamais rendu compte que c'est (selon moi) l'un des langages les plus compliqués et tordus que je n'ai jamais vu.

Superficiellement, c'est un langage très simple : c'est LE langage dans lequel, en bidouillant, même si vous n'avez jamais entendu parler ni de pointeur ni d'objet ni de référence, vous arriverez toujours à faire un petit bout de code qui marche à peu près.

Mais moi qui suis développeur, même après avoir lu 3 fois la page wikipedia sur javascript, je suis incapable de dire ce qu'est un 'var' : aucune idée de la structure de donnée C sous-jacente. La seule chose que j'ai compris c'est que ça dépend de la version de javascript/actionscript, et du navigateur web ou du plugin flash correspondant.

Est-ce que quelqu'un de gentil accepterait par exemple de compléter pour nous (dans les grandes lignes) la structure/classe var qu'on utiliserait si on écrivait un interprêteur javascript en C++ ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 /// le var du javascript en C++ struct var { /// un var peu contenir des champs std::map<string,var*> local_var_space; /// ou hériter des champs de ses types parents vector<std::map<string,var*>* > parent_var_spaces; union { /// etre une fonction qui prend des var en paramètre et retourne une référence un var var* (*function_ptr)(...); /// ou contenir une référence sur un var var* ref; /// ou une valeur d'un type de base int n; float f; string s; /// ... /// ou etre un tableau de var vector<var*> vec; }; /// pour le garbage collector int nb_refenrence; };
Est-ce que php (j'ai l'intuition que oui) serait le seul langage qui pourrait rivaliser avec la complexité de javascript/actionscript dans le genre langage fourre-tout avec des milliards de versions différentes et aux concepts trop éparpillés pour être réels ?

Pourquoi ce sont ces langages là (javascript/actionscript et php) qui ont percé sur le web alors que ce sont, j'ai l'impression, les deux langages les plus diaboliques qui n'aient jamais existé ?

Et pourquoi quand on tape 'javascript langage compliqué' sur google on ne trouve rien ? :-)

J'attends avec impatience vos avis. Merci !

31/01/2013, 10h27
gangsoleil

Citation:

Envoyé par acx01b

Est-ce que php (j'ai l'intuition que oui) serait le seul langage qui pourrait rivaliser avec la complexité de javascript/actionscript dans le genre langage fourre-tout avec des milliards de versions différentes et aux concepts trop éparpillés pour être réels ?

Je ne me prononcerait pas sur PHP, mais a supposer qu'il rentre dans la categorie de ce que tu appelles les langages compliques, il n'est pas le seul, loin de la. Tu peux au moins ajouter Perl, plus pleins d'autres que je ne connais pas.

Citation:

Pourquoi ce sont ces langages là (javascript/actionscript et php) qui ont percé sur le web alors que ce sont, j'ai l'impression, les deux langages les plus diaboliques qui n'aient jamais existé ?

Parce que justement, tout le monde peut reussir a faire un truc qui marchotte en bidouillant et triturant le machin dans tous les sens.
A l'inverse, un langage restrictif n'a plus aucune chance de percer dans ce domaine, car il demande de la rigueur et une lourde formation.

Bonjour,

j'ai regardé rapidement V8 le moteur javascript de Google (Chrome) et je n'ai rien compris, impossible de trouver les champs ! Je ne suis tombé que sur des méthodes sur des Handle, donc trop faiblement typées pour y comprendre quelque chose...

Par contre, j'ai trouvé ce petit projet : http://code.google.com/p/tiny-js/
et là le code source est je dois dire assez clair (et simple), bien sûr c'est un tout petit peu moins abouti et performant que V8. Donc voila la structure qu'il utilise pour les var :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 typedef void (*JSCallback)(CScriptVar *var, void *userdata); class CScriptVarLink { public: std::string name; CScriptVarLink *nextSibling; CScriptVarLink *prevSibling; CScriptVar *var; bool owned; }; class CScriptVar { public: // liste doublement chainee pour les champs de notre var CScriptVarLink *firstChild; CScriptVarLink *lastChild; int refs; ///< The number of references held to this - used for garbage collection // au lieu de faire une union, on met tous les types possibles à la suite ... std::string data; ///< The contents of this variable if it is a string long intData; ///< The contents of this variable if it is an int double doubleData; ///< The contents of this variable if it is a double JSCallback jsCallback; ///< Callback for native functions int flags; ///< the flags determine the type of the variable - int/double/string/etc /// je suppose que c'est le contexte (les arguments) de la fonction, si notre var est une fonction ? void *jsCallbackUserData; ///< user data passed as second argument to native functions };
Un var de javascript devient donc ici un CScriptVar* de C++

03/02/2013, 21h25
acx01b

Citation:

Envoyé par gangsoleil

la categorie de ce que tu appelles les langages compliques

Je pense qu'on s'est compris : ce sont les langages qui ne sont pas trivaux à cerner même pour quelqu'un qui a un gros background en programmation.

Citation:

Envoyé par gangsoleil

Parce que justement, tout le monde peut reussir a faire un truc qui marchotte en bidouillant et triturant le machin dans tous les sens.
A l'inverse, un langage restrictif n'a plus aucune chance de percer dans ce domaine, car il demande de la rigueur et une lourde formation.

c'est intéressant, mais de toute façon un langage doit bien définir les types de bases, les possibles objets/classes, la convention de passage de paramètre, les opérateurs, etc...
Un super méta-langage permet de tout faire, mais au final ça devient plusieurs langages, ou au moins un super-langage qui contient plusieurs sous-langages (par exemple la possibilité de faire des regexp directement en PERL c'est un peu un sous-langage intégré).

Par exemple, on peut toujours s'amuser à créer un langage hybride C/Java en ajoutant un bloc __java { } en plus du bloc __asm{ } déjà existant en C, mais faire cohabiter plusieurs nouvelles features dans un langage n'est jamais aisé, et avoir beaucoup de features rend rarement un langage pratique à utiliser.

En allant plus loin, je dirais même que ça pousse les bons développeurs à utiliser les features complexes du langage, et ainsi, les codes "exemples" que l'on peut trouver sur le net deviennent beaucoup plus complexes que nécessaires.

Prenons pour exemple les codes de gestion de liste chainée en C++ qui incluent presque systématiquement les template. Qu'est-ce qu'un débutant pourra bien en faire ? C'est clair : rien ! Trop de feature pénalise forcément les débutants. D'où le paradoxe avec javascript (qui me semble-t-il est un langage complexe, avec beaucoup de features) de l'avoir choisi comme langage de script pour le web, où par définition il y a beaucoup de développeurs débutants.

Citation:

Envoyé par acx01b

Prenons pour exemple les codes de gestion de liste chainée en C++ qui incluent presque systématiquement les template. Qu'est-ce qu'un débutant pourra bien en faire ? C'est clair : rien !

Au contraire ! Il utilisera le code, sans comprendre comment ca marche, en esperant vaguement que ca fasse ce qu'il veut :
Code:

1 2 3 4 new ListeChainee[10]; /* je cree une liste de 10 elements */ ListeChainee.add (mon_objet); /* on ajoute le premier element */ ListeChainee.search (un_objet, ma_liste); /* on cherche l'objet dans la liste */ ...
Bien sur, ca conduit souvent a du code fonctionnel dans 80% des cas, et qui crash violement sinon. Ce qui est bien le cas de pas mal de programmes aujourd'hui, surtout dans les codes faits par des non-developpeurs.

05/02/2013, 07h32
gangsoleil

Un exemple de pourquoi les gens choisissent Javascript : http://treitter.livejournal.com/14871.html

En (tres) gros, c'est connu et ca s'integre avec ce qu'ils font.

je suis ébahi par les performances de V8 le moteur javascript de google chrome...

en effet, si j'ai du mal à trouver la représentation interne des var dans V8 c'est parce que V8 est bien plus qu'un simple interpréteur Javascript, c'est aussi et surtout un compilateur javascript --> assembleur, et avec les optimisations...

Comme petit test j'ai comparé le code qui calcule Fibonacci(k) modulo n implémenté en javascript et en assembleur (visual C++ avec __asm).

Mon code assembleur n'utilise que des registres, on peut donc dire qu'il est optimal.
Le code assembleur / visual C++ :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 /// calcule fibonacci(k) % n int fibo_asm(int k,int n) { k--; int res; __asm { push edi; push ebp; mov ebp, k; mov ebx, 1; // fib(0) mov ecx, 1; // fib(1) mov edi, n; deb: test ebp,ebp; // ebp est le compteur de boucle je fin; sub ebp, 1; mov eax, ebx; add eax, ecx; // eax = fib(k) + fib(k-1) mov edx, 0; /// instruction idiv edi /// divise le nombre 64 bit edx:eax par edi /// met le quotient dans eax, et le reste dans edx idiv edi; mov ebx, ecx; // on update fib(k-1) mov ecx, edx; // et fib(k) jmp deb; fin: pop ebp; pop edi; mov res, ecx; } return res; } int main() { int t0 = clock(); int r = fibo_asm(200000000,25984098); printf("fibo_asm(200000000,25984098) = %d\n", r); int t1 = clock(); int dt = (t1 - t0) * 1000 / CLOCKS_PER_SEC ; printf("dt = %d ms\n", dt); return 0; }
et le code javascript :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 <body> <p id="pHTML"></p> <script> var pHTML = document.getElementById("pHTML"); function printf(str) { pHTML.innerHTML += str; } function fibo(k,n) { var fib_k_moins_1 = 1; var fib_k = 1; k--; while (k > 0) { var new_fib_k = (fib_k + fib_k_moins_1) % n; fib_k_moins_1 = fib_k; fib_k = new_fib_k; k--; } return fib_k; } var t0 = new Date(); var k = 200000000; var n = 25984098; var r = fibo(k,n); printf("fibo_javascript(" + k + "," + n + ") = " + r); var t1 = new Date(); var dt = t1 - t0; printf("<p/> dt = " + dt + " ms"); </script> </body> </html>
et enfin les sorties :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Code assembleur / visual C++ optimal fibo_asm(200000000,25984098) = 1803670 dt = 2077 ms Code javascript / V8 fibo_javascript(200000000,25984098) = 1803670 dt = 2176 ms
Je trouve ça impressionnant.
Si quelqu'un a une idée pour tester les perf de V8 pour ce qui est de l'ajout dynamique de champs à un var ...