Journal [annonce]Formalisation grammaticale d'un pidgin

Posté par  (site Web personnel) .
Étiquettes : aucune
0
17
oct.
2006
Bonjour, dans le cadre de mes réflexions faisant suite à https://linuxfr.org/~Montaigne/20582.html et https://linuxfr.org/~Montaigne/19629.html je cherche une formalisation grammaticale d'un pidgin, si possible issu d'au moins une langue indo européenne.

S'il y a des linguistes dans la salle, ayant des éventuels pointeurs, je suis intéressé, google ne m'ayant rien donné de très exploitable.

Merci
  • # Pour info

    Posté par  . Évalué à 6.

    En direct de wikipedia:
    Le terme de pidgin (nom masculin) désigne différentes langues véhiculaires simplifiées créées sur le vocabulaire et certaines structures d'une langue de base, en général européenne (anglais, français, espagnol...).

    Les linguistes distinguent le pidgin du créole en fonction du niveau de structuration de la langue. Toutefois, il est courant de réserver le terme pidgin aux langues issues de l'anglais et le terme créole aux langues issues du français. C'est cependant un emploi abusif.

    Exemple de pidgin de Papouasie-Nouvelle-Guinée : yumi signifiant « nous » (issu de l'anglais you + me).

    Ce commentaire passe-t-il les trois tamis de Socrate ? -- https://linuxfr.org/suivi/autoriser-la-correction-limitee-de-commentaires-apres-les-5min

  • # Formalisation grammaticale

    Posté par  . Évalué à 3.

    Qu'entends-tu par "formalisation grammaticale" ?

    Je ne suis pas linguiste mais j'y suis un peu sensibilisé, et à ma connaissance, de ce que je comprends de "formalisation grammaticale" et de "pidgin", ta question n'a pas de réponse.

    Quel est le rapport avec les journaux précédents ?
    • [^] # Re: Formalisation grammaticale

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

      Je cherche à étudier des descriptions grammaticales de pidgin, tout comme on peut proposer une étude de la grammaire du français (dans un besherelle de grammaire française par exemple).
      Le but étant de pouvoir interpréter des phrases dans un espèce de langage naturel primitif et d'en extraire le sens.

      Le rapport avec mes journaux précédent est que je cherche (c'est une simple piste) des moyens de programmer autrement, et donc d'être un peu moins coincé par les grammaires formelles trop strictes dont on à l'habitude(entre autre, car il y a beaucoup d'autres concepts). J'en parle un peu dans l'intro du premier journal cité.
      Mais j'en reparlerai dans quelques mois quand j'aurai fini.

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

      • [^] # Du côté de la syntaxe

        Posté par  (site Web personnel) . Évalué à 5.

        Si je comprend bien, tu cherches à faire de la grammaire générative ?[1]

        Il faut savoir qu'en linguistique, la notion de grammaire n'a pas beaucoup de sens, puisque la linguistique n'a pas pour vocation d'être normative mais descriptive.. Je pense que tu trouveras davantage de résultats avec le mot "syntaxe"[2] ( même si, pour avoir fait une présentation de la syntaxe du thaï, je sais que le net n'est pas très riche en informations la dessus. )
        Par contre, il n'est pas possible de te donner d'informations concernant les pidgin, puisque comme cela a été dit, un pidgin dépend des langues qui ont permit sa construction ( en gros il y a une langue/culture dominante, et une langue dominée, la langue dominante imposant sa syntaxe, la langue dominée gardant son vocabulaire ; je dis bien, en gros... )

        Je pense que tu aurais plus d'informations si tu t'intéressais à la syntaxe d'une manière générale... Sans vouloir faire un cours la dessus, la syntaxe est le procédé par lequel les "mots" s'agencent par des relations de détermination pour donner du sens. Ce procédé résulte d'un découpage de la réalité ( quand on dit "le chat dort", on sépare l'objet ( le chat ) de son action ( dormir ), ce qui est un découpage totalement artificiel.. ), et aussi d'une re-construction, dans le but d'économiser le nombre de mot dans une langue, évidement.
        Ensuite, il est possible d'étudier les caractéristiques des différentes unités ( à l'aide d'opération de commutation ), en partant du principe que deux unités de même catégorie :
        1) ont les mêmes relations avec les autres catégories ( ex : un nom peut être déterminé par un déterminant, par le pluriel, et peut déterminer un verbe .. ( bien sur j'en oublie ) )
        2) s'excluent l'une l'autre ( on peut dire chat ou chien, mais le fait de dire l'un empêche de dire l'autre )

        Bon, j'ai développé plus que je ne voulais, mais je pense effectivement que les langages informatiques et les langues ne sont pas si éloignés que cela... :)

        Bonne recherche !


        [1] http://fr.wikipedia.org/wiki/Grammaire_g%C3%A9n%C3%A9rative
        [2] http://fr.wikipedia.org/wiki/Syntaxe
        • [^] # Re: Du côté de la syntaxe

          Posté par  . Évalué à 4.

          Je pense avoir une vague idée de ce qu'Ontologia cherche (parce que je me suis déjà posé la question).
          Un angle d'approche pourrait être celui de l'AppleScript, qui tente d'être entre la langue et le programme. L'idée est plus un intermédiaire entre une vraie langue de programmation et la langue je pense (il faudrait voir les arcanes de la chose pour en etre sur).

          Ca permet d'avoir des lignes du genre (j'ai plus la ligne en tete, mais ca y ressemble) :
          "tell iTunes to set Volume to 20"
          qui sera parfaitement la meme chose que de cliquer sur le bouton de volume et de le mettre a (pile poil, on a de la chance) 20% du volume max.

          En gros, ils ont identifié des phrases en anglais qui avaient une structure plutot figée :
          TELL sthg TO do_sthg
          SET sthg TO sthg
          Apres, ils ont ajouté le "OF" qui permet de specifier un peu plus les choses :
          tell iCal to set value of day Tuesday November, 20th to empty
          (bon l'exemple est completement bidon mais l'idee est la).

          Petit a petit on arriverait a construire un lexique, une syntaxe... un coup de yacc/flex et c'est alors gagné.

          Un des gros inconvenients, c'est que la programmation en applescript est tres deroutante au debut : on a 2/3 mots cles, et apres on doit essayer de deviner un peu comment acceder a une valeur (y'a de la doc, mais il faut toujours faire des allers-retour). Ca fait moins formel. Et je ne suis pas sur qu'on gagne en maintenabilité, lisibilite...


          Mais je pense que ce que tu cherches, Ontologia, c'est aller plus loin que ca. Est-ce que je me trompe ?
          • [^] # Re: Du côté de la syntaxe

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

            >Un angle d'approche pourrait être celui de l'AppleScript, qui tente d'être entre la langue et le programme.

            Ce n'était pas également l'idée de départ du SQL ?
          • [^] # Re: Du côté de la syntaxe

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

            J'étais tombé sur hyperCard, avait entendu parlé d'AppleScript, mais même pas encore essayé sur mon nouveau Mac ! Génial, je vais pouvoir scripter mon système avec ça !

            En fait, une des pistes que j'explore, est de pouvoir écrire des phrases à la syntaxe simplifiée, contextuel au vocabulaire afin d'écrire du code.
            Plus clairement, au lieu de partir de la logique habituelle qui consiste à dire qu'une grammaire précise s'applique à l'appel d'une fonction, j'aimerai que ce soit le nom de la fonction qui impose contextuellement sa grammaire.
            Par exemple :
            (je fais du franglais, car l'anglais possède moins de déterminant que le français)

            CréerUnRépertoire <où> NamedBy

            En gros la structure grammaticale de la fonction va donner des renseignement sur le type des données, et permettre d'utiliser des mots de liaisons.
            Exemple

            if exist file (repSrc+"\"+uneVariable) then
            fileCopy itself to repDest


            Le mot if attend une condition, classique, or le syntagme exist file <Nom Fichier> renvoi un booléen.
            Exist File est la combinaison de deux mots où exist attend un ensemble et un élement.
            Ici l'analyseur de contexte va comprendre que dans exist file <Nom fichier> file désigne intrinsèquement un emsemble (bien qu'il soit lui même un mot fonction) et que le paramètre de file est l'élément recherché.
            Il va aussi déduire que itself revient à (repSrc+"\"+uneVariable)

            fileCopy itself to repDest a pour syntaxe fileCopy to <localité>

            Bref, (je réfléchis en écrivant hein...), ya pas mal de problèmes.
            En fait il faut créer un graphe de concept qui permette de décrire des notions, comme la localité, le nom, "quoi", "qui", "vers", etc... De manière à pouvoir les contextualiser pour chaque contexte ensembliste.
            Par exemple dans l'ensemble "Arborescence de fichier", une localité est un chemin répertoire ou fichier précis.
            Dans une structure de donnée représentant un réseau, ce sera une ip donné. Dans un xml, ce sera un chemin, etc...

            C'est un peu logique flou en fait. C'est pour cela que j'essaye de formaliser une grammaire assez lâche, mais qui permette à une phrase, comme présenté en exemple ci dessu, soit compréhensible par l'interpréteur.

            Alors quel est mon but ? Je déflore un peu, car je vous ferais la surprise avec un gros journal quand j'aurai (et si je) finis, où tout au moins que j'aurai produit une conceptualisation qui tienne debout et me semble exploitable (l'oeil inquisiteur de mon ami Benoit Sonntag qui est un des meilleurs spécialiste en compilation objet et ne ratera aucun trou logique, m'obligera à présenter quelques chose de solide).
            C'est en lisant le texte de Victoria Livschitz, dont j'ai traduit l'interview dans un des deux journaux cités que j'ai compris ce qu'était le KeyWord central était "intuitivité", il faut que les langage de programmation s'adapte à la façon de penser, de parler de l'Homme.
            L'autre apport d'importance - outre que d'être développeur de métier adorant les langages type SQL, regexp, xpath et détestant l'impératif - fut une discussion avec Nat Makarevitch (entre autre créateur d'IdealX). J'étais déjà en train d'essayer de penser à un langage où, comme en SQL, regexp, Xpath, je demande à l'ordinateur de m'envoyer un résultat en décrivant ce que je veux et non en décrivant ce que l'ordinateur doit faire pour l'obtenir.
            Plus trivialement, écrire des boucles à longueur de journée, ça m'emmerde.
            Un bon select from where dans un objet ça me va parfaitement, j'ai autre chose à faire que de concevoir l'algo qui ma me donner le résultat et j'ai absolument horreur de se sentiment de perdre mon temps à écrire des conneries.
            (Je sais il existe ça et là des lib permettant de le faire en .Net/Java/... mais c'est hyper lourd à mettre en oeuvre)

            Nat m'a parlé du projet http://Tunes.org et de l'objectif de créer en définitive une sorte de méta langage. Bref un langage où on décrit à la machine ce qu'on veut qu'elle fasse, et non que l'on décrive un automate, un graphe de code, bref une sémantique opérationelle http://fr.wikipedia.org/wiki/S%C3%A9mantique_op%C3%A9rationn(...) , où l'on décrit une métaphore d'exécution sur une machine virtuelle (qui exécute ton code).
            Le but est de travailler avec une sémantique plus axiomatique avec des fortes notions de reconnaissance de formes, de structures.

            J'ai vite compris que le background et les partis pris de l'abruti (pourtant normalien, mais qui a écrit cette horreur là : http://www.quebecoislibre.org/030927-11.htm qui me donne envie de vomir en tant que démocrate) qui mène ce projet va le diriger droit vers l'échec (qui a d'ailleurs l'air dors et déjà mort).

            AMHA, je pense qu'un type qui prone un extrémisme scientifique, qui est l'individualisme méthodologique, base théorique des néolibéraux (dont il est un des pires représentant) ne permet pas de comprendre les concepts fondamentaux qui mèneront à la conception d'un métalangage.
            En ce qui me concerne, je suis au miyeux, entre déterminisme et individualisme méthodologique, avec des phénomènes d'attractions, et de probabilité de tomber dans le déterminisme, stop, je me lance pas dans l'explication.

            Bref tout ça pour dire que je n'ai pas envisagé de collaboration avec lui et ait commencé à réfléchir à la question dans mon coin, en travaillant sur différentes thématiques : syntaxe/linguistique, Métadynamique des Système Multi Agent, psychologie cognitive (eh oui on s'adapte à un humain, faut comprendre comment il fonctionne), axiomatique mathématique, etc...
            Je fais une formalisation, je demande l'avis à plein de monde et surtout à Benoit qui me dira si c'est compilable, interprétable ou pas...

            Voilà pour répondre à ta question, mais pour le moment, j'ai plus d'idée en vrac qu'autre chose et n'ait pas encore effectué de synthèse.

            A dans quelques mois...

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

            • [^] # Re: Du côté de la syntaxe

              Posté par  . Évalué à 2.

              je demande à l'ordinateur de m'envoyer un résultat en décrivant ce que je veux

              When someone says, ‟I want a programming language in which I need only say what I wish done,” give him a lollipop.
              — Alan Perlis

              (Quand quelqu'un dit « Je veux un langage de programmation dans lequel j'aurai seulement besoin de dire ce que je souhaite qu'il soit fait », donnez-lui une sucette.)

              ;oP

              (Remarquons que décrire le résultat attendu est ce que l'on fait avec certains langages, comme Prolog p.ex.)

              En ce qui concerne la syntaxe plus « humaine », même si j'ai bien compris que tu veux aller beaucoup plus loin, les systèmes de mots-clefs de Smalltalk ou de Common Lisp permettent déjà pas mal de choses :
              créer :quoi 'répertoire :où ... :nommé ...
              (ordre indéfini).
              • [^] # Re: Du côté de la syntaxe

                Posté par  (site Web personnel) . Évalué à 0.

                (Quand quelqu'un dit « Je veux un langage de programmation dans lequel j'aurai seulement besoin de dire ce que je souhaite qu'il soit fait », donnez-lui une sucette.)

                C'est pas parce que des grands pontes totalement coincé dans leur monde et peu intéressés d'avoir une approche transdisciplinaire, disent que c'est impossible qu'il ne faut pas essayer.
                Avec une mentalité pareil, la Science risque de ne guère avancer.

                Mais ça m'étonne pas. C'est dur à admettre pour un type ayant une culture mathématique, informatique théorique seule, de penser que ce genre de chose est possible. Mais c'est uniquement par manque de culture et d'intérêt (que je ne critique pas : les goûts et les couleurs....).
                J'ai des exemples personnels à l'appui.

                Faut pas se leurer, dans 30 on programmera plus les machines. Et ça commence : dans des grandes boites comme Cap Gemini, 97% du code est généré suite à des schémas, spécifications, design d'interface...

                En ce qui concerne la syntaxe plus « humaine », même si j'ai bien compris que tu veux aller beaucoup plus loin, les systèmes de mots-clefs de Smalltalk ou de Common Lisp permettent déjà pas mal de choses :
                créer :quoi 'répertoire :où ... :nommé ...
                (ordre indéfini).

                SI je présente ça comme la solution, on me répondra à raison
                "tu es gentil, mais c'est du sucre syntaxique"
                Et en ce qui me concerne, je trouve ça totalement insuffisant.

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

                • [^] # Re: Du côté de la syntaxe

                  Posté par  . Évalué à 2.

                  Faut pas se leurer, dans 30 on programmera plus les machines. Et ça commence : dans des grandes boites comme Cap Gemini, 97% du code est généré suite à des schémas, spécifications, design d'interface...

                  T'as de sources ou c'est une estimation a la louche? Ca me semble un peu surréaliste, quand on voit la qualité du code généré...

                  Sinon pour le reste, je suis plutôt pas d'accord avec toi :) Quand on programme une machine (que ce soit avec des schémas, des pouik pouik qui clignotent ou un langage presque "naturel"), on s'attend a un comportement déterministe, pas a un truc bourre d'heuristiques. Et c'est ça le problème des langues naturelles. Elles sont tellement basées sur les sous-entendus et l'implicite qu’elles sont beaucoup trop ambigüe pour pouvoir programmer une machine. Et j’insiste, par définition on devra toujours programmer une machine. C'est-à-dire lui dicter son « comportement », même s’il s’agit d’une IA.
                  • [^] # Re: Du côté de la syntaxe

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

                    T'as de sources ou c'est une estimation a la louche? Ca me semble un peu surréaliste, quand on voit la qualité du code généré...
                    Estimation à la louche d'un copain ingénieur à CapGemini.

                    Sinon pour le reste, je suis plutôt pas d'accord avec toi :) Quand on programme une machine (que ce soit avec des schémas, des pouik pouik qui clignotent ou un langage presque "naturel"), on s'attend a un comportement déterministe, pas a un truc bourre d'heuristiques. Et c'est ça le problème des langues naturelles. Elles sont tellement basées sur les sous-entendus et l'implicite qu’elles sont beaucoup trop ambigüe pour pouvoir programmer une machine. Et j’insiste, par définition on devra toujours programmer une machine. C'est-à-dire lui dicter son « comportement », même s’il s’agit d’une IA.

                    Pas d'accord non plus :)

                    En particulier, je ne suis pas d'accord avec l'assertion "Entre la programmation opérationnelle ( http://fr.wikipedia.org/wiki/S%C3%A9mantique_op%C3%A9rationn(...) ) et le flou artistique du langage naturelle, il n'y a pas de solution".
                    SQL c'est quoi ? Une expression régulière c'est quoi ?
                    Un métalangage. Tu lui décris ce que tu veux, le système te renvoi la réponse.

                    L'objectif est ici de généraliser ce concept.

                    SI tu dis au système A={ qqsoit y ¤ B | y ¤ B et y > 15}, tu as quelques chose de déterministe...
                    Mon propos n'est pas de vouloir mettre un langage "naturel" pour programmer, mais de dépasser le carcan de la grammaire classique formalisable en BNF.
                    C'est juste l'idée de disposer après analyse de graphe grammaticaux relativement simple dont le sens va émmerger Et de la structure grammatical Et du sens des mots clé utilisé, donc du contexte.

                    Avec une bonne IA, comprendre
                    'Create file "toto.xml"' ou 'Create xml structure with' , c'est pas insurmontable !
                    Bref, je ne cherche pas du côté de la logique flou, je cherche un formalisme souple et évolutif permettant de décrire avec précision une spécification précises, complète et sans ambiguités de ce que je veux obtenir.

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

                • [^] # Re: Du côté de la syntaxe

                  Posté par  . Évalué à 3.

                  Cependant, mon premier reflexe, comme lui, quand j'ai lu ces lignes :

                  je demande à l'ordinateur de m'envoyer un résultat en décrivant ce que je veux et non en décrivant ce que l'ordinateur doit faire pour l'obtenir.

                  j'ai aussi tout de suite pensé Prolog.
                  Je cite d'ailleurs wikipedia a propos de la programmation logique (utilisée par Prolog) :

                  La Programmation logique est une forme de programmation dont l'essence est de définir des règles de logique mathématique au lieu de fournir une succession d'instructions que l'ordinateur exécuterait.

                  Dans ton exemple avec itself, j'ai l'impression que ce que tu cherches c'est que ton langage évolue au fil du temps : itself n'avait pas de sens avant le exist file. Tu n'as pas eu à le définir ensuite, parce que son sens est devenu intrinsèquement lié à l'objet considéré au moment présent. A première vue ça ressemble à une déclaration de variable/objet qui serait induite par le langage et non imposée par une instanciation effectuée par le développeur.

                  Dans la programmation, il y a deux extrêmes : ceux qui veulent qu'on fasse : déclaration, instanciation, utilisation, destruction. Et ceux qui pensent que tout ça, ça lourde, c'est verbeux, on peut laisser le soin à la machine de s'en occuper tout seul. On arrive actuellement à des langages où on doit déclarer et instancier en même temps, la destruction est laissée à la machine.
                  Tu aimerais d'une certaine manière avoir un langage dont le sens te permet de t'affranchir de l'instanciation, si j'ai bien compris, c'est ça ?

                  (pareil que toi, je réflechis en même temps que j'écris)

                  Donc, comme tu dis, le nom de la variable a maintenant un sens dans ce langage : grâce au vocabulaire, on peut deviner ce qu'est un élément. A quoi il se rapporte, c'est du au contexte (itself est dans une boucle if, et concerne ce qui est testé par le if, mais pas l'existence, parce qu'elle n'est qu'un test, pas un "objet" humainement visible et palpable. Donc itself ne peut être que file).

                  Tes idées sont toujours aussi marrantes, parce qu'elles vont contre courant, j'aime bien ;) Même si ça ne mène à rien d'exploitable (ou pas), ça donne parfois à réflechir sur des sujets intéressants
                  • [^] # Re: Du côté de la syntaxe

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

                    j'ai aussi tout de suite pensé Prolog.
                    Prolog c'est vachement intéressant, mais beaucoup trop limité. On peut difficilement écrire un logiciel de gestion avec.

                    Dans ton exemple avec itself, j'ai l'impression que ce que tu cherches c'est que ton langage évolue au fil du temps : itself n'avait pas de sens avant le exist file. Tu n'as pas eu à le définir ensuite, parce que son sens est devenu intrinsèquement lié à l'objet considéré au moment présent. A première vue ça ressemble à une déclaration de variable/objet qui serait induite par le langage et non imposée par une instanciation effectuée par le développeur.

                    C'est exactement ça. Du sens de chaque mot et de la grammaire formée emmerge le sens.

                    On pourrait définir dans la bibliothèque le mot clé create de la façon suivante.

                    Create [in] <élément> et Create <élément> []

                    (En effet, je taxinomise pour le moment (je peux changer d'avis) en terme de "notion", "d'agent non vivant" et "d'agent vivant", sachant que chaque agent est potentiellement un SMA peuplé lui même d'agent formés par des SMA... Il y aura aussi probalement les notions de temps et de localisation)

                    On a donc deux dérivation possible associée à "Create".

                    Dans Create [in] <élément> l' ensemble est un objet "physique", donc on créé un élément dans l'ensemble.

                    Si Create est associé à une notion, cela veux dire que l'on crée un élement qui est une instanciation de cette notion, donc ici un fichier. La notion de localisation se réfère ici à l'endroit où elle se crée. La notion de localisation sera une primitive qui pourra se décliner en fonction du contexte. Dans un contexte fichier, il s'agit de préciser sur quel disque physique, ressource réseaux etc... on crée le fichier.
                    Cela pourra aussi donner lieu à la localisation d'un endroit particulier du fichier, en fonction du pattern.

                    (je réfléchis encore en écrivant)

                    Dans un fichier xml, il s'agit de retrouver un ou plusieurs pattern.

                    exemple find in (file "toto.xml" of type xml) (pattern [folder] [type ="(\w*)"][/folder]) and replace capture [0-9]+ by "coucou"

                    On a find in <qq_chose>
                    and est une conjonction de coordination, donc là la machine déduit qu'il s'agit d'un ordre associé.
                    replace <qq_chose> by <qq_chose>
                    ("find in" sera toujours associé à un ensemble)

                    find in <qq_chose>: désigne (file "toto.xml" of type xml). Le système comprend que l'ensemble en question est un ensemble structuré par une grammaire (xml en l'occurence).

                    Le <qq_chose>de find doit donc se rapporter à l'ensemble désigné et être compatible avec la grammaire. De plus, on ne sait pas si on cherche un élément ou un sous ensemble, d'où l'utilisation de <qq_chose> dont hérite et <éléments>
                    Ici il est remplacé par (pattern [folder] [type ="(\w*)"][/folder]) qui est un sous ensemble (un sous arbre) de l'xml.

                    Ensuite, on passe à l'ordre suivant :
                    replace capture [0-9]+ by "coucou"
                    Comme j'ai mis ma regexp entre parenthèse, j'ai une capture. Il y aura donc autant de captures que de sous ensembles trouvés. '[0-9]+' veut dire n'importe laquelle.
                    replace <élément> by <élément>

                    Bon j'arrête le délire ici.

                    Tel que je l'imagine, le système serait doté d'un moteur logique qui détecterait les ambiguité et demanderait à l'utilisateur de les lever.

                    Merci pour vos intervention multiples qui m'ont fait beaucoup réfléchir , je crois qu'il va falloir que j'étudie la théorie des grammaires génératives de chomsky, ainsi que les types ayant essayé de concevoir un langage logique destiné à supprimer les sous entendus.

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

                • [^] # Re: Du côté de la syntaxe

                  Posté par  . Évalué à 2.

                  Heureusement que j'avais mis « ;oP » et une remarque sur Prolog derrière…

                   "tu es gentil, mais c'est du sucre syntaxique"
                  Et en ce qui me concerne, je trouve ça totalement insuffisant. 

                  Tu semblais pourtant intéressé par AppleScript. Il s'agit juste d'une autre forme, d'une autre piste.

                  En AppleScript, on a tell … to …, avec tell et to qui sont deux mots-clefs. Ils sont lexicalisés dans la grammaire. (En tout cas, ils le semblent, comme des begin … end ou do … end.)
                  En CLISP et en Smalltalk, le premier mot est une fonction et les suivants sont des symboles. Ils sont donc variables suivant la fonction et ne sont pas dans la grammaire.
                  En ce qui concerne l'utilisateur, les deux formes sont des mots-clefs à retenir. (Certain Smalltalkien de ma connaissance soutient mordicus le contraire en affirmant que le Smalltalk n'a presque pas de mots-clefs (beaucoup moins que Java ou Python, p.ex.), comme si 1) il ne fallait pas mémoriser ces symboles, 2) une grande partie d'entre eux n'étaient pas génériques et communs à de nombreuses fonctions…)
  • # Hmm ...

    Posté par  . Évalué à 6.

    S'il y a des linguistes dans la salle, ayant des éventuels pointeurs, je suis intéressé, google ne m'ayant rien donné de très exploitable.


    void *ptr;
    ptr = &(linguist->pidgin);

    A tous les coups je dois m'être gourré qqpart, mon niveau en C sur ce genre de trucs n'étant pas super top.
    • [^] # [HS] merci pour ta page sur free

      Posté par  . Évalué à 0.

      ... que je découvre aujourd'hui, et qui est un bon résumé.

      Ah si seulement je l'avais vue il y a quelques mois :-(

      La gent féminine, pas la "gente", pas de "e" ! La gent féminine ! Et ça se prononce comme "gens". Pas "jante".

      • [^] # Re: [HS] merci pour ta page sur free

        Posté par  . Évalué à 0.

        Gnieu ???
        • [^] # Re: [HS] merci pour ta page sur free

          Posté par  . Évalué à 0.

          Ah en effet, je me suis indéniablement gourré dans les onglets de mon
          navigateur.

          Enfin ceci n'enlève rien aux mérites (certes sans rapport aucun avec
          free.fr ) de ta page ;-)

          La gent féminine, pas la "gente", pas de "e" ! La gent féminine ! Et ça se prononce comme "gens". Pas "jante".

  • # perl ?

    Posté par  . Évalué à 2.

    Un pidgin, c'est à dire une langue simplifiée aux structures rudimentaires, au vocabulaire restreint, sorte de mélange d'une langue de base et de langues indigènes, jamais apprise de manière native, peu expressive, une langue véhiculaire, sorte de plus petit dénominateur commun entre des populations d'origines diverses ?

    Je crois que j'ai ce qu'il te faut:

    http://www.perl.com/doc/manual/html/pod/perlsyn.html

    :-p
  • # Bah yacc qu'à demander...

    Posté par  . Évalué à 3.

    %token KIKOO
    %token LOL

    %% /* Grammar rules and actions follow */

    irc : KIKOO | LOL ;

    %

    Tu dois pouvoir faire le même pour le SMS en moins de deux.
  • # Espéranto-Ido

    Posté par  . Évalué à 2.

    Bonjour,

    Tu devrais chercher du côté des langues artificielles, en particulier l'ido.

    L'ido est une version moderne de l'esperanto, sans les accents bizarres ou la primauté du masculin.

    L'avantage est d'avoir:
    - une grammaire régulière, simple et restreinte.
    - une similarité par rapport aux langues naturelle qui facilite l'apprentissage,
    - un vocabulaire riche ayant des racines dans les langues indo-européennes,
    - une expression souple et puissante grâce à l'usage de radicaux et d'affixes (un même radical peut être un nom, un verbe, un adjectif, donner une idée d'antériorité, de multiplicité, d'infériorité, de féminité, de répétition, etc.).

    L'ido est sûrement la meilleure langue véhiculaire et probablement un lien entre le langue humain et le language machine évolué tel que tu le présentes dans tes réflexions.
    • [^] # Re: Espéranto-Ido

      Posté par  . Évalué à 3.

      Après les trolls :

      - Vi - Emacs
      - KDE - Gnome
      - Debian - Ubuntu
      - C - C++
      - Perl - Python
      - J'en passe - Et des meilleures

      voici le grand retour du troll (qui date du début du siècle, un peu le grand-père de tout les trolls, quoi)

      - Esperanto - Ido


      C'est la gloire \o/
      • [^] # Re: Espéranto-Ido

        Posté par  . Évalué à 3.

        Accéssoirement, quitte à aller voir du coté des langues construites, il peut peut-être jeter un coup d'oeil au lojban ou au kotava :

        Pour le premier :
        Le mot lojban vient de langue logique, en lojban. En effet, la grammaire du lojban est basée sur les principes de la logique des prédicats. http://fr.wikipedia.org/wiki/Lojban

        Pour le deuxième, c'est une langue à-priori .
        • [^] # Re: Espéranto-Ido

          Posté par  . Évalué à 2.

          La force et le génie de l'espéranto et donc de l'Ido est d'être perçus comme similaire à une "vraie" langue. Le succès historique de l'espéranto me semble en être la preuve; a contrario les "langues logiques" n'ont jamais rencontrés un quelconque succès.

          Une langue naturelle se caractérise, entre autre, par ses redondances, sa polysémie, sa capacité à connoter.... Je dirais même que c'est le propre de la communication humaine. Un langage logique évacue, ou tente d'évacuer, ce qui n'est pas explicite et univoque. In fine on se retrouve avec un langage mathématique, proche d'un langage informatique, très peu intuitif et facile à apprendre.

          L'ido me semble être le meilleur compromis entre une langue naturelle et un langage informatique.
          • [^] # Re: Espéranto-Ido

            Posté par  . Évalué à 2.

            Un langage logique évacue, ou tente d'évacuer, ce qui n'est pas explicite et univoque. In fine on se retrouve avec un langage mathématique, proche d'un langage informatique, très peu intuitif et facile à apprendre.

            Ce qui tombe bien, vu que l'auteur de l'article recherche justement à faire un langage informatique plus proche du langage humain.
            • [^] # Re: Espéranto-Ido

              Posté par  . Évalué à 1.

              Muff, mon clavier a fourché.
              Je voulais dire peu intuitif et PAS facile à apprendre.

              Pour aller au bout de ma pensée: je trouve cela inutile d'avoir un langage artificiel aussi rébarbatif pour le commun des mortels qu'un langage informatique.

              L'avantage d'une langue comme l'ido utilisé dans l'informatique serait d'avoir une langue destinée à couvrir toute l'expression humaine (comme les langues naturelles), mais pouvant être appliquée à une destination précise sans trop d'efforts (en l'occurence l'informatique).

              l'auteur de l'article recherche justement à faire un langage informatique plus proche du langage humain.


              Ce que je propose c'est une langue humaine proche du langage informatique.
    • [^] # Re: Espéranto-Ido

      Posté par  . Évalué à 2.

      Comme langue artificielle minimaliste, il y a aussi :
      - le Toki Pona (tokipona.org),
      - le Glosa (glosa.org),
      - le Basic English (basic-english.org),
      - et beaucoup d'autres (langmaker.com).

      Le Lojban (lojban.org) est très loin d'être minimaliste, mais c'est le plus axé sur la communication avec les ordinateurs.

      Les créoles sont essentiellement des langues orales, comme le kreyol haïtien, qui plus est dans des pays pauvres. Il y a donc peu de documentation sur l'internet.

      Il doit y avoir plus d'infos sur le Swahili et le Filipino.

Suivre le flux des commentaires

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