Depuis un moment déjà, j'aimerais faire évoluer le javascript.
Javascript est un bon langage , son coté fonctionnelle par exemple est excellent, mais il manque de rigueur via notamment un typage fort

Le principe serait donc de garder le modèle à prototype dynamique , mais aussi d'inclure un système de classe a héritage multiple, permettant le refactoring, l’auto-complétion, et l'aide à la programmation et au débogage via un IDE.Des valeurs par défauts pour les arguments aussi , et pourquoi pas du sucre syntaxique comme on peux le voir en phyton ou ruby par exemple.

Le langage serait donc une surcouche au javascript, sa compilation devrait donc être aisé.
La compilation ne devrait pas tant prendre en compte la visibilités des membres (public, private , protected ... ), mais bien de se servir de se nouveau langage pour améliorer ses développements via l'ide, sans trop atténuer les performances.

Bien sur il faudrait une gestion de package, modules , ou l'on puisse identifié qu'elle seront les membre exportable.
Et pourquoi pas inclure les génériques ...

un exemple de se nouveau langage pourrait être :

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
//un fichier est en faite un module et un package
//si celui ci est inclue dans le package org.jo.malibrairie 
//et que ce fichier se nomme Utils, 
//toute les variable publique du fichier apparaîtront dans l'espace de nom org.jo.malibrairie.Utils 
 
//une gestion des importation est nécessaire 
const maLibrairie = import org.jo.maLibrairie; 
 
//des variable et constante typé public ou privé
public var String:maString = "une string";
private const Number:monNombre = 10;
public var RegExp:maRegExp= /^[a-z]#/;
 
//et des générics
var Array<String> = ["a", "b", "c"];
 
//des variable dynamique
var maVarDynamic = {};
 
//des fonctions typé public
public function Number:test(Number:a=5, Number:b=15){
    return a + b;
}
 
//des fonctions non typé privé
private function test2(a, b){
    return a + b;
}
 
//une classe public
public class Test {
    //constructeur
    public constructor(Integer:a, Integer:b){
        var Integer:c = a + b;
    }
    // variable typé
    public String:maString;
    // variable non typé
    protected Dynamic = {};
    //methode typé
    public function void:concat(String:a="hello", String:b="world"){
        this.maString = a + b
    }
    //methode non typé
    private function doWhat(a = {}, b = 10){
        ...
    }
    //methode non typé, mais arguments typé , dont une fonction 
    private function doWhatThat(Function(Number:a)->Number:a = function(a){return a}, Number:b = 10){
        ...
    }
}
 
//une classe abstraite
private abstract class Test2  {
 
    public abstract function Number:test(Number:a=5, Number:b=15);
 
    protected function String:test(String:a, String:b){
        return a + b;
    }
}
 
//une classe multi hérité
public class Test3  extends Test as Test , Test2 as Test2, maLibrairie.Test3 as Test3 {
 
    public constructor(Integer:a, Integer:b){
        ....
        super.Test(a, b);
        ....
        super.Test3();
    }
 
    //implémente la methode de Test2:test2
    public function Number:test(Number:a=5, Number:b=15){
        return a+b;
    }
 
    public function Number:test2(Number:a=5, Number:b=15){
        ...
        return super.Test3.test(a, b),
    }
 
    //en cas de conflie d'héritage, la fonction teste pouvant hérité de Test et Test3 , alors on la définit comme telle
    //sinon l'ordre de définition des classe étendue prendera le dessus
    test -> Test3
 
}
La redéfinition d'un membre avec la même signature, ou l'ajout de nouveau membres d'une classes ou module pourrait logiquement se faire sans perturber le travaille de l'ide.

C'est bien sur un projet très très très ambitieux . Comme je l'ai dis la partie compilation ne pause pas de problème, mais celle de l'intégration dans un IDE , beaucoup plus.
Ce projet n'est qu'une ébauche, et je cherche des gens pour m'aider, et ou, proposer de nouvelle idées.
Je sais qu'il existe déjà certain projet de ce type, mais peux me satisfont vraiment. Notamment à cause de l’héritage multiple.
Ce projet m'est venue grâce au projet xtext, un plugin d'eclipse, qui permet de facilement (tout est relatif ) développer ce genre de langage.
Un article d'introduction à été déposé sur dvp icihttp://gkemayo.developpez.com/eclipse/intro-xtext/

J'espère que certains d'entre vous seront intérréssé... il me faudra des mois voir des années pour aboutir à un tel projet, si je ne l'abandonne pas, malgrès qu'il me tiens à coeur. Alors si vous vous sentez pret ....