En Suisse ils ne font pas que du gruyère sans trou, mais aussi un bon langage de programmation "moderne", appelé Scala :
http://scala.epfl.ch/index.html(...)
Il a été développé au LAMP (Laboratoire des Méthodes de Programmation) de l'EPFL (Ecole Polytechnique Fédérale de Lausanne).
Il essaye de concilier programmation fonctionnelle et OO. Il est statiquement typé, et on y trouve pas mal de concepts sympas :
- tout est objet, à la Smalltalk
- il gère la généricité (bon aujourd'hui ça peut paraître classique, c'est vrai)
- les traits, sorte de classes sans état interne, qui permette d'"imiter" l'héritage multiple
- le type d'une variable peut être inféré (localement), ce qui permet de ne pas préciser le type d'une variable à certains endroits
- il possède le moyen de préciser la variance des arguments d'une fonction. Par exemple, un truc qui m'a vraiment étonné, sur les types génériques, on peut préciser que List[String] est un sous-type de List[Object], mais que pour insérer un objet à cette liste, l'argument est contravariant, menant à transformer List[String] en List[Object] si on y ajoute un objet qui n'est pas une sous-classe de String (je pense qu'il prend alors l'ancêtre commun des deux types, j'ai mis Object pour être général)
- et d'autres choses, comme la possibilité d'insérer du XML inline, bref, en l'écrivant tel-quel
Il faut préciser qu'il est compilé pour être exécuté sur une VM Java ou .Net, et qu'il peut utiliser les frameworks de chacun (je pense que ça peut mener à un beau bordel si on doit adapter les classes qui utilisent l'un à l'autre). Je trouve ce point pas super positif, mais bon le langage à l'air vraiment pas mal quand même.
Sinon pour la licence, c'est une BSD-like.
Voilà, j'ai trouvé ce langage lors de recherches sur les différents concepts intégrés aux langages de prog en général, et j'ai trouvé que Scala intégrait un bon paquet de choses que je trouve très utiles & "jolies", programmaticalement parlant. Mais je tiens à préciser que je n'ai pas encore utilisé ce langage, je ne sais pas s'il est bon en pratique, c'est juste ses concepts qui m'ont parus assez intéressants pour en faire un journal...
http://scala.epfl.ch/index.html(...)
Il a été développé au LAMP (Laboratoire des Méthodes de Programmation) de l'EPFL (Ecole Polytechnique Fédérale de Lausanne).
Il essaye de concilier programmation fonctionnelle et OO. Il est statiquement typé, et on y trouve pas mal de concepts sympas :
- tout est objet, à la Smalltalk
- il gère la généricité (bon aujourd'hui ça peut paraître classique, c'est vrai)
- les traits, sorte de classes sans état interne, qui permette d'"imiter" l'héritage multiple
- le type d'une variable peut être inféré (localement), ce qui permet de ne pas préciser le type d'une variable à certains endroits
- il possède le moyen de préciser la variance des arguments d'une fonction. Par exemple, un truc qui m'a vraiment étonné, sur les types génériques, on peut préciser que List[String] est un sous-type de List[Object], mais que pour insérer un objet à cette liste, l'argument est contravariant, menant à transformer List[String] en List[Object] si on y ajoute un objet qui n'est pas une sous-classe de String (je pense qu'il prend alors l'ancêtre commun des deux types, j'ai mis Object pour être général)
- et d'autres choses, comme la possibilité d'insérer du XML inline, bref, en l'écrivant tel-quel
Il faut préciser qu'il est compilé pour être exécuté sur une VM Java ou .Net, et qu'il peut utiliser les frameworks de chacun (je pense que ça peut mener à un beau bordel si on doit adapter les classes qui utilisent l'un à l'autre). Je trouve ce point pas super positif, mais bon le langage à l'air vraiment pas mal quand même.
Sinon pour la licence, c'est une BSD-like.
Voilà, j'ai trouvé ce langage lors de recherches sur les différents concepts intégrés aux langages de prog en général, et j'ai trouvé que Scala intégrait un bon paquet de choses que je trouve très utiles & "jolies", programmaticalement parlant. Mais je tiens à préciser que je n'ai pas encore utilisé ce langage, je ne sais pas s'il est bon en pratique, c'est juste ses concepts qui m'ont parus assez intéressants pour en faire un journal...
> Lire le journal (7 commentaires, moyenne: 2,4).
Vous avez demandé le commentaire #604236.
Run by 
Cette page a été générée par Templeet en 0.0413s (dont 0.0045 de SQL).
Cette page est peut-être conforme xhtml 1.0.
Information sur le site.
Interessant
...mais tu peux réexpliquer plus clairement ce passage :
- il possède le moyen de préciser la variance des arguments d'une fonction. Par exemple, un truc qui m'a vraiment étonné, sur les types génériques, on peut préciser que List[String] est un sous-type de List[Object], mais que pour insérer un objet à cette liste, l'argument est contravariant, menant à transformer List[String] en List[Object] si on y ajoute un objet qui n'est pas une sous-classe de String (je pense qu'il prend alors l'ancêtre commun des deux types, j'ai mis Object pour être général)
Je ne suis pas sûr d'avoir bien tout compris.
[^]Re: Interessant
Bon, je suis vraiment pas doué pour expliquer les choses, alors voici leur exemple :
class Stack[+A] {
def push[B >: A](elem: B): Stack[B] = new Stack[B] {
override def top: B = elem;
override def pop: Stack[B] = Stack.this;
override def toString() = elem.toString() + " " +
Stack.this.toString();
}
def top: A = error("no element on stack");
def pop: Stack[A] = error("no element on stack");
override def toString() = "";
}
Si j'ai bien compris :
- le [+A] veut dire que le type A est covariant, et que donc une Stack[String] dérive d'une Stack[Object] (attention, je crois que Object n'existe pas, c'est plutot AnyRef ou Any qu'il faudrait utiliser, mais on m'aura compris ... j'espère)
- push est une méthode polymorphique (= générique), et [B >: A] veut dire que B est un super-type de A, bref, que A dérive de B. Donc, losrqu'on push un élément sur la pile :
s = s.push[Int](5)
le type retourné sera Stack[Int] (on peut ne pas préciser [Int], le type est inféré). Puis, si on fait
s = s.push(new Object())
(là je n'ai pas précisé [Object]), alors le type renvoyé sera Stack[Object], en bref, notre pile d'Int s'est transformée en pile d'Object. Bien sur, si on ne souhaite pas ce comportement, il suffit que la variable affectée (s) soit du type que l'on souhaite, et une erreur à la compilation sera détectée.
Bon c'est vrai qu'après on peut trouver la construction de cette pile assez étrange, car le code est vraiment fonctionnel plus qu'objet ici (cette pile est gérée à la manière des liste en Lisp, avec une tête et le reste). Au début j'ai eu du mal à comprendre def top: A = error("no element on stack"); !!!
Enfin voila, j'espère avoir été plus clair, sinon la page l'expliquant surement mieux :
http://scala.epfl.ch/intro/variances.html(...)