Discussion :

[acx01b]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[gangsoleil]

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.

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.

[acx01b]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++

[acx01b]

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.

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.

[gangsoleil]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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.

[acx01b]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...