Journal L'expressivité des langages

Posté par  (site web personnel) .
Étiquettes : aucune
0
30
mai
2007
Le contenu de LinuxFr parlant encore une fois peu de son sujet principal, je vais me dévouer une nouvelle fois afin de tenter de lancer un débat intéressant (?), sur le même sujet qui me tiens toujours à coeur ;-)
Golum va nous manquer, mais on fera sans :(
C'est une lapalissade de dire que l'on cherche à créer des langages permettant de disposer de plus d'expressivité afin d'améliorer la productivité.
Des langages comme Ruby, caml, perl, python, etc... sont à la mode, permettent d'aller plus loin, de diminuer la taille du code, en sacrifiant parfois à la lisibilité.

Il me semble depuis quelques mois que mes réflexion avancent sur ce sujet, que la clé d'une (r)évolution réelle des langages de programmation nécessite la mise au point d'un langage déclaratifs (axiomatiques) turing complet.

Les expression régulières, le langage Xpath, le Sql, etc... sont des langages axiomatiques, déclaratifs sans être turing complet, et c'est bien normal car leur objectif est d'être spécialisé, ce qui permet leur existence.
En effet, passer du paradigme régnant aujourd'hui en maître dans les paradigmes de langages - consistant à décrire à l'ordinateur les étapes successives de traitement permettant d'aboutir à un résultat - à des paradigmes dans lequel on décrit quelques règles de manières déclaratives en demandant à la machine d'inférer, est une étape difficile, peu explorée en réalité, et posant plein de problèmes théoriques.

Adoptons une démarche incrémentale.

Les langages actuels, langages fonctionnels y compris, se contentent de décrire un graphe orienté, décrivant le parcourt d'un automate virtuel.
Que l'on ajoute tous le sucre syntaxique que l'on veut, que l'on permette de mettre des fonctions en paramètres d'autres fonctions, on est toujours rappelé par cette réalité.
L'objectif des librairies, de la programmation fonctionnelle, objet, est souvent de cacher localement cette réalité, en rendant déclaratif certains traitements.

Certains langages, parce que dynamiques ou bien compilé, sont grâce à leur sémantique interne capables d'implémenter des traitement déclaratif de haut niveau.
Les langages fonctionnels, ou objets implantant une sorte de type Block (ie. correspondant à une liste d'instructions) permettent en effet de définir des fonctions exécutant un code donné en argument dans certains cas, de procéder à des opérations ensemblistes sur des tableaux avec des fonctions de comparaisons données par les utilisateurs.
En particulier, on peut y implémenter les opérations de bases chères au utilisateurs de langages fonctionnels, comme map, fold et filter : http://www.cse.unsw.edu.au/~en1000/haskell/hof.html [1]
Ces fonctions restent assez abordables et sont d'une puissance fabuleuse.


Je rappel une problématique qui me semble clé :
Un langage plus expressif, plus puissant, doit l'être tout en restant le plus abordable possible, avec l'approche qui a prévalu lors de la création d'un langage comme LOGO ou AppleScript : permettre à des non informaticiens un minimum logique d'écrire au moins de petits programmes.
Si on oublie cette problématique, alors la question est réglée : il faut jeter Java/C#/C++, et former tout le monde d'urgence à Haskell/Caml/Lisp/Oz.
Malheureusement, peu de développeurs ont le niveau théorique leur permettant de maîtriser un tel langage.
Je me souviens que la plupart de mes collègues de BTS ne maîtrisaient pas vraiment le concept de fonction d'un point de vue théorique (produit cartésien, tout ça), mes collègues de boulot pareil (la fameuse réponse "un langage fonctionnel ? C'est un langage qui marche ?").
Et même des gens très qualifiés peu habitué à cette logique ne la trouve pas aisée à prime abord.
Un exemple récent est cet échange http://linuxfr.org/comments/834613.html#834613 [2] dont tout habitué de LinuxFR reconnaîtra des interlocuteurs très compétents.
Bref, je pense que la formation n'est pas l'unique problème de la marginalité des langages fonctionnels, même si elle reste importante.

Plusieurs voies d'évolution:

Le déclaratif sur les données

La plupart du temps, les données sur lesquels on travaille ont une forme d'arbre, on est donc en terrain connu, et des formalismes comme Object Query language (ou tout autre query language conçu pour Xml) par exemple, permettent de rendre déclaratives des opérations qui en ont bien besoin.
En effet, d'après http://www.st.cs.uni-sb.de/edu/seminare/2005/advanced-fp/doc(...) [3] , 90 % des entiers du code source du jeu Unreal sont dédiés à parcourir des tableaux. C'est certes un exemple spécifique de par la part prépondérante de concepts issus d'algèbre linéaire dans ce genre de logiciel, mais pour des logiciels de gestion, on en est sûrement pas très loin, en tout cas en ce qui me concerne.
Disposer d'un SQL objet built in le langage permet d'accéder beaucoup plus vite à l'intuition du développeur, gage de réduction d'erreurs, de productivité, comme l'expliquait Victoria Livschitz dans une interview (traduction française aproximative ici : http://linuxfr.org/~Montaigne/19629.html [4] ).
En effet, on se retrouve ici avec un problème de (sucre) syntaxe(ique) : même si l'on peut implémenter des fonctions sur listes permettant de réaliser des intersections, unions, différence avec en argument la fonction de comparaison, permettant au fin du fin de recomposer à peu près proprement et à peu près déclarativement une requête SQL, ces dernières sont plus intuitives car tout simplement plus proches du langage naturel.

Par exemple pour trouver les chaîne égales, dans listStr au chaînes embarquées dans un objet Item :
Select listStr.element from listStr, listItem where listStr.element = listItem.element.link
(ici élement est le nom que l'on donne au champ d'une table avec un champ unique, un tableau de chaîne par exemple)
On peut l'écrire aussi :

liststr.intersection(listItem, {listStr.element = listItem.element.link});

ou pire en java
Vector t3 = listStr.intersect_with_func(listItem,new FonctionBool() {
public boolean compare(Object el1, Object el2){ return ((String)((Item)el1).link).equals((String)el2)); } }
);



La richesse dans la déclaration des structures

D'après [3], page 35 une statistique impressionnante : 40 % des for du code du moteur d'Unreal sont des compréhensions fonctionnelles, c'est à dire une liste du genre :
s = [ x | x E [0..inf] | x²>36 ];
s est bien entendu une liste.

Il faut bien reconnaître que les variables déclarées classiquement dans nos langages typés (Java/C# pour citer les plus utilisés dans l'industrie) sont des stéréotypes directement issus de la machine.
Un entier est arbitrairement compris entre -2^n et 2^n
Une chaîne est une liste de caractère.
Un flottant est de même un nombre compris entre -2^n et 2^n mais avec des décimales en +, elle même cadrées.
Bref, ce n'est pas intuitif, et le programmeur est obligé de tracer les effets de bords et les répercutions de ce genre de partis pris aux racines historiques.
Il serait peut être temps de proposer des langages à vocation industrielle, d'informatique de gestion, ayant des syntaxes permettant de décrire une variable selon une structure prédéfinie, et non plus un stéréotype machine calqué sur les registres du processeur.
Que ce modèle fut valable sur des machines tournant à quelques mégahertz et quelques centaines de Ko de mémoire est parfaitement cohérent. Mais avec presque 3 Ghz et plusieurs Go, des compilateurs puissant permettant une analyse de flot (analyse de toutes les exécutions possible du code, ce genre d'algo consomme beaucoup de mémoire à la compilation), il serait peut être temps...

Après cette digression, quelques exemple :

Une chaîne avec un masque
str : \d{2}-\d{3}-\d{2}
ou le contenant
str : [ String | contains \d{2}-\d{3}-\d{2} | StartWith W];

Un entier appartenant à un sous ensemble de |N

i : [ x : Int | x E [0..inf] | x mod 2 = 0 | x>51];




Un pattern matching à tout les étages

L'idée d'utiliser du filtrage à haut niveau se retrouve dans Caml, ou plus récemment dans TOM http://tom.loria.fr/ [5]

En caml, on peut faire du filtrage de type, ainsi que de forme de liste. A ma connaissance, on ne peut pas faire grand chose de plus, mais c'est déjà assez puissant.
TOM, dont je reprendrai ici juste des idées, permet déjà de faire des choses un peu plus sioux
(je reprend ici un slide http://sedre.loria.fr/seminaire/060203-ACL-YTo.pdf [6])

(x*,a,y*) : recherche l'élément a dans la liste
f(X1*,x,x,Y*) -> f(X*,x,Y*) : élimine des doublons.
Ca ressemble encore beaucoup à du langage mathématique, mais c'est pas mal intuitif
TOM est très intéressant, mais comme tous les trucs de la fac, ça y restera, et de toutes façons c'est quasiment imbitable.
Ce serait un langage très intéressant à recomposer afin d'en faire quelque chose d'un minimum intuitif.
On pourra aussi proposer de la manipulation d'arbre :

[
<b @Match "(i.*)"=@Match"\d+">[
@Match ".*?\d+.*?Attention.*"
]
@Match "(.*)"
]
->
[
[
<bla id="3" @Match.capt 1=@Match.capt 2>@Match.capt 3
]
]

ou
[
@match_grammar "(.*?)ELEMENT `(?[0-9]+[A-Z]?)?`{'and',',',' ',`(?[0-9]+[A-Z]?)?`}(.*?)"
]
->
[
@capt 1 @match_grammar.captur.foreach elt <ref id=@fonctionTrouveIDde(elt)>[(elt)]
];

( les `` servent à capturer
Bon ma syntaxe est pourrie (et pas intuitive ;-), mais l'idée est décrire des sortes de regexp, et de définir des règles de transformation
Le dernier exemple est un cas réel dans sa forme (complètement réécris bien sûr), et m'a posé pas mal de problèmes, à coder à la main, en java.


Le problème du pattern-matching, lorsqu'on le mélange à un paradigme classique de description d'automate virtuel, est le bordel que ça implique dans le code car cela peut rentrer en collision avec des données (la variable tmp de type string qui peut valoir toutes sorte de choses le long de l'exécution du programme).
Je ne parle même pas de la programmation orientée Aspect, cette intéressante bidouille, qui consiste à faire faire à l'automate des sauts en 4ème dimension du graphe...


Vers une grammaire à langage naturelle

Car là est peut être la clé la plus fondamentale du changement: un langage intuitif est proche du langage naturel (non, Cobol est un faux contre exemple). Mais cela nécessite peut être de dépasser les grammaires LL, LR, etc...
Ces grammaires vérifient une liste de règle basé sur le typage d'expression.
Une grammaire de langage naturelle, se base sur la nature des mots, et de celle-ci émerge une fonction. C'est le sens du mot combiné avec le graphe syntaxique qui fait émerger le sens.
Le gros problème de ces grammaires est leur potentielle ambiguïté.
J'ai rien d'autre d'intelligent à dire sur ce sujet ;-)
  • # pas mal !

    Posté par  (site web personnel) . Évalué à 3.

    J'ai rien d'autre d'intelligent à dire sur ce sujet ;-)

    De toute facon qui va tout lire ?
  • # Commentaire supprimé

    Posté par  . Évalué à 5.

    Ce commentaire a été supprimé par l’équipe de modération.

  • # ambiguité

    Posté par  (Mastodon) . Évalué à 2.

    Je ne sais pas si tu parles d'un problème d'ambiguité syntaxique ou sémantique, pour les langages naturels... Le premier est évident et déjà un peu bloquant, mais le second est bien plus problématique à mon avis. Les langages informatique sont formels, mais ce n'est pas uniquement pour des raisons techniques au niveau du compilateur, comment gérer le flou de nos langages ? Parfois quand on me parle je comprend de travers, alors que faire ?
    • [^] # Re: ambiguité

      Posté par  (site web personnel) . Évalué à 4.

      Il existe des langages naturels conçu par des linguistes afin de s'assurer qu'il n'aient aucune ambigûités.
      Le lojban http://fr.wikipedia.org/wiki/Lojban en est un exemple
      Sa grammaire est conçu pour être non ambigüe, et expressible de façon unique.

      Bien entendu, c'est un langage assez déroutant, qui, bien que quasiment conçu dans l'idée (entre autre) de permettre un jour le dialogue entre ordinateur et humain, reste assez difficile à apprendre, et en tout cas impossible à imposer culturellement comme base d'un langage de programmation.

      On pourrait alors se tourner vers le basic english http://ogden.basic-english.org/fbasice.html qui propose une version simplifiée de l'anglais.
      Il s'agirait de la simplifier, de la transformer en grammaire type pidgin et d'user obligatoirement de parenthèse afin de lever les ambigûités.
      Je m'étais amusé à imaginer ce que cela pourrait donner : http://wiki.loria.fr/wiki/Lisaac/M%C3%A9talangage

      Plus sérieusement, le problème est de prouver que l'on puisse extraîre une grammaire non ambigue en simplifiant une langue naturelle, c'est un problème théorique sur lequel un travail de recherche serait intéressant.

      Maintenant, je n'ai parlé des langages naturels qu'en fin de texte, et ça occulte 80% du texte qui parle d'autre chose. Et c'est plus ça qui m'intéresse...

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: ambiguité

        Posté par  . Évalué à 3.

        J'ai pas mal discuté avec un informaticien linguiste de mon labo et il fait de la détection d'ambiguïté dans le langage naturel. Dans le contexte du langage naturel, ce n'est pas parfait mais dans le cas d'un truc plus basique, ça doit pouvoir trouver toutes les ambiguïtés.

        Ce que je veux dire, c'est qu'imposer les parenthèses n'est pas nécessaire. Dans pas mal de cas, ce n'est pas ambigu. En revanche, le compilo peut te dire là où il en manque, un peut comme quand le compilo d'ocaml te dit que ton patern matching n'est pas exaustif et qu'il te sort un exemple.

        Blop.
        • [^] # Re: ambiguité

          Posté par  (site web personnel) . Évalué à 2.

          Tu m'intéresses beaucoup là !
          Il a fait des papiers là dessus ? Il s'appelle comment ?

          « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

          • [^] # Re: ambiguité

            Posté par  . Évalué à 2.

            Je n'ai rien sous la main. Je vais demander au gars.
      • [^] # Re: ambiguité

        Posté par  (Mastodon) . Évalué à 3.

        Je pensais justement au lojban en faisant la distinction entre ambiguité syntaxique et sémantique: si le lojban n'est pas ambigu syntaxiquement, il reste ambigu sémantiquement au même titre que n'importe quel langagé parlé, qui a besoin d'un peu de souplesse.

        En gros, j'ai peur que même si on programme en lojban ou autre langage non ambigu, on se retrouve, pour exprimer clairement ce que l'on veut, à devoir écrire des tonnes de précisions.
    • [^] # Re: ambiguité

      Posté par  . Évalué à 3.

      Il y a plusieurs niveaux de compréhension du langage :
      - lexical (les mots sont dans le dico), ok
      - syntaxique (les phrases sont elles bien formées), ok
      - sémantique (la phrase a-t-elle un sens ?), déjà assez difficile...
      - pragmatique (dans quel contexte a été énoncée la phrase ?).

      Ce dernier est trop négligé par les informaticiens :-)

      exemples archi-connus :
      1) la petite brise la glace
      2) le boucher sale la tranche

      c'est bon lexicalement, syntaxiquement et sémantiquement. Il manque cependant le contexte pour comprendre ces phrases sans ambiguïté :
      1) s'agit-il d'une petite fille qui casse la glace ou d'un petit vent qui la congèle ?
      2) le boucher met-il du sel sur le steak ou n'est il pas propre et il la coupe ?

      Bref, je ne vois pas comment un compilo pourrait comprendre le contexte :-)
      • [^] # Re: ambiguité

        Posté par  (site web personnel) . Évalué à 2.

        >>>exemples archi-connus :
        1) la petite brise la glace
        2) le boucher sale la tranche

        Je connaissais juste
        "la belle ferme le voile"
        encore un exemple où seul le contexte permet de savoir où est le verbe dans la phrase.

        ウィズコロナ

  • # cduce ? et les sous type ?

    Posté par  (site web personnel) . Évalué à 2.

    http://www.cduce.org/ fait ce que tu as l'air de décrire pour manipuler facilement du XML. Et je trouve plus souple la notion de sous-type qui ressemble aux ensembles mathémtiques que la notion de classe.

    "La première sécurité est la liberté"

    • [^] # Re: cduce ? et les sous type ?

      Posté par  (site web personnel) . Évalué à 2.

      Oui, je leur ai piqué 70% de la syntaxe ;-)
      Cduce est extrêmement intéressant, mais un peut trop universitaire, et pas assez adapté au monde de l'entreprise.

      Je bosse dans un boite où on fait de l'ingé documentaire et à ce titre je travaille beaucoup sur de l'XML, mes collègues et moi avons pas mal d'expérience dans le domaine (surtout eux, ça fait qu'un an que j'y suis).
      Je les vois franchement pas se former à CDuce. C'est même pas la peine que j'en parle, on va encore me regarder comme un extraterrestre, déjà que je leur fait peur avec Perl et les expressions régulières...
      C'est très dommage, car on multiplierait notre productivité par 3.

      Il faut donc concevoir un truc qui soit plus facilement utilisable, quitte à ce que ce soit un front-end pour cduce, le pied c'est que ça produise du bytecode Java, là je pense que Cduce aurait beaucoup de chance d'être utilisé.

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: cduce ? et les sous type ?

        Posté par  (site web personnel) . Évalué à 2.

        Je croyais que tu réfléchissais à une lib pour lisaac et non à un nouveau langage.

        "La première sécurité est la liberté"

        • [^] # Re: cduce ? et les sous type ?

          Posté par  (site web personnel) . Évalué à 2.

          Il y a une limite à l'extensibilité de Lisaac, et il faut que le langage garde sa cohérence.
          Une fois la réflexivité disponible, on pourra probablement coder ce genre de chose dans la lib, et j'y pense souvent.
          C'est d'ailleurs vrai pour d'autre langage.

          Le problème, c'est que ça sera toujours une chaîne de caractère en argument de fonction.

          « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

          • [^] # Re: cduce ? et les sous type ?

            Posté par  (site web personnel) . Évalué à 2.

            Je ne voie pas trop ça comme un problème.

            Pour une telle lib, tu as besoin de la reflexivité.

            Si le système de build est géré par lisaac lui-même, tu peux imaginer de la compilation paramètrique (en gros, cela revient à compiler à la volé, modulo le fait que l'on ne cherche pas du tout à être léger et que cela intervient à la compilation du projet). Donc, cela permet de faire des filtres de code comme certain module perl (je sais cela peut paraitre immonde mais cela ne se passe qu'à la compilation et c'est juste pour une lib).

            Tu peux imaginer une fonction qui contient du code en "string" mais qui sera compiler elle-même, un peu comme les regex du perl.

            "La première sécurité est la liberté"

            • [^] # Re: cduce ? et les sous type ?

              Posté par  . Évalué à 2.

              Les source filters, c'est sale, parce qu'on n'a pas de parseur. Une vraie bonne approche serait de pouvoir changer la grammaire dynamiquement (comme en Perl 6).

              Tu peux imaginer une fonction qui contient du code en "string" mais qui sera compiler elle-même, un peu comme les regex du perl.

              Ou plutôt comme eval("...code...") non ?
              • [^] # Re: cduce ? et les sous type ?

                Posté par  (site web personnel) . Évalué à 2.

                non car c'est à faire à la compilation.

                Mais pas besoin de filtre de source pour faire ça, il "suffit" d'un bon propagateur de constante suivi d'une élimination de code mort.

                Le filtre de source est plus pour se permètre d'ajouter un sucre syntaxique. C'est crade mais si lisaac contient son propre compilo, on peut imaginer utiliser le parseur de lisaac lui même avant de faire une modification.

                Lisaac étant minimaliste, je ne pense pas que bidouiller sa grammaire soit super utile et propre.

                "La première sécurité est la liberté"

      • [^] # Re: cduce ? et les sous type ?

        Posté par  . Évalué à 2.


        Il faut donc concevoir un truc qui soit plus facilement utilisable, quitte à ce que ce soit un front-end pour cduce,


        Est-ce qu'un graphical front-end pour CDuce tel que celui decrit dans ce papier

        http://www.pps.jussieu.fr/~gc/papers/pbe.pdf

        irait ?

        Sinon, nous on est prenant pour des suggestions. Tu peux les poster dans users@cduce.org

        No bytecode I'm afraid (pas tout de suite au moins)

        ---Beppe---
    • [^] # Re: cduce ? et les sous type ?

      Posté par  . Évalué à 2.

      En l'occurence, ça ne "ressemble" pas aux ensembles mathématiques. "Semantic subtyping" (l'article fondateur derrière CDuce) montre qu'il y a équivalence parfaite (chose qui était connue intuitivement depuis un moment, mais que personne n'avait jamais démontré avant).
      • [^] # Re: cduce ? et les sous type ?

        Posté par  (site web personnel) . Évalué à 2.

        Je n'ai pas le back ground de math necessaire pour affirmer ça.

        Par contre, l'interret est dans la somme de code qui disparait. En fait, il y a plein de classes mères virtuelles qui deviennent inutile et en plus cela retire une dépendance qui est souvent artificielle.

        "La première sécurité est la liberté"

        • [^] # Re: cduce ? et les sous type ?

          Posté par  . Évalué à 2.

          Mmmh, ce n'est pas tant un problème de background en maths que d'info théorique (les maths utilisées sont des formules logiques, le plus souvent du premier ordre : ET, OU, etc.). Mais de l'aveu d'un de ses rédacteurs, l'article en lui-même est franchement difficile d'accès. :-)

          Un article plus « simple » (même s'il reste très théorique) est « A gentle introduction to semantic subtyping » [1]. Ça reste plutôt difficile à digérer quand on n'a pas l'habitude, mais c'est extrêmement intéressant.

          À noter qu'une bonne intro à ces deux articles se trouvent dans le rapport de stage de DEA d'Alain Frisch; pour les courageux, sa thèse (230 pages) explique tout, du côté « semantic subtyping » jusqu'à l'implémentation de CDuce. Là par contre, j'ai décroché assez vite.

          [1] « gentle », mais bien sûr ...
  • # Superbe ! mai je me pose une question...

    Posté par  . Évalué à 3.

    Dommage qu'on ne puisse pas, au moins, plusser les journaux... celui-ci est superbe... pourtant je me pose une question, plusieurs en fait :

    - l'utilité d'avoir plusieurs langages n'est-elle pas, justement, d'adapter le code à la vocation de l'application, à son but ? (chuis peut être pas clair, j'ai la crève, soyez indulgents !)

    - avoir différents langages ne permet-il pas d'approcher un problème, de "l'expliquer à la machine", de manières différentes, de manière à optimiser la vitesse d'exécution, ou optimiser la taille en mémoire, de manière à être plus simplement maintenu et répandu etc... ?

    - un langage dit "naturel" ne l'est réellement que si on connaît sa grammaire et sa syntaxe. Le mandarin est très naturel pour un chinois, beaucoup moins pour un français, par contre, l'italien peut être assez naturel pour un espagnol ou un français... bref... n'est-ce pas un peu trop suggestif pour permettre d'aboutir à quelque chose de réellement utile ? Il est vrai, c'est un peu la quête du graal, mais est-ce réellement réalisable/pertinent/opportun de chercher à créer un N° langage qui se veut naturel tout en sachant qu'il ne pourras jamais autant l'être qu'on le voudrait ?

    voila pour les questions, je retourne au lit avec ma bouillotte...
    • [^] # Re: Superbe ! mai je me pose une question...

      Posté par  (site web personnel) . Évalué à 2.


      - l'utilité d'avoir plusieurs langages n'est-elle pas, justement, d'adapter le code à la vocation de l'application, à son but ? (chuis peut être pas clair, j'ai la crève, soyez indulgents !)

      Oui mais pour moi, c'est une bidouille organisée. Ca oblige les devs à connaître différents langage. Déjà que mon chef veut pas entendre parler de Perl parcque qu'on est que deux dans l'équipe à le connaître, j'ose pas imaginer une approche avec 5 langages différents.

      C'est pour cela que je réfléchissais à un saint graal qui unifie le tout.

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: Superbe ! mai je me pose une question...

        Posté par  (site web personnel) . Évalué à 2.

        Bah si lisaac est suffisement souple, cela devient une histoire de lib.

        Si il permet de remplacer les Makefile, les autotools, des générateurs de codes, c'est déjà pas mal.

        Lisaac a pour lui ça syntaxe hyper simple de base. Si ensuite, il intègre de la preuve et le système de "contenaire magique", il peut faire déjà beaucoup !

        "La première sécurité est la liberté"

      • [^] # Re: Superbe ! mai je me pose une question...

        Posté par  . Évalué à 2.

        Je pense, moi aussi, que l'avenir est aux DSL (domain-specific languages), et plus precisement a un language unique permettant d'incorporer differents DSL simultanement dans un meme langage.

        L'utilisation de certains DSL peut paraitre evident (comme cites ci-dessus: Xpath, SQL etc); ce qui l'est moins c'est l'utilisation de DSL integres au languages par exemple, des sous-langages permettant d'ecrire des parseurs comme Bison, ou des
        extensions SQL a C). Peu de langages encouragent a l'utilisation systematique de DSL, a part Lisp (a ce propos, j'encourage fortement la lecture de On Lisp, de Paul Graham, disponible gratuitement sur internet).

        Cette utilisation systematique permet effectivement de rendre les programmes de plus en plus declaratifs, et de permettre de faire des verifications au "compile-time".

        Un exemple: un DSL precis pourrait etre les interfaces utilisees dans le noyau Linux.

        Par exemple, un driver reseau utilise ceci:

        static struct pci_driver ne2k_driver = {
        .name = DRV_NAME,
        .probe = ne2k_pci_init_one,
        .remove = __devexit_p(ne2k_pci_remove_one),
        .id_table = ne2k_pci_tbl,
        #ifdef CONFIG_PM
        .suspend = ne2k_pci_suspend,
        .resume = ne2k_pci_resume,
        #endif /* CONFIG_PM */

        };

        L'utilisation d'un DSL pour les drivers PCI du noyau resulterai en qqchose comme ceci:

        pci_driver ne2k = {
        name : DRV_NAME;
        probe : ne2k_pci_init_one;
        remove : ne2k_pci_remove_one;
        id_table : ne2k_pci_tbl;
        suspend : ne2k_pci_suspend;
        resume : ne2k_pci_resume;
        }

        Ce type de DSL permettrait de gerer plus facilement les changements d'interface binaires (pas besoin de retoucher aux sources), et permet de faire des verifications a la compilation (typage par exemple).

        Utiliser un tel DSL n'est pas apprendre un nouveau langage; c'est extremement simple, et plus simple que d'apprendre a utiliser une librairie par exemple.

        Le langage L (http://www.nongnu.org/l-lang , attention la page est un peu outdated) est concu pour pouvoir ecrire ce type de DSL. A titre d'exemple, voici un extrait d'un parseur ecrit dans le DSL de parseur:

        grammar Numeric = {
        rule Digit:Character = d:[0-9] { d - Character( '0')};
        rule Decimal_Number:Int = n:( d:[1-9] {d - Character( '0')})
        (d:Digit {{n = n*10; n = n+d}})* {n};

        rule Hexa_Digit:Character = (Digit | d:[a-f] { d - Character( 'a')});
        rule Hexadecimal_Number:Int = "0x" n:{0}
        (d:Hexa_Digit {{n = n*16; n = n+d}})* {n};

        rule Number:Int = Decimal_Number | Hexadecimal_Number
        }

        Dans cet exemple, on mixe la DSL du parseur (permettant d'exprimer la grammaire) avec du code L (permettant d'exprimer des actions semantiques). Dans ce cas precis, on est en train de calculer la valeur des entiers parses tout en les parsant.

        En resume, je pense que ce type de langage permet une plus grande surete, flexibilite, et facilite d'utilisation par la programmation declarative. Par contre, je ne pense pas que le langage naturel soit la cle, mais plutot d'avoir des syntaxes specifiques bien adaptees a chaque DSL.

        Si vous etes interesses par ce type de langage, L est en plein developpement mais est deja fonctionnel (il dispose d'un compilateur dynamique, de DSL facilitant le developpement, et d'un translateur vers C, et une partie de L est deja ecrite en L);

        un exemple de projet serait l'ecriture d'un DSL pour l'inline assembleur (qqchose qui fonctionne mieux que le asm de GCC, qui ne comprend pas l'assembleur inline).
  • # on décrit quelques règles de manières déclaratives en demandant à la mac

    Posté par  . Évalué à 6.

    C'est pas ce que Prolog fait ?

    http://fr.wikipedia.org/wiki/Prolog :
    un langage de programmation qui permettait d'utiliser l'expressivité de la logique au lieu de définir pas à pas la succession d'instructions que doit exécuter un ordinateur.

    BeOS le faisait il y a 20 ans !

  • # je veux plus un langage ou une syntaxe

    Posté par  . Évalué à 5.

    les langages un poil évolués ils finissent tous par devenir isomorphes en dessous, avec au final les impératifs d'un coté et les fonctionnels de l'autre. et on finit par retrouver les mêmes concepts comme l'objet dans chaque lointain rejeton du C ou de Lisp.

    moi depuis longtemps je préfèrerai assembler graphiquement des bouts de code comme ici :

    http://llk.media.mit.edu/projects/scratch/help/images/greate(...)

    ou

    http://llk.media.mit.edu/projects/scratch/help/images/mouseY(...)

    (un bout de code associé au sprite/acteur du chat)

    le projet pédagoqique Scratch http://scratch.mit.edu/ est sous licence MIT et s'il ne tourne pas encore officiellement nativement sous Linux, on en est bien proche :

    http://scratch.mit.edu/forums/viewtopic.php?id=252

    il tourne déjà sous Wine et le port est plus que possible (basé sur Squeak, on peut déjà ouvrir l'image avec une machine virtuelle Squeak, ce qui ne marchera pas de suite ça sera quelques détails multimedia)

    et voici d'ailleurs un pacman :

    http://img259.imageshack.us/img259/9456/pacmanmc4.png

    on notera que le "code" est localisable automatiquement et que sa structure reste inchangée.

    je ne pense pas qu'il soit très dur d'imaginer des blocs pour gérer des tableaux, listes, maps et autres collections. actuellement on peut se créer des variables de type numérique (qui est déjà massivement utilisé pour la position et la direction des sprites) mais on s'aperçoit vite qu'elles sont peu nécessaires. ah, on peut envoyer des messages entre acteurs, aussi...

    il doit être trivial de réunir et nommer des tas de blocs ordonnés pour en faire d'autres blocs ou superblocks réutilisables : je veux dire par là que cet aspect est un grand classique qu'on retrouve dans d'autres environnements d'assemblage de blocs ou composants logiciels.

    maintenant on pourrait se creuser la tête sur comment créer des blocs supplémentaires dans cet environnement, à partir d'autres blocs et sans trop aller les coder en Smalltalk derrière : par exemple pour régler le volume : ce bloc manque, il faudra bien disposer d'une primitive setVolume...
    • [^] # Re: je veux plus un langage ou une syntaxe

      Posté par  (site web personnel) . Évalué à 2.

      C'est extrêmement intéressant comme approche : il ne l'attaque pas au niveau sémantique, mais au niveau de la métaphore.

      Par contre au niveau sémantique, on découvre un ajout hyper intéressant auquel je pense souvent, et qui est un peu dans la lignée de Prolog : le "forever" que l'on trouve ici.
      On exprime des contraintes, à l'interpréteur de se débrouiller.

      Le problème, c'est que l'on peut tomber dans des contradictions logique. Donc soit l'interpréteur permet de détecter qu"il y a problème, soit on a carrément un moteur logique qui va essayer de le détecter à priori

      Le développement d'une librairie est fondamentale, car c'est avec elle que se structure une taxinomie/ontologie, ou tout au moins une structuration des concepts de façon à être réutilisables.

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

  • # Les mathématiques Formels

    Posté par  . Évalué à 2.

    J'ai lu dans le magazine l'Ordinateur Individuel de ce mois-ci que le partenariat entre Microsoft-Research et l'INRIA portait entre autre sur la programation basé sur les mathématiques formels.
    Partant du principe que dans les mathématiques, toute les équations sont démontré et on est sûr qu'il n'y a pas d'autres solution possibles que celle connu (ouai bon je maîtrise pas trop, je vous dis ce que j'en ai compris), ils espèrent à terme débouché sur la programmation de logiciels totalement dépourvu de bug. (belle utopie ;-) )
    Cela débouchera certainement sur un nouveau langage de programmation, bien que dans l'article ils ne parlaient que de la "manière" de concevoir un logiciel (phase d'études préliminaire et tout ça)
    En tout cas, si jamais ça débouche sur quelques chose d'intéressant, comme cette techno sera certainement matraqué de brevet, j'espère que l'ont verra quelques chose de similaire en libre bien avant les premiers résultat de leur techno pour qu'ils nous accusent pas de piller leurs propriété intellectuelle.
    • [^] # Re: Les mathématiques Formels

      Posté par  . Évalué à 5.

      C'est le genre de chose que fait COQ.

      L'idée est d'utiliser la correspondance de Curry-Howard.

      En math, on démontre souvent des trucs du genre: A implique B.
      En info, on code souvent des fonctions qui prennent A et qui rendent B.

      Si on réinterprète les maths, le théorème A implique B, ce n'est rien d'autre qu'une fonction qui, à partir d'une preuve de A, te rend une preuve de B. C'est la même chose.

      En brodant un peu (beaucoup), on obtient un truc comme COQ qui permet de générer du code certifié. La seule chose, c'est que le mode de programmation est carrément spécial.

      Exemple, pour programmer un tri, on démontre le théorème suivant:
      Il existe une fonction f de l'ensemble des listes dans l'ensemble des listes telle que
      - f(l) est une permutation de l
      - f(l) est triée.

      Une fois le théorème démontre, on peut demander à COQ de sortir du code implémentant une fonction qui vérifie les hypothèses du théorème: un tri.

      Bref, le jour où les programmeurs de base sauront utiliser ce genre d'outil n'est pas encore arrivé.
    • [^] # Re: Les mathématiques Formels

      Posté par  . Évalué à 3.

      Tout cela existe déjà cela s'appelle les méthode formelles http://en.wikipedia.org/wiki/Formal_method .

      Ce n'est pas spécialement breveté peut-être car c'est plus un domaine universitaire que industriel. Néanmoins de véritable application industriels on déjà été réalisé surtout dans le domaine des logiciels embarqués (train et avion notament). (et il risque d'en avoir de plus en plus, surtout si un jour des gens meurent à cause d'un controleur mal foutu dans une voiture).

      La partie méthode formelle du labo Microsoft/INRIA va probablement être basé sur TLA, étant donné que son créateur Leslie Lamport est associé au Labo. http://en.wikipedia.org/wiki/Temporal_Logic_of_Actions (enfin j'en sais rien je fais de la rumeur c'est tout)
      • [^] # Re: Les mathématiques Formels

        Posté par  (site web personnel) . Évalué à 1.

        Euh, ce genre de programmation restera je pense, pour un bon moment, réservé à certains domaines bien spécifiques. C'est à dire des applications pas trop complexe, mais dont la fiabilité doit être de 100%(du genre le programme qui gère les méchanismes de la centrale nucléaire).
        • [^] # Re: Les mathématiques Formels

          Posté par  . Évalué à 1.

          Ce n'est pas spécialement utilisé dans les centrales nucléaires, ils ont plus des systèmes électronique que informatique.

          Quand au marché potentiel, cela dépend juste de prix potentiel d'une erreur dans le logiciel (en perte humaine ou juste financiere) par rapport au surcout de dévelloppement.

          Et si il sagit juste de faire un peu de model-checking ca coute pas non plus très cher.
          • [^] # Re: Les mathématiques Formels

            Posté par  . Évalué à 2.

            J'ai visité un réacteur de recherche du CEA (ISIS) la semaine dernière, et...

            Le logiciel de contrôle tourne sous Windows XP !

            Si, si, je vous assure, vous ne rêvez pas, ou plutôt vous ne cauchemardez pas. Bon je tiens à préciser que c'est un "petit" réacteur, pas plus de 700kW de puissance, mais son clône est juste à côté et développe tout de même 70MW. Par contre je ne peut rien dire pour l'autre, j'ai vu la salle de contrôle, mais je ne me suis pas approché assez près pour pouvoir vérifier si c'est le même logiciel qui tourne dessus.

            Bon, avant que vous ne fassiez une syncope, je précise (ce qui va dans le sens de outs) que le système informatique est juste un "bonus" ou un "front-end" des systèmes électroniques, qui sont bien entendu tous doublés, et absolument pas dépendants de Windows. Donc en cas de crash ou de comportement erratique de Windows, le contrôle est toujours assuré, et les sécurités toujours en place.

            Après pour le reste de leurs réacteurs je ne sais pas, mais ça m'a choqué de voir du Windows en salle de contrôle, même d'un petit réacteur de recherche fonctionnant par intermittence (pas le nuit, par exemple).
            • [^] # Re: Les mathématiques Formels

              Posté par  (site web personnel) . Évalué à 2.

              ok. Alors imagine que Windows avec les logiciels de contrôles plantent. Bon, l'électronique tourne encore, super. Maintenant, deux secondes après le plantage, un problème intervient sur le reacteur, il faut appuyer sur un bouton le plus vite possible. Sauf que voilà, Hommer cherche désespérément le bouton, et devra chercher à lire le manuel le Windows qui informe du problème est planté. Personne ne réagit. 20 morts, 200 années de radioactivité dans la région, et un nuage radioactif qui s'arrête à la frontière de nos maisons qui parcours l'europe.
              • [^] # Re: Les mathématiques Formels

                Posté par  . Évalué à 2.

                Pas exactement...
                Toutes les mesures d'urgences sont automatiques, dans le sens où en cas de mesure indiquant un problème aucun choix n'est laissé au technicien, il y a arrêt d'urgence *(chute des barres de contrôle). Et je n'ai pas demandé, mais il n'est pas exclu qu'un crash de Windows entre dans ce cas (mais dans ce cas leur réacteur doit souvent s'arrêter... ;-)

                De plus même en cas de défaillance totale, le réacteur s'arrête. En fait les barres de contrôle sont retenues par des éléctroaimants, donc si il n'y a plus de courant, elles tombent. Donc dans le pire du pire des cas, il faut juste couper l'alimentation électrique et la réaction s'arrête.

                Il y a des règles de sécurité très strictes pour ce genre d'installation, et une de ces règles stipule que l'exploitant doit démontrer que le réacteur doit se mettre dans une configuration sûre en cas de problème.

                Mais néanmoins, ça fait un choc...

                * Et ce genre de chose se produit environ 3-4 fois par an sur le réacteur OSIRIS, dixit un ingénieur travaillant dessus
                • [^] # Re: Les mathématiques Formels

                  Posté par  . Évalué à 2.

                  Oui, c’est le « contrôle de l’homme mort » (dead man trigger) : le principe n’est pas d’« arrêter en cas de problème » mais de « continuer en cas de non problème ». C’est-à-dire que lorsque le réacteur est dans les limites acceptables de fonctionnement, les interrupteurs d’urgences sont empêchés, et dès qu’il sort de ces limites, les blocages des interrupteurs sautent et donc les interrupteurs interrompent. (Exemple simple : les barres de contrôle sont maintenues par un éléctro-aimant, dès qu’il y a un pépin (le réacteur arrête de produire de l’éléctricité ou en produit trop et un plomb saute...), le jus est coupé et donc elles ne sont plus retenues et, merci la gravité, tombent et arrêtent le réacteur.)
                  • [^] # Re: Les mathématiques Formels

                    Posté par  . Évalué à 1.

                    ouais pareil pour les trains : tant que le circuit de freinage, qui est a air comprimé, est sous pression cela ne freine pas. Des que la pression chute ca freine (avec des ressort). C'est un peu comme s'il fallait appuyer pour ne pas freiner
          • [^] # Re: Les mathématiques Formels

            Posté par  (site web personnel) . Évalué à 3.

            Bin, je pense qu'il est possible de démontrer qu'un système électronique aussi, n'a pas d'autres sorties possibles que celles désirées. Je dirais même que si ce n'était pas le cas, il serait difficile de le faire pour un programme qui tourne au dessus d'électronique.
  • # Erlang ?

    Posté par  . Évalué à 5.

    Si le languages t'intéresse tant que ca je ne peux que t'inviter à jeter un oeil à
    Erlang.

    Ce langage dispose de certains avantages et des fonctionnalités que tu décris plus haut.

    Non seulement il est robuste, simple et ultra productif, mais en plus il vient avec un framework très très attractifs. (OTP)

    C'est un langage fonctionnel, et peut dérouter les débutants ou expérimentés aux cerveaux encore trop habitués aux autres langages.

    Erlang, dispose de 'green threads' c'est à dire de process ultra légers, ce ne sont pas le même threads que dans java ni celle de pthread ou de nptl, ce sont des processus erlang.

    Un processus erlang pèse 300 octets, et une machine virtuelle de base (sans paramètre de démarrage) est configurée pour faire tourner un peu plus de 32000 processus.

    Il est courant d'avoir un très grand nombre de processus tournant en même temps.

    Pour vous donner une idée, un crawler de page web peut tout à fait être développé de manière à avoir un processus erlang par url à récupérer. En d'autres termes chaque href contenu dans une page va déclencher un "spawn" (fonction de création de processus) d'un processus faisant une requète GET.
    Donc 5000 liens dans une page va déclencher 5000 processus...

    Erlang est distribué, pour communiquer la syntaxe est très simple, les processus sont identifiés par leur PID et pour leur parler on écrit ceci:

    Pid ! coucou.

    Cela veut dire qu'on envoit l'atome coucou au processus Pid.
    Pid peut être sur la machine locale comme sur une autre machine, c'est transparent...

    Erlang dispose des List Comprehension, du Pattern Matching, d'une base de donnée repliquée et distribuée (Mnesia).

    Erlang dispose également de modules indispensables, tableaux (ets, dets), arbres (gb_sets, gb_trees), gestion de queue (queue), de timers (timer) et bien d'autres.

    Erlang dispose de types de bases proches de ceux du javascript (pardonner cette phrase mais elle permettra à plus de monde de comprendre :p), liste et tuple.
    [1,3,4,5,2] est une liste
    {user, Login, Pass} est un tuple
    [{a, 1}, {b,2}, {c,3}] est une liste de tuple...

    Erlang c'est aussi un moyen de faire de la livraison de code à chaud, Erlang fait la différence entre les versions de codes, il est donc capable d'être mis à jour sans arrêt. No DownTime.

    Erlang vaut définitivement le coup d'oeil, il est facile de dire que ce language va faire énormément parler de lui dans les années avenir, ne serait-ce qu'avec l'arrivée de processeur multicore... (pour comprendre il faut regarder en détails et arriver à comprendre qu'une variable ne peut pas changer de valeur une fois assignée...)

    Une Vidéo sur le sujet, certainement le plus accessible:
    google video

    Certains projets commencent à être connu (ou le sont déjà):
    Ejabberd (process-one)
    Tsung
    Eddie

    Doc Erlang:
    Erlang.org
    Intro a Erlang (en anglais)

    Et pour approfondir, n'hésiter pas à chercher sur del.ico.us ou digg ou reddit, ou encore l'excellent Lambda the Ultimate
    • [^] # Re: Erlang ?

      Posté par  (site web personnel) . Évalué à 1.

      erlang ne pourra jamais percer à cause de ses performances déplorables multicore ou pas. Il ne sera utile que dans les marchés de niche pour lequel il a été conçu ou sa fiabilité et sa robustesse le rend le plus interrescant des langages.

      "La première sécurité est la liberté"

      • [^] # Re: Erlang ?

        Posté par  . Évalué à 3.

        Ah, bien comme commentaire, j'aurais aimer que tu argumentes un peu ...

        En revanche j'admets tout à fait que pour la gestion des caractères sous forme de liste peut sembler être lourd, c'est le cas, mais c'est également pour cette raison que le type binary est utilisé (notation en << >>).

        Maintenant il est toujours (et peut importe le language) de générer un automate pour parser un fichier XML que d'utiliser DOM, XPATH et tout ce que tu veux.

        Je défis quiconque de réaliser un parser avec libxml2 pour ne citer que le meilleur, qui irait plus vite qu'un code générer à partir de flex (même pas besoin de bison/yacc) pour parser exactement les même tags...

        Et oh grand bonheur, dans le code source de erlang tu peux trouver l'application megaco qui utilise justement un parseur générer à l'aide de flex, tout simplement pour des soucis de performances (et certainement de rapidité de développement pour le ou les auteurs).

        ejabberd utilise libexpat pour parser son XML.

        Dernier point, même si me prouve qu'à traitement équivalent erlang est plus lent, lorsque tu veux augmenter ta puissance de calcul en ajoutant des noeuds à ton réseau je peux te garantir qu'erlang au final l'emportera.

        Regarde du côté du MapReduce ( de google ) et essai peut être de comprendre que la vitesse n'ai absolument pas le but ultime, le but ultime c'est d'avoir une plateforme
        dans laquelle tu peux
        ajouter 1 noeud, retirer 1 noeud quand tu veux et sans perturber le service,
        une plateforme qui peut grossir horizontalement.

        Un noeud (une machine on va dire) utilisé à 100% de sa puissance à 100% du temps est une énorme erreur.
        Ce noeud ne pourra pas encaisser une charge soudaine, devient difficile à administrer (pense à toute les sondes de surveillance système et métiers) et est primordiale à la plateforme, c'est à dire que si elle tombe les autres machines de la plateforme ne pourront tenir la charge globale...

        Erlang c'est pour bâtir des architectures solides dans un monde où 100% du temps seul 90% (on va dire) du matériel fonctionne...


        Cadeau bonus:
        études de cas

        Ce lien ne parle pas d'erlang en particulier mais d'architecture, et la conclusion est que le brique qui ont été nécessaires existent ou sont triviales à implémenter en erlang...
        • [^] # Re: Erlang ?

          Posté par  . Évalué à 1.

          Vu que je suis une burne et n'arrive même pas à coller des liens je les remets ici...

          La video google:
          http://video.google.com/videoplay?docid=2953846492344274158&(...)

          http://www.erlang.org/


          Lien vers les presentations des archis (dans le vent) web 2.0:
          http://poorbuthappy.com/ease/archives/2007/04/29/3616/the-to(...)
          • [^] # Re: Erlang ?

            Posté par  (site web personnel) . Évalué à 4.

            Par pure curiosité, Erlang sait-il paralléliser tout seul (ou suggérer de le faire).
            On connais tous les limites des programmeurs quand il s'agit de concevoir un code qui s'exécute dans plusieurs flots. Et c'est peut-être là le problème majeur ?
        • [^] # Re: Erlang ?

          Posté par  (site web personnel) . Évalué à 2.

          Comme préciser plus bas, le code ne se parralèlise pas tout seul. C'est peut-être facile à faire en erlang mais si ton code ne le permet pas tu es eu définitivement.

          En plus, il me semble que Erlang tourne dans une VM pas encore jit et pas encore SMP aware. Bref, j'imagine que même Perl ou Java doit être plus rapide.

          En gros à part dans les applications serveur ou le parralèlisme est trivial, Erlang pourrait s'en sortir. Et encore, faire de la distribution de charge sur plusieurs apache n'est pas bien difficile et chaque noeud sera bien plus rapide.

          "La première sécurité est la liberté"

          • [^] # Re: Erlang ?

            Posté par  (site web personnel) . Évalué à 1.

            En plus, il me semble que Erlang tourne dans une VM pas encore jit et pas encore SMP aware.

            tout faux: il y a un compilateur natif et le runtime est SMP-aware (mais ça fait pas longtemps il est vrai)
            • [^] # Re: Erlang ?

              Posté par  (site web personnel) . Évalué à 2.

              Et cela donne quoi en perf ?

              Erlang était très bon pour le paralèlisme par la VM executait une instruction par thread après l'autre. Le compilo ne peut pas faire ça. Il utilise les threads de base de l'os?

              "La première sécurité est la liberté"

              • [^] # Re: Erlang ?

                Posté par  . Évalué à 2.

                La réponse est écrite dans mon premier message,
                un processus erlang prends 300 octets, et n'est pas un appel a fork() ni à pthread_create ou à clone().

                Erlang utilise les thread pour se répartir sur les différents core des processeurs, mais une thread OS peut contenir 30000 process erlang...

                Plus je lis vos commentaires et plus je vois qu'il circule un mythe sur erlang.

                Erlang dérive des telco, c'est à dire qu'il doit assurer 99,99999 % de disponibilité.
                Erlang n'est pas un language sorti d'une université, erlang est la réponse à un besoin,
                et c'est fondamentalement différent des autres langages.

                Ericsson avait besoin d'un langage robuste, sûre et permettant le développement rapide.

                Pour les perfs, il existe le très connu:

                http://www.sics.se/~joe/apachevsyaws.html

                Yaws étant un serveur web écrit en erlang.

                Encore pour les perfs, la meilleure implémentation de serveur Jabber n'est autre que ejabberd. Or un serveur Jabber regroupe exactement toute les problèmatiques liés au développement réseau (concurrence, asynchronisme, performance, stabilité)

                Sinon erlang au passage ca tourne sur énormément de pabx ericsson, ou switch/accelerateur SSL nortel ...
                Altéon également utilise erlang.

                Pour terminer, il n'existe pas d'avenir pour les langages qui continue à
                partager des variables, (Mutable State is Hell)
                ne font pas de la concurrence de base,
                ne peuvent pas être rechargé à chaud,
                et ne gèrent pas les grappes de machines de manière transparentes....
                • [^] # Re: Erlang ?

                  Posté par  (site web personnel) . Évalué à 2.


                  un processus erlang prends 300 octets, et n'est pas un appel a fork() ni à pthread_create ou à clone().

                  Erlang utilise les thread pour se répartir sur les différents cores des processeurs, mais une thread OS peut contenir 30000 process erlang...


                  En gros les 300 octets, c'est la taille prise même si le nouveau thread contient uniquement un "RET". La taille réservée pour la pile et le code sera bine plus grande.


                  Erlang dérive des telco, c'est à dire qu'il doit assurer 99,99999 % de disponibilité.


                  Je le sais bien. On peut même rajouter que les performances n'étaient qu'un problème secondaire, c'est pour ça que je considère que cela n'est qu'un langage de niche.

                  Et cela n'est pas ce que l'on demande principalement à un langage actuellement (c'est plutôt de la productivité, et un moindre cout de formation).

                  Le bench montré n'a que peut d'interret. Pour ce genre de serveur, c'est le nombre de requètes par seconde en fonction du nombre de session en parralèle qui est la métrique utilisée.

                  Je parie que Erlang doit très bien scaler jusqu'à plus de 30000 sessions parrallèle avec une courbe bien plate. Mais que pour les cas d'utilisation moyen avec ~100 à 1000 sessions, je parie que apache gère bien plus de transactions.

                  "La première sécurité est la liberté"

                • [^] # Re: Erlang ?

                  Posté par  . Évalué à 2.

                  Erlang utilise les thread pour se répartir sur les différents core des processeurs, mais une thread OS peut contenir 30000 process erlang...
                  Erlang a appris l'existence de librairies de threads MxN.
                  C'est normal pour un langage orienté concurrence aussi :D
                  Et voui ce genre de librairie existe aussi en C par exemple.

                  (je ne dis pas que erlang ca pux car il a des avantages indéniables, je dis juste que les threads MxN erlang est pas le seul a pouvoir les utiliser).

                  Question sur erlang : la migration de processus se fait comment :
                  - a travers la meme machine (smp)
                  - a travers un cluster (machine numa) voir un bewolf (grille de calcul, ...) ?
                  Comment est gérer la mémoire ?
                  Evite -on les faux partages ?
  • # L'algorithme.

    Posté par  . Évalué à 2.

    Je suis vraiment pas du tout expert en langages, mais le vrai
    problème, ça ne reste pas l'algorithme ?

    Bien sur, un bon langage va permettre de modéliser les choses
    de belle façon, mais à un moment, il faut tout de même
    penser à l'algorithme, à l'empreinte mémoire etc...
    • [^] # Re: L'algorithme.

      Posté par  (site web personnel) . Évalué à 4.

      Oui enfin entre l'algorithme de base, l'implémentation et le code exécuté, il se passe pas mal de chose.

      Typiquement tu as trois étapes.

      _ Tu écrit un algorithme dans un langage

      _ Celui-ci est transformé en un objet mathématique (un graphe)

      _ le graphe devient un flot d'instructions machine

      La question est plus de savoir comment est-ce qu'on peut envisager les choses différemment.

      Certains langages le permettent. Par exemple en prolog tu définis une série de contraintes.

      Tout fils a un père et une mère.

      > a est le fils de b
      > c est le père de a
      >>>>>>>> b est la mère de a

      Un bon exemple est la différence de raisonnement entre : remplir une grille de sudoku et résoudre une equation

      Un autre exemple une base de données.
      Tu crée un univers : la base avec ses contraintes, sa façon de fonctionner, ses droits ...

      Ensuite tu agis sur cet univers avec un langage prévu exprès pour ça : le SQL.

      C'est aussi une façon de programmer.

      Là, il n'est nullement question d'algorithme mais bien d'une façon d'envisager les choses.
      • [^] # Re: L'algorithme.

        Posté par  (site web personnel) . Évalué à 2.

        Ouais hein, la prog par contrainte c'est joli, mais ca cache tout au programmeur s'il connait pas les algos qu'il y a derriere.
        Ca fait le backtracking tout seul, certes, mais si t'es pas foutu de bien de bien definir tes contraintes (ou si elles sont pas triviales), t'as vite fait d'ecrire du code facile et rapidement, mais ultra pas efficace, voire pire !


        Pour les langages proches de l'humain mais pour l'ordi, j'ai lu un article dessus recemment, le (peut etre) bien nomme EasyLanguage : http://lambda-the-ultimate.org/node/2201

        Mais bon, perso, après de l'ASM, du C++, du Caml et du Haskell (et tout plein d'autre sur mon CV), c'est avec Scheme que je redécouvre le langage idéal.
  • # Inform?

    Posté par  . Évalué à 2.

    J'ai malheureusement survolé, étant pressé, mais pour la fin, ou tu ouvres sur les langages naturels: que penses tu d'Inform 7 ? Il s'agit d'un langage de création de jeu d'aventure interactif. Le langage de "programmation" est un sous-ensemble de l'anglais, qui permet de décrire le monde de l'aventure et de poser relations et activités sur les objets du monde, pour construire le fil de l'aventure.

    Bien sur, ce n'est pas tout à fait de l'anglais, des fois les constructions sont un peu lourdingues, mais c'est vraiment un plaisir de décrire une aventure en utilisant ce langage, plutot qu'en composant des objets avec attributs et méthodes, comme il fallait le faire avec Inform 6.

    Voila :)
  • # j'pige pas tout mais j'me soigne

    Posté par  . Évalué à 0.

    Pourquoi ne pas plutôt travailler à harmoniser et étendre la STL ?

    http://www.sgi.com/tech/stl/stl_introduction.html
  • # Le plus gros défi...

    Posté par  . Évalué à 2.

    ...est à mon sens la programmation concurrente, ou multithreading en anglais.
    Un bon langage adapté au futur sera un langage qui permette d'écrire "naturellement" des applications multithread, mais je n'en connais pas à l'heure actuelle... (cependant il est vrai que mes connaissances en terme de langages sont limitées)


    Je suis vraiment convaincu par les mérites des langages fonctionnels, mais par exemple OCaml ne permet pas grand-chose dans le domaine du multithreading, hélas. Je ne sais plus très bien où (sur la ML de OCaml il me semble) j'avais vu que les concepteurs du langage sont opposés à ça, tant qu'il n'y a pas de paradigme efficace de programmation concurrente.

    Qu'en est-il ?

    N'y-a-t-il pas au contraire un espoir suscité par les langages fonctionnels ?
    Il me semble en effet qu'un programme écrit d'une certaine façon en fonctionnel peut être parallélisé très facilement, par exemple un truc du genre :

    let rec f l =
    match l with
    |[] -> []
    |x::r -> (quelque_chose x)::(map f r) ;;

    En gros faire du MapReduce...
    • [^] # Re: Le plus gros défi...

      Posté par  . Évalué à 3.

      ...est à mon sens la programmation concurrente, ou multithreading en anglais.

      Je ne suis pas d'accord avec cette vision des choses. La prog concurrente existe indépendemment des threads. De plus, on peut très bien avoir des threads de niveau utilisateur qui se coordonnent très bien, voire n'ont absolument pas connaissance de l'existence des voisins, car l'ordonnancement a été fait pour.
    • [^] # Re: Le plus gros défi...

      Posté par  (site web personnel) . Évalué à 1.

      J'en connais deux
      Erlang et Gambit-C/Termite (Scheme)

      Ton truc s'appelle pmap

      parmap(F, L) ->
      Parent = self(),
      [receive {Pid, Result} ->
      Result end ||
      Pid <- [spawn(fun() -> Parent ! {self(), F(X)} end) ||
      X <- L]].

      (define (pmap f lst)
      (let ((parent (self)))
      (map (lambda (pid)
      (recv ((,pid reply) reply)))
      (map (lambda (x)
      (spawn (lambda () (! parent (list (self) (f x))))))
      lst))))


      Pour caml, c'est pas l'objectif du langage. Mais tu peux regarder du coté du "join calculus" qui a été implanté en OCaml...
  • # Smalltalk

    Posté par  . Évalué à 2.

    Tu as déjà essayé smalltalk?

    C'est un langage à la syntaxe super simple, super orienté objet, et avec un minimum de rigueur super lisible. On peut aussi passer des blocs de code en argument, faire de la réflexivité et ce genre de truc (méta-programmation, ...).

    En plus, grâce à l'ultra-simplicité de la syntaxe, il est super facile de faire des outils de refactoring puissants, ce qui rend la programmation beaucoup plus agréable et ce qui permet de se concentrer vraiment sur les choses importantes comme le design de l'application. Après, c'est d'autant plus facile de rajouter des fonctionnalités et de faire évoluer le code. (Si on couple ça avec une batterie de tests unitaires, on est partis pour conquérir le monde!)

    Depuis que j'ai découvert ce langage, j'ai l'impression que tout ce que j'ai fait avant (C, C++, java, etc) c'est de la merde.

    Python ça va encore ;-)

    Faut encore que j'essaye Ruby, aussi.
    • [^] # Re: Smalltalk

      Posté par  (site web personnel) . Évalué à 2.

      Personnellement je travaille sur Lisaac, qui se veut un sur-ensemble de Smalltalk à prototype.
      Lisaac s'inspire de Smalltalk, Self, Eiffel. Il est lui aussi un langage minimaliste (moins de 10 primitives de base) et propose une syntaxe à mot clé.

      La réflexivité devrait être proposé dans moins d'un an, ce qui fera de lui un total sur-ensemble de SmallTalk.

      Lisaac est compilé et permet d'atteindre des performances proche du C.

      Il devrait normalement être libéré un jour.

      http://isaacproject.u-strasbg.fr/li.html

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: Smalltalk

        Posté par  (site web personnel) . Évalué à 2.

        Il devrait normalement être libéré un jour.

        Le un jour a l'air d'être dans vraiment pas longtemps.

        En gros c'est déjà libre mais ce n'est pas encore publié ... Il faut attendre la version 0.2 qui devrait logiquement bientôt sortir.
  • # Perso

    Posté par  . Évalué à 1.

    Personnellement voir les langages de prog se rapprocher du langage naturel serait un vrai cauchemard.

    Devoir tout taper dans des vielles syntaxes genre SQL ou windev, mon dieu quel horreur :)

    En plus, comme dit plus haut, l'informatique est une science dure et en temps quel tel le seul langage qui pourrait rassembler tout le monde, ben c'est le langage des math (formelle). la logique quoi. (mais pas forcement un langage genre prolog : qui est quand même très special dans l'idée).

    Enfin c'est juste mon point du vue.
    • [^] # Re: Perso

      Posté par  (site web personnel) . Évalué à 2.

      Avec toute ma sympathie, j'ai l'impression que tas réaction s'apparente à une volonté inconsciente de garder pour soi un mandarinat technique, en maîtrisant une syntaxe ésotérique et d'en ressentir du plaisir.

      Mon propos est d'essayer d"imaginer de nouveaux paradigme afin de diviser par n les coûts de développement.
      Ca peut chagriner des informaticiens qui voient le fondement de leur présence, potentiellement se dérober sous eux à la vue d'une telle perspective.

      Juste entre parenthèse sur Windev, j'en ai fait pas mal, je connais, et windev, c'est une sorte de langage pascal interprété, mais c'est très classique comme langage, la grammaire est just un peu neuneuifié.

      SQL est par contre assez génial, parce que ma chef, qui était contrôleur de gestion, et donc pas informaticienne, a assez facilement appris à faire diverses requêtes : SQL est logique, simple d'accès et ne te demande pas d'expliquer à la machine ce qu"il faut faire.

      En plus, comme dit plus haut, l'informatique est une science dure et en temps quel tel le seul langage qui pourrait rassembler tout le monde, ben c'est le langage des math (formelle). la logique quoi. (mais pas forcement un langage genre prolog : qui est quand même très special dans l'idée).

      Moi je fais de l'informatique de "gestion" tout les jours et je peux te dire que c'est partiellement vrai, les concepts qu'on exprime sont certes mathématiques au fin du fin, mais il existe certainement des manières moins mathématique et aussi rigoureuse - faisant appelle à l'intuition - de l'exprimer.

      « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

      • [^] # Re: Perso

        Posté par  . Évalué à 2.

        Avec toute ma sympathie, j'ai l'impression ... en maîtrisant une syntaxe ésotérique et d'en ressentir du plaisir.

        Haha Ontologia t'es trop fort:) Et toi avoue que tu aime les grandes phrases pleines de mots pompeux :)

        Mais je pense réellement que le langage naturel n'est pas le meilleur candidat pour démocratiser les choses.

        Le langage mathématique parrait abscon pour pas mal de monde je sais. Mais en fait il est définit avec une dizaine d'opérateurs de base que l'on combine en utilisant, la plupart du temps, son intuition pour exprimer ce qu'on veut.

        Si on utilise un langage naturel pour le remplacer, cela va sembler plus simple mais en fait la difficulté sous jacente sera la même. Et il vaut mieux avoir un langage non-ambigu pour s'en sortir avec ces difficultés. C'est un petit investissement a faire pour se simplifier la vie apres.

        SQL est logique, simple d'accès et ne te demande pas d'expliquer à la machine ce qu"il faut faire.


        Uniquement parcqu'il est basé sur l'algèbre relationnelle. La couche de bla-bla pardessus ne fait que rendre les choses plus confuses. Enfin en tout cas c'est la premiere chose que j'ai ressentit apres avoir apris a rédiger les requetes en algebres relationnelle directement et en SQL. Je me souviens plus mais y'a une demi-douzaine d'opérateur a apprendre en algebre et c'est tout. Alors qu'un manuel SQL c'est plein de cas particulier et de bordel.

        Apres plein de gens sont rebuté par les notation mathématique, je pense que c'est un problème pédagogique plus qu'autre chose.

        enfin au final, si on considère que tout le monde n'a pas la même représentation mentale cela serait normal que des gens préférent un style et d'autre un autre. Et le mieux serait que chacun puisse utiliser son langage adapté a se représentation et que l'on ai une interopérabilité voir pourquoi pas un moyen de traduire automatiquement d'un langage vers un autre.
  • # Autres grammaires

    Posté par  (site web personnel) . Évalué à 2.

    Mais cela nécessite peut être de dépasser les grammaires LL, LR, etc...


    A ce propos, j'avais en ce moment une idée de créer un langage sans syntaxe définie, mais où la syntaxe serait définie lors de l'exécution. Bien sûr, au début du fichier, une dyntaxe par défaut serait chargée mais il serait possible d'en changer après.

    Je pensait à un truc du style LaTeX avec des caractères reconnus qui permettent de structurer le texte, mais où il serait possible de changer ces caractères en cours de route tout simplement.

    Après, c'est juste une idée que je n'aurais sans doute jamais le temps d'implémenter.
    • [^] # Re: Autres grammaires

      Posté par  . Évalué à 2.

      Très honnêtement, si tu te contentes de balancer un ou deux exemples avec quelques explications sur internet, ça me semble suffisament intéressant pour que quelqu'un s'y penche de plus près...
      • [^] # Re: Autres grammaires

        Posté par  (site web personnel) . Évalué à 2.

        Comme je l'ai dit, il n'y a rien de défini. Mais j'imagine par exemple quelque chose du style :
        \define{my_function}{\function{
        \print\getparam{1}{\true}
        }}
        \setspecialchar{startkeyword}@
        @my_function{Hello World}


        On appelle la fonction \define qui va définir un symbole my_function contenant une fonction qui affichera son premier paramètre. Ensuite, on définit que le caractère @ servira a introduire un mot-clef comme le fait actuellement \. On peut donc appeler notre fonction définie avec @my_function.

        Pour déterminer les paramètres d'une fonction cela se fait à la volée. Lorsque une fonction appelle getparam, le moteur du langage va découper le texte qui suit le texte en cours (@my_function), c'est à dire {Hello World}. Il détecte les caractères spéciaux { et } qui permettent de grouper le texte et prend uniquement son contenu. Le contenu trouvé est ensuite évalué récursivement.

        Il serait bien sûr possible d'accéder au prochain caractère de manière brute ou sans évaluer le texte trouvé. Sinon, si dans mon appel à \getparam j'ai mis {\true} c'est pour dire que le paramètre doit être 'mangé' et que le procian texte a évaluer est encore après.

        Voila, j'espère que ce n'est pas trop difficile a suivre
        • [^] # Re: Autres grammaires

          Posté par  (site web personnel) . Évalué à 2.

          A mon avis, aussi, il faudrait y réfléchir davantage pour voir ce qu'on peut faire ... Mais l'idée c'était surtout de pouvoir à partir d'un tel langage pouvoir construire ce qu'on veut, aussi bien du XML que du C ou un autre langage ...
          Je pensait écrire ça en Lisaac.

          Le problème c'est que j'ai aussi d'autres projets tout aussi intéressants en tête et que je n'ai finalement que très peu de temps.
          • [^] # Re: Autres grammaires

            Posté par  . Évalué à 2.

            Ça existe déja, et ça s’appelle le Lisp.

            Par exemple, en Common Lisp, on associe le caractère tilde ~ avec la fonction ‹tilde-reader› avec cette petite ligne :

            (set-macro-character #\~ #'tilde-reader)

            La fonction ‹tilde-reader› lit le flot correspondant à la suite du code en cours de lecture (on utilise la fonction ‹read› et on récupère le texte, non-évalué, et on construit une s-expression (du code) qui sera évaluée).

            Tu peux aussi faire d’autres modifs, pour remplacer la signification des parenthèses, en donner aux chevrons (pour le XML…), etc.
            Tout est possible en Lisp parce que Lisp n’est qu’une boucle read-eval-print (ou (print (eval (read))) :o) et que l’on peut modifier toutes les fonctions, y compris ‹read›, ‹eval› et ‹print›.

            On le fait pour utiliser Lisp comme machine virtuelle d’un langage ad hoc.
            On ne le fait pas vraiment pour des données (comme du XML) parce que ça ne simplifie pas vraiment le code. Tout ce que ça apporte, c’est le « wahou ! les données _sont_ le code », qui, une fois passé l’auto-satisfaction, entraîne un « et alors ? »…
            Finalement, ça n’est pas très différent et ça n’apporte pas grand-chose à l’utilisation de compilateurs ou d’interprètes ad hoc.
            • [^] # Re: Autres grammaires

              Posté par  (site web personnel) . Évalué à 2.

              L'avantage c'est qu'une syntaxe LaTeX est beaucoup plus pratique dans un éditeur de texte classique qu'une syntaxe XML ... Et si cela peut se transformer en XML, on peut alors utiliser XSLT et XSL-FO pour créer un document PDF.

              J'ai déjà pensé à utiliser un langage lisp. Mais je pense préférer le scheme (plus petit et je trouve mieux sur certains aspects) mais ce langage me rebute par le fait que l'environnement global contienne *beaucoup* de variables (guile en contient plus de 1000 par défaut).

              Je préfère quand même partir sur quelque chose de déconnecté de Lisp qui a plein d'avantages mais aussi je trouve quelques inconvénients. Mais pour le moment je travaille sur autre chose alors on verra plus tard.
              • [^] # Re: Autres grammaires

                Posté par  . Évalué à 2.

                Tu sais, quand je dis Lisp, j’englobe tous les Lisp, du bon vieux Le Lisp à Common Lisp et Scheme, il n’y a pas tant de différences (si ce n’est que Scheme est un peu plus impératif (variables globales, tout ça) que le bon vieux Le Lisp).

                Il fut un temps où j’ai aussi pensé à faire un langage de documents à la TeX mais en évitant ses problèmes. Par exemple :
                — le fait que TeX est un langage de macros, ce qui est déjà difficile à suivre avec l’utilisation répétée de \expandafter (‹quote› en Lisp, mais qui n’opère que sur le caractère ou la commande qui suit) ;
                — avec de vraies macros, celles qui sont évaluées dans le « ventre » de TeX, pour reprendre les termes de Knuth, et des macros spéciales, qui sont évalués dans sa « bouche » ;
                — le manque de primitives pour manipuler les chaînes (bonjour la chienlit pour découper une chaîne).
                Bien sûr, on arrive à faire plein de choses, surtout quand on s’appele Knuth, mais ce n’est vraiment pas par le chemin le plus accessible.

                La syntaxe (La)TeX n’est pas si sale (même si elle est perfectible, mieux structurable) et XML est effectivement trop lourd si c’est un humain qui doit le taper.

                Par contre, dès qu’on y réfléchit un peu, on voit que c’est une tâche colossale : il y a énormément de bibliothèques à faire pour arriver à la cheville de LaTex et il est plus simple de s’accommoder de ses défauts.
                • [^] # Re: Autres grammaires

                  Posté par  (site web personnel) . Évalué à 2.

                  Et tu peux pas faire un convertisseur LaTex -> ton langage ?

                  « Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker

                  • [^] # Re: Autres grammaires

                    Posté par  . Évalué à 2.

                    C’est une idée mais ça ne simplifie pas vraiment. Pour caricaturer, ce serait comme désassembler vers du Lisp du code compilé depuis du Fortran.
              • [^] # Re: Autres grammaires

                Posté par  (site web personnel) . Évalué à 2.

                > Mais je pense préférer le scheme (plus petit et je trouve mieux sur certains aspects) mais ce langage me rebute par le fait que l'environnement global contienne *beaucoup* de variables (guile en contient plus de 1000 par défaut).

                euh... mais si tu prends guile, t'étonne pas d'avoir un truc si gros...
                (en plus, guile est pourri, mais c'est une question de gout)
                Regarde plutot du coté de Scheme48 pour un Scheme plus petit.

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.