Recherche:Algoritmaro

Une page de Wikiversité.
Aller à : navigation, rechercher
Desktop computer clipart - Yellow theme.svg
Wikimedia-research-fr.png
Travail de recherche : Algoritmaro kaj algoritmleksemaro

Cette page de l’espace Recherche, dépend de la faculté linguistique. Consultez le portail de l'espace recherche ou pour plus de détails l'index des travaux de recherche par faculté.

Toutes les discussions sur ce sujet doivent avoir lieu sur cette page.


Ce projet vise à étudier le vocabulaire utile à l’algorithmique en espéranto, et aux langages de programmation utilisant un lexique espérantophone. Pour se faire on étudiera l’implémentation de divers algorithmes dans un panel de langages de programmation existants où le lexique est majoritairement anglophone, et pour chacun on proposera une transcription en espéranto. Ce projet fait écho au projet Fabeleblaĵo, mais contrairement à celui-ci, on se souciera pas nécessairement de fournir des codes sources totalement phonétiques.

Nous retiendrons, dans un premier temps, les langages d’implémentation anglophone suivant :

  • MMIX pour l’assembleur ;
  • C comme langage de programmation impératif ;
  • C++ comme langage de programmation multi-paradigme : procédurale, orientée objet et générique ;
  • Clojure, Haskel, ou Scala comme langage de programmation fonctionnel, choix que nous effectuerons ultérieurement ;
  • Python en tant que langage de script moderne ;
  • Lua en tant que langage de script réflexif et impératif.

Comme d’habitude, il est difficile de faire ce type de choix. La popularité de ces langages varie parfois rapidement à travers le temps, et il est difficile de prédire ce qui demain suscitera l’engouement. C’est d’ailleurs la raison d’être de MMIX, conçu spécifiquement pour contourner cette problématique dans le cadre de la rédaction de The Art of Computer Programming. Cela étant, certains langages peuvent aujourd’hui assurément se prévaloir d’une importante assise du fait de la base de code existante. C’est bien évidemment le cas du C et C++, présents sur la scène des langages informatiques respectivement depuis 1972 et 1983. De son coté Python est un peu plus jeune, 1990, mais semble avoir largement le vent en poupe depuis déjà un certain temps. Pour ce qui est de Lua, ce choix est principalement dicté par sa disponibilité en tant que langage de script directement au sein de l’infrastructure Wikimedia. Du côté des langages fonctionnelles, aucun ne semble encore avoir fait de percé fulgurante en dehors du milieu universitaire. Scala rencontre peut-être actuellement un succès plus important, mais il n’est pas purement fonctionnel. Toujours est-il que ce qui importe dans le cadre de ce projet est de dégager le vocabulaire espéranto utile pour implémenter langages de programmation et des algorithmes. Autant que possible, on tentera de s’appuyer sur des terminologie déjà adoptés par d’autres espérantiste, et exposé dans des ouvrages comme le Komputada leksikono[1].

Au niveau des algorithmes qu’on se propose de prendre comme cas d’étude, nous développerons plusieurs axes en parallèle :

  • historique, c’est-à-dire présentant chronologiquement des algorithmes comme ceux d’Euclide, de Newton, etc.
  • méthodologie courante avec les patrons de conception ;
  • selon l’humeur des auteurs[2].

Le projet devra donc apporter un glossaire informatique anglais-espéranto permettant de « traduire » les langages sus-cités, et on profitera de l’occasion pour également fournir les équivalences françaises en annexe.

De plus à travers ces travaux on souhaite dégager les avantages de la structure grammaticale régulière de l’espéranto pour exposer des constructions lexicales applicables à des langages de programmation qui en tirerait partie.


Sommaire

Structure des langages[modifier | modifier le wikicode]

Avant de s’intéresser à des cas plus complexes, le projet débute par un tour d’horizon des mots clés et des grammaires utiles à tous les langages de programmation et en particulier ceux qu’utilisent les langages que nous avons retenu.


Opérateurs arithmétiques[modifier | modifier le wikicode]

Vocabulaire utilisé pour nommer les différentes représentations numériques
 Nom de l’opération Symbole courant Nom de l’opérateur Nom du facteur Nom de l’opérande Nom du résultat
egalaĵo a = o signo de egaleco aŭ egalsigno
f + o = r f plus o faras r
f * o = r f-oble o estas r
o - f = r o minus f igu r
o / f = r f-one o igu r
o % f = i
of = r f alt o igu r[3]
logf(o) = r

MMIX[modifier | modifier le wikicode]

Vocabulaire général lié aux discours sur les assembleurs[modifier | modifier le wikicode]

Pour établir une liste du Vocabulaire général lié aux discours assembleur, on propose de relever les termes techniques utilisés dans le FASCICLE 1 MMIX de THE ART OF COMPUTER PROGRAMMING[mmix 1].

Description d’architecture matérielle[modifier | modifier le wikicode]
Vocabulaire utilisé pour nommer les différentes représentations numériques
Nom anglais Nom espéranto Nom français
alignement (mémoire)[note 1] ĝisrandigo[note 2] alignement
big-endian pezeka[note 3] petit-boutisme
little-endian eteka[note 3] gros-boutisme
Représentations des nombres[modifier | modifier le wikicode]
Vocabulaire utilisé pour nommer les différentes représentations numériques
Nom anglais Nom espéranto Nom français
representation prezento représentation
system sistemo système
binary duuma binaire
octal okuma octal
decimal dekuma décimal
hexadecimal deksesuma hexadécimal
floating(-point) glit(kom)a (à virgule) flottant(e)
integer entjera entier
signed signuma signé
unsigned sensignuma non-signé

Les formes d’écriture positionnelle utiliseront la même notation qu’à l’usuel : en binaire, 241 en décimal, f116 en hexadécimal.

Références aux cellules mémoires[modifier | modifier le wikicode]

La documentation de MMIX utilise la notation M[j], où j est un ogdo, pour désigner le j-ième octet de la mémoire virtuelle de la machine. Pour notre part nous utiliserons la notation fonctionnelle indiku(j), ou alternativement la forme j-indikanto. Ici le verbe indiki[note 4] est à prendre tant au sens « ce qu’indique j », et j-indikanto au sens de « ce qui est dénoté par (ce qui est situé en) j ».

De même, à la place de la notation qui permet désigner le nombre codé sur les octets, nous utiliserons la notation fonctionnelle indiku(k, t) ou sa variante au participe présent substantivé t-um-k-indikanto. Par exemple, indiku(6, 2) donne 2-um-6-indikanto ou en toutes lettres duum-ses-indikanto.

Signalons que dans la seconde notation, l’adresse mémoire est codée indirectement, de sorte que indku(k) = indiku(k, 64) (). On nomme adresi la fonction d’indirection qui renvoie l’adresse correspondante, c’est-à-dire telle que adresu(k,t) renvoie l’adresse de la première cellule mémoire de indiku(k, t). On pourra également utiliser la notation t-um-k-adresanto.

def adresu(k,t):
    return k^(2**64-2**t)
Noms des groupes de quantificateur[modifier | modifier le wikicode]
Vocabulaire utilisé pour nommer des regroupement d’unité de mesure de l’information
Nombre de chiffres codables par position Nom anglais Nom espéranto Nom français
Terme retenu Autres termes possibles Terme de groupe unitiaire Terme de groupe d’octets Autres termes possibles
1 (unary digit) unuumo singulet octacho-octet arithmophore[4], arithmostœchion[5], nombre unaire
2 bit duumo bito duet tétracho-octet bit, binet, binème[6], quaternoctet, quaternet, nombre binaire
3 triumo ternet trisoctacho-octet[7]
4 nybble kvarumo kvaropo, bajtduono quadret hémi-octet semi-octet, demi-octet
5 kvinumo quintet pentakisoctacho-octet[8]
6 sesumo sénet tristétracho-octet[9]
7 sepumo septet heptakisoctacho-octet[10]
8 byte okumo okopo, bajto, bitoko, duumokopo octet
9 naŭumo nonet ennéakisoctacho-octet[11]
10 dekumo dénet pentakistétracho-octet[12]
16 wyde (okum)duopo duopokopo, dek-sesopo, okopduoblo, bajtduoblo seizet[note 5] dyoctet bi-octet, di-octet, doublet, duplet , sexidécet
32 tetra(byte) (okum)kvaropo okopokvaropo, okopkvaroblo, bajtkvaroblo, tri-dek-duopo duotrigéset tétra(-octet) bi-seizet, quadri-octet, trente-deuzet, quadlet, quad
64 octa(byte) (okum)okopo okopokopo, okopokoblo, bajtokoblo, ses-dek-vkaropo quadrisexagéset ogdo(-octet) quadri-seizet, octlet, octoctet, soixante-quatret, huit-octet, huitet, asht(e)(-octet)[note 6]

Entre parenthèses nous avons mis les parties élaguées dans les formes abrégés. Les affixes de l’espéranto permettent ici tout une variété de combinaisons possibles entre le -um- de sens indéfini, le collectif numérique -op-, le multiplicatif -obl-. Les mots retenus tentent de concilier autant que possible les contraintes suivantes :

  • l’usage fait prévaloir ce terme ;
  • le terme est endodescriptif, c’est-à-dire qu’il utilise uniquement des lexèmes typiques de la langue plutôt que d’avoir recours à des emprunts ;
  • les termes ont une proximité lexicale inverse à leur proximité sémantique, c’est-à-dire que plus il sont interchangeables en termes de rôle dans un discours, plus ils doivent se distinguer en termes de forme (contre exemple : octet et octlet) ;
  • la structure sémantique se reflète dans la structure lexicale : c’est-à-dire que les combinaisons de concepts sont traduites par des combinaisons de leurs lexèmes respectifs ;
  • les relations sémantiques isomorphes se reflètent par des structures lexicales isomorphes, c’est-à-dire qu’on tente de construire une nomenclature homogène ;
  • le mot à une longueur inversement proportionnelle à sa fréquence dans le discours.

Il est clair que toutes ces contraintes sont aussi raisonnables que divergentes sur la terminologie qu’elles incitent à retenir. On donne ci-après les raisons qui, à côté de la part arbitraire, ont décidé les choix les plus cornéliens.

On retient duumo plutôt que bito pour homogénéiser la nomenclature. On parle d’ailleurs volontiers de duuma sistemo, système binaire[note 7]. L’affixe -um- est, de façon homogène, retenu pour le premier niveau de regroupement, indiquant un groupe de bit. L’affixe -op- est retenue pour marquer un regroupement d’octets. Cette convention permet en plus d’omettre le préfixe okum-, là où une utilisation doublé de -op- (okopokvaropo,) aurait rendu l’aphérèse ambivalente. L’usage à jusque là plutôt retenue okopo en tant que terme endémique pour octet. Cependant si on avait fait le choix inverse, à savoir exprimer un groupe de 64 bits par okumo, on aurait eu la problématique inverse. En effet, on aurait donc retenu duopo, kvaropo et okopo pour bit, semi-octet et octet, alors que l’usage actuel retient duuma et okuma pour binaire et octal. Une nomenclature homogène nous oblige donc à contrevenir à l’un ou l’autre de ces usages.

Le terme seizet à pour lui un usage attesté, au moins dans la norme UNICODE, ainsi qu’une syllabe de moins par rapport à bi-octet que pourrait suggérer une nomenclature plus homogène. En revanche, si trente-deuzet jouit également d’une présence dans UNICODE, il s’avère plus long que le terme tétra, qui a également pour lui le fait de refléter parfaitement le terme anglais utilisé dans la documentation de MMIX. Enfin on préfère éliminer tout réusage du préfixe oct- pour le groupe de 64 bits. Octlet est beaucoup trop proche de octet. Octoctet sonne plutôt étrange dans une langue comme le français ou le redoublement est plutôt utilisé comme procédé hypocoristique : bibiche, chouchou, dodo, fifille… Quadri-seizet qu’on apocoperait en quadri voir quad amènerait beaucoup trop confusion avec tétra, d’autant que le terme quad est parfois utilisé pour désigner un tétra-octet. Asht[note 6] (prononcé /aʃ.t/), est un néologisme, mais il est concis et univoque. On pourrait aussi orthographier ashte, avec l’usuel e muet finale du français. Enfin ogdo- a l’avantage de se distinguer du lexème oct-, déjà employé dans octet, tout en désignant la même valeur numérique et en étant également issue d’une racine grecque. Voir par exemple ogdoade et ogdoédrie pour des usages de se préfixe relatif à huit.

Registres[modifier | modifier le wikicode]

MMIX est est à la fois une architecture informatique et un jeu d'instructions 64-bit RISC équipé d’au moins 256 registres. C’est ce dernier qui nous intéresse plus spécifiquement ici.

Dans MMIX chacune des 256 instructions fait quatre octets et code une opération et ses éventuelles arguments.

Dans le présent projet, l’affixe de lieu -ej- est utilisé pour dénoter les registres de façon générique : dekaejo, le dixième lieu, c’est-à-dire le dixième registre. On pourra indifféremment utiliser la forme d’écriture décimale positionnelle ou la combinaison d’adjectifs numéraux correspondante  : 16aejo, dek-sesaejo.

Instructions[modifier | modifier le wikicode]

Forme des instructions utilisé dans le cadre du présent projet
Opérateur Première opérande seconde opérande troisième opérande
Notations de la documentation de MMIX OP X Y Z
Notation utilisée dans le présent projet
operatoro cel(operand)o font(operand)oj
unuafont(operand)o duafont(operand)o
(duop)font(operand)o

(triopfont)operando

Le premier octet code toujours une opération, et les octets suivant un ou plusieurs opérandes. Le plus souvent le second octet code l’opérande cible, et les deux suivants des opérandes sources. Certains opérateurs prennent cependant plusieurs octets comme opérande unique, en groupant toujours depuis le dernier octet vers le premier.

De plus on note eju(X) ou X-ejo le registre X, noté $X dans la notation ADD $X, $Y, $Z. Celle-ci devient adiciu eju(X) eju(Y) eju(Z) ou adiciu X-ejo, Y-ejo, Z-ejo , avec X, Y et Z prenant des valeurs entières.

Chargement et stockage des données[modifier | modifier le wikicode]
Tableau des instructions utilisées pour le transfert de données entre les registres et la mémoire principale.
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
  • LDB $X,$Y,$Z
  • LDB $X,$Y,Z
load byte geokumŝargu[13] charger Charge dans le registre cible, en tant qu’entier signé, l’octet à l’adresse indiquée par la somme des deux opérandes sources. En notation fonctionnel pourrait traduire les deux variations de cette instruction par :
  • ŝargu( ejo(X), signumu(indiku(ejo(Y) + ejo(Z)) ) ) ;
  • ŝargu( ejo(X), signumu(indiku(ejo(Y) + Z) ) ).
LDBU $X,$Y,$Z|Z load byte unsigned okumŝargu Idem, mais charge la valeur en tant qu’entier non-signé.
LDW $X,$Y,$Z|Z load wyde geduopŝargu Charge dans le registre cible, en tant qu’entier signé, le seizet à l’adresse indiquée par la somme des deux opérandes sources.
LDWU $X,$Y,$Z|Z load wyde unsigned duopŝargu Idem, mais charge la valeur en tant qu’entier non-signé.
LDT $X,$Y,$Z|Z load tetra gekvaropŝargu Charge dans le registre cible, en tant qu’entier signé, le tétra à l’adresse indiquée par la somme des deux opérandes sources.
LDTU $X,$Y,$Z|Z load tetra unsigned kvaropŝargu Idem, mais charge la valeur en tant qu’entier non-signé.
LDO $X,$Y,$Z|Z load octa geokopŝargu Charge dans le registre cible, en tant qu’entier signé, l’ogdo à l’adresse indiquée par la somme des deux opérandes sources.
LDOU $X,$Y,$Z|Z load octa unsigned okopŝargu Idem, mais charge la valeur en tant qu’entier non-signé.
LDA $X,$Y,$Z|Z load address adresŝargu Charge dans le registre cible, en tant qu’adresse, l’ogdo à l’adresse indiquée par la somme des deux opérandes sources.
STB $X,$Y,$Z|Z store byte geokummemoru
STBU $X,$Y,$Z|Z store byte unsigned okummemoru
STW $X,$Y,$Z|Z store wyde geduopmemoru
STWU $X,$Y,$Z|Z store wyde unsigned duopmemoru
STT $X,$Y,$Z|Z store tetra gekvaropmemoru
STTU $X,$Y,$Z|Z store tetra unsigned kvaropmemoru
STO $X,$Y,$Z|Z store octa geokopmemoru
STOU $X,$Y,$Z|Z store octa unsigned okopmemoru
STCO X,$Y,$Z|Z store constant octabyte konstantmemoru
STHT $X,$Y,$Z|Z store high tetra pezmemoru
Addition et Soustraction[modifier | modifier le wikicode]
Tableau des instructions utilisées pour l’addition et la soustraction
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
ADD $X,$Y,$Z|Z add geadiciu
ADDU $X,$Y,$Z|Z add unsigned adiciu
2ADDU $X,$Y,$Z|Z times 2 and add unsigned duobladiciu
4ADDU $X,$Y,$Z|Z times 4 and add unsigned kvarobladiciu
8ADDU $X,$Y,$Z|Z times 8 and add unsigned okobladiciu
16ADDU $X,$Y,$Z|Z times 16 and add unsigned deksesobladiciu
SUB $X,$Y,$Z|Z subtract gesubtrahu
SUBU $X,$Y,$Z|Z subtract unsigned subtrahu
NEG $X,Y,$Z|Z negate gemalu
NEGU $X,Y,$Z|Z negate unsigned malu


Multiplication et division[modifier | modifier le wikicode]
Tableau des instructions de multiplication et de division
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
MUL $X,$Y,$Z|Z multiply geobligu
MULU $X,$Y,$Z|Z multiply unsigned obligu
DIV $X,$Y,$Z|Z divide geonigu
DIVU $X,$Y,$Z|Z divide unsigned onigu
Opérations bit à bit[modifier | modifier le wikicode]

Les opérations bit à bit sont généralement traduites laŭbita operacio en espéranto, on pourra donc parler, conformément à notre nomenclature, de laŭduuma operacio. MMIX en propose dix-huit variantes.

Tableau des instructions bit à bit
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
AND $X,$Y,$Z|Z bitwise and kaju[14]
OR $X,$Y,$Z|Z bitwise or kaŭu[15]
XOR $X,$Y,$Z|Z bitwise exclusive-or aŭu
ANDN $X,$Y,$Z|Z bitwise and-not kajneu
ORN $X,$Y,$Z|Z bitwise or-not aŭneu
NAND $X,$Y,$Z|Z bitwise not-and nekaju
NOR $X,$Y,$Z|Z bitwise not-or nekaŭu
NXOR $X,$Y,$Z|Z bitwise not-exclusive-or neaŭu
MUX $X,$Y,$Z|Z bitwise multiplex plektu[16]
BDIF $X,$Y,$Z|Z byte difference okummalsamu
WDIF $X,$Y,$Z|Z wyde difference duopmalsamu
TDIF $X,$Y,$Z|Z tetra difference kvaropmalsamu
ODIF $X,$Y,$Z|Z octa difference okopmalsamu
SADD $X,$Y,$Z|Z sideways add adiciumu[17]
MOR $X,$Y,$Z|Z multiple or kaŭoblu
MXOR $X,$Y,$Z|Z multiple exclusive-or aŭoblu
SETH $X,YZ set to high wyde unuapezasignu
SETMH $X,YZ set to medium high wyde duapezasignu
SETML $X,YZ set to medium low triapezasignu
SETL $X,YZ set to low wyde kvarapezasignu
INCH $X,YZ increase by high wyde
INCMH $X,YZ increase by medium high wyde
INCML $X,YZ increase increase by medium low wyde
ORH $X,YZ bitwise or with high wyde
ORMH $X,YZ bitwise or with medium high wyde
ORML $X,YZ bitwise or with medium low wyde
ORL $X,YZ bitwise or with low wyde
ANDNH $X,YZ bitwise and-not high wyde
ANDNMH $X,YZ bitwise and-not medium high wyde
SL $X,$Y,$Z|Z shift left
SLU $X,$Y,$Z|Z shift left unsigned
SR $X,$Y,$Z|Z shift right
SRU $X,$Y,$Z|Z shift right unsigned
Comparaisons[modifier | modifier le wikicode]
Tableau des instructions de comparaison
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
CMP $X,$Y,$Z|Z compare
CMPU $X,$Y,$Z|Z compare unsigned
CSN $X,$Y,$Z|Z conditionally set if negative
CSZ $X,$Y,$Z|Z conditionally set if zero
CSP $X,$Y,$Z|Z conditionally set if positive
CSOD $X,$Y,$Z|Z conditionally set if odd
CSNN $X,$Y,$Z|Z conditionally set if nonnegative
CSNZ $X,$Y,$Z|Z conditionally set if nonzero
CSNP $X,$Y,$Z|Z conditionally set if nonpositive
CSEV $X,$Y,$Z|Z conditionally set if even
ZSN $X,$Y,$Z|Z zero or set if negative
ZSZ $X,$Y,$Z|Z zero or set if zero
ZSP $X,$Y,$Z|Z zero or set if positive
ZSOD $X,$Y,$Z|Z zero or set if odd
ZSNN $X,$Y,$Z|Z zero or set if nonnegative
ZSNZ $X,$Y,$Z|Z zero or set if nonzero
ZSNP $X,$Y,$Z|Z zero or set if nonpositive
ZSEV $X,$Y,$Z|Z zero or set if even
Embranchements et sauts[modifier | modifier le wikicode]
Tableau des instructions d’embranchement et de saut
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
BN $X,@+4*YZ[−262144] branch if negative
BZ $X,@+4*YZ[−262144] branch if zero
BP $X,@+4*YZ[−262144] branch if positive
BOD $X,@+4*YZ[−262144] branch if odd
BNN $X,@+4*YZ[−262144] branch if nonnegative
BNZ $X,@+4*YZ[−262144] branch if nonzero
BNP $X,@+4*YZ[−262144] branch if nonpositive
BEV $X,@+4*YZ[−262144] branch if even
PBN $X,@+4*YZ[−262144] probable branch if negative
PBZ $X,@+4*YZ[−262144] probable branch if zero
PBP $X,@+4*YZ[−262144] probable branch if positive
PBOD $X,@+4*YZ[−262144] probable branch if odd
PBNN $X,@+4*YZ[−262144] probable branch if nonnegative
PBNZ $X,@+4*YZ[−262144] probable branch if nonzero
PBNP $X,@+4*YZ[−262144] probable branch if nonpositive
PBEV $X,@+4*YZ[−262144] probable branch if even
GETA $X,@+4*YZ[−262144] get address
JMP @+4*XYZ[−67108864] jump
GO $X,$Y,$Z|Z go to location
Calcules de nombres à virgule flottante[modifier | modifier le wikicode]
Tableau des instructions de calcul sur les nombres à virgule flottante
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
FSUB $X,$Y,$Z floating subtract
FMUL $X,$Y,$Z floating multiply
FDIV $X,$Y,$Z floating divide
FREM $X,$Y,$Z floating remainder
FSQRT $X,$Z floating square root
FINT $X,$Z floating integer
FCMP $X,$Y,$Z floating compare
FEQL $X,$Y,$Z floating equal to
FUN $X,$Y,$Z floating unordered
FCMPE $X,$Y,$Z floating compare (with respect to epsilon)
FEQLE $X,$Y,$Z floating equivalent (with respect to epsilon)
FUNE $X,$Y,$Z floating unordered (with respect to epsilon)
LDSF $X,$Y,$Z|Z load short float
STSF $X,$Y,$Z|Z store short float
FIX $X,$Z convert floating to fixed
FIXU $X,$Z convert floating to fixed unsigned
FLOT $X,$Z|Z convert fixed to floating
FLOTU $X,$Z|Z convert fixed to floating unsigned
SFLOT $X,$Z|Z ‘convert fixed to short float’; SFLOTU $X,$Z|Z convert fixed to short float unsigned
Édition de lien des sous-routine[modifier | modifier le wikicode]

Subroutine linkage -> subrutina ligo -> Édition de lien des sous-routine

Tableau des instructions de comparaison
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
PUSHJ $X,@+4*YZ[−262144] push registers and jump
PUSHGO $X,$Y,$Z|Z push registers and go
POP X,YZ pop registers and return from subroutine
Commandes systèmes[modifier | modifier le wikicode]
Tableau des instructions de comparaison
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
LDUNC $X,$Y,$Z|Z load octa uncached
STUNC $X,$Y,$Z|Z store octa uncached
PRELD X,$Y,$Z|Z preload data
PREGO X,$Y,$Z|Z prefetch to go
PREST X,$Y,$Z|Z prestore data
SYNCD X,$Y,$Z|Z synchronize data
SYNCID X,$Y,$Z|Z synchronize instructions and data
CSWAP $X,$Y,$Z|Z compare and swap octabytes
SYNC XYZ synchronize
Déclencheurs et interruptions[modifier | modifier le wikicode]

trip and trap -> déclencheurs et interruptions -> ekpaŝo kaj elpaŝo/interrompo

Tableau des instructions de comparaison
Nom de l’instruction MMIX Signification de l’instruction Nom espéranto Nom français Description
TRAP X,Y,Z trap
TRIP X,Y,Z trip
RESUME Z resume after interrupt

C[modifier | modifier le wikicode]

Mots clés réservés[modifier | modifier le wikicode]

Note : on commence par spécifier les racines à même de traduire le concept du mot clé de la langue orignal. On discute des termainaisons utilisable dans un second temps. Pour cette raison on termine nos traductions par un astérisque. Note : pour refléter les différents rôles des mots clés, on propose des traduction qui reflètent ces rôles par le type du mot : adjectif, verbe, substantif, etc.

Tableau des mots réservés du C et leur équivalent espéranto
Mot clé Traduction espéranto Description
auto aŭt* Définie comme locale la durée de vie d'une variable locale.
break elsalt*[18] Entraîne un saut hors de l’actuelle plus profonde structure de contrôle.
case kas* Voir switch
char sign*[19] Déclare une variable et lui associe le type correspondant à un code caractère.
const senĉes*[20] Indique que la variable ne pourra être affectée d’une valeur qu’à sa déclaration, et que toute tentative d’affectation ultérieure sera invalide.
continue plusalt*[21] Entraîne un saut vers la prochaine itération de l’actuelle plus profonde structure de contrôle. Ici il s’agit clairement d’une instruction qu’on peut traduire par un verbe à l’impératif.
default defaŭlt* Voir switch
do far* Usuellement utilisé en conjonction avec le mot clé while pour itérer au moins une fois sur un bloc d’instruction. Ici il s’agit clairement d’une instruction qu’on peut traduire par un verbe à l’impératif.
double duobl* glit* Déclare une variable et lui associe le type correspondant à un nombre à virgule flottante double précision. Ici la solution retenue diverge cependant de cette signification. Plutôt qu’un mot clé indépendant, on propose d’en faire un complément l’instruction de déclaration float, tout comme peuvent faire les mots clés longet unsigned.
else alie
entry enirej* Ce mot clé n’a jamais été standardisé, bien que réservé, sa fonction étant de permettre de multiples points d’entrée dans une fonction[22].
enum enumeraci*
extern ekster*
float glit* Déclare une variable et lui associe le type correspondant à un nombre à virgule flottante. La formation du mot retenu analogue à ce qui est détaillé pour char en se basant sur la locution glitpunkto (prezento), ramené simplement à glito, tout comme en français on parle par métonymie de flottant.
for por
goto ensalt*
if se
int entjer* Déclare une variable et lui associe le type correspondant à un entier. La formation du mot retenu analogue à ce qui est détaillé pour char en se basant sur le mot entjero.
long long*
register reĝistr*
return return*[23] Quitte la fonction courante vers la fonction appelante, optionnellement en renvoyant une valeur.
short mallong*
signed signum*
sizeof mezur*
static statik*
struct struktur*
switch ŝalt* Structure de contrôle qui, en fonction d’une variable associée, permute à l’embranchement case de valeur correspondante ou, s’il est défini, à l’embranchement default.
typedef tipdefin*
union uni*
unsigned malsignum*
void vaku*[24]
volatile variem*
while dum


Utilisation des mots clés et variations grammaticales espérantistes[modifier | modifier le wikicode]

Déclaration d’une fonction[modifier | modifier le wikicode]

Partons de quelque-chose de simple :

void idle (void)
{
  return;
}

En se basant sur nos traductions précédemment proposé, nous pourrions donc par exemple translittérer :

vakuo vaku (vakuo)
{
  returnu;
}

Que s’agit-il d’exprimer ici ? Nous voulons :

  • déclarer un objet de type fonction,
  • qui renvoie un objet de type vide,
  • prend un objet de type vide en paramètre,
  • associer à cette fonction un bloque d’instruction composé d’une unique instruction de retour au code appelant
  • et enfin créer une entrée dans notre dictionnaire qui associe un nom à cette fonction.

Le premier point n’est pas explicité en C, mais peut l’être plus ou moins dans d’autres langages. Ainsi en Python la déclaration d’une fonction débute par l’instruction def, apocope de define. Nous pourrions donc expliciter cette instruction par un verbe impératif :

definu vakuo vaku (vakuo)

Sous cette forme, on ne fait qu’ajouter à la confusion, vakuo pouvant passer pour un sujet de deux verbes à l'impératif : qu’on pourrait traduire par « définie néant, ne fait rien (néant) ». Un brin poétique, mais fort loin de ce que nous cherchons à exprimer. Nous souhaitons définir une fonction, donc une action, c’est-à-dire un verbe. C’est bien pourquoi nous avions retenu comme nom "vaku" qui est un verbe à l’impératif. Cependant dans le cadre d’une définition, on utilise plutôt la forme infinitive d’un verbe. En C, il serait peut commode d’utiliser l’impératif à la définition et une forme conjugué à l’appel, la conjugaison de l’anglais étant for irrégulière. Comme nous n’avons pas cette problématique en espéranto, nous pouvons nous permettre d’avoir des mots clés de forme variable. Cette définition nous pouvons la formuler par une suite de verbe à l’impératif, tous ayant pour sujet notre verbe à l’infinitif et pour éventuel objet grammatical, un objet du code.

definu vaki, returnu vakuon, prenu vakuon,
plenumu
{
  returnu;
}

Aussi on peut poser des contraintes sur les noms des objets que définie l’utilisateur de façon qu’un mot terminant par un -i indique le début de la définition d’une fonction nommée. Si on convient également que le premier objet à l’accusatif qui suit ce verbe indique l’objet retourné et les suivants les objets pris en paramètre, on peut réduire notre syntaxe précédente à

vaki, vakuon, vakuon
{
  returnu;
}

De plus, si jusque là nous avons utilisé le substantif vakuo, ce qu’on souhait désigner n’est pas un objet nommé que le nom de son type. On pourrait expliciter complètement cela en nommant notre type vakutipo. On préférera de plus utiliser la forme adjectivale et réservé la forme substantive au nom de l’objet typé.


vaki, vakutipan, vakutipan
{
  returnu;
}

Pour donner un aspect plus « définition de dictionnaire » un double-point peut remplacer la première virgule. Par rapport au verbe, le premier élément énoncé est un complément, tandis que les suivant sont sujet. D’où la possibilité de ne marquer l’accusatif que sur le premier élément. Cela devient évidemment bien plus pertinent à partir du moment où l’on utilise effectivement des noms d’objet.

Une fonction identité en C et un équivalant possible en langage espérantophone
int idle (int number)
{
  return number;
}
identi: entjertipan, entjertipa nombro
{
  returnu nombron;
}

Pour rester linguistiquement cohérent le sujet de instruction returnu doit être à l’accusatif. C’est de plus cohérent avec la façon proposé d’exprimer la définition, on renvoie "entjertipan nombron".

Si on tiens absolument à calquer la concision de la typologie du C, on peut fabriquer des mots clés plus courts.

Propositions de noms de type abrégés pour les types courants du C
Non du type C Typologie espérantophone Nom espérantophone abrégé possible
char signtipa stipa
double duobla glita/duobltipa dutipa
float glittipa gtipa
int entjertipa etipa
long longa lotipa
short mallonga/kurta kutipa
Une fonction identité en C et un équivalant possible en langage espérantophone
int identity(int number)
{
  return number;
}
identi: etipan, etipa nombro
{
  returnu nombron;
}
Signatures de fonction respectives
(int) (int) etipan, etipa
Appel de fonction[modifier | modifier le wikicode]

Pour l’appel de fonction on peut tout simplement conjuguer nos verbes :


Une fonction identité en C et un équivalant possible en langage espérantophone
int b, c, d;
b = 3;
c = identity(b);
d = sum(b,c);
etipaj bo, co, ĉo.
bo iĝi 3.
con identu bo.
sumi: etipan, etipa akumulejo, etipa adjunkto  { returnu akumulejo + adjunkto  }
ĉon sumu bo co.

Évidemment, comme en espéranto, la présence de l’accusatif permet une certaine souplesse dans l’ordre d’énonciation des mots.

ĉon sumu bo co.
bo co sumu ĉon. 
bo ĉon sumu co.
bo co ĉon sumu.
sumu ĉon bo co.
sumu bo co ĉon.

En revanche, tel quel, on ne peut inverser l’ordre d’apparition de bo et co, qui définie implicitement le rôle qu’ils prennent dans la fonction, ce qui peut amener à des résultats différents si la fonction n’est pas commutative. Éventuellement si tous les paramètres de la fonction sont de type différent, on peut inférer les rôles à partir des types passés. On peut aussi préciser à quel paramètre on souhaite affecter chaque sujet, par exemple en adverbialisant le nom du paramètre de la fonction et en adjoignant l’adverbe résultant au substantif de la variable à assigner. Les éventuelles ambiguïtés pouvant être résolues par une combinaison de priorité de proximité et d'ordre d'énonciation des substantifs candidats à l'adjonction : akumuleje sumu co bo, on affecte akumulejo de la valeur de co car il est énonciativement plus proche, et dans sumu co akumuleje bo, on affect également co car il est antécédent dans l’instruction énoncée.

sumu ĉon akumuleje co adjunkto bo. /* assigne co à akumulejo et bo à adjunkto */ 
sumu ĉon, akumuleje co, adjunkte bo. /* des virgules peuvent aider la lisibilité */
sumu ĉon, akumuleje co, bo. /* bo est assigné à adjunkto par inférence : il n'y a qu'un sujet non-utilisé et un paramètre de fonction non-assigné */

Notons bien que jusqu'ici, toutes les ponctuations peuvent être omises sans nuire à la précision de la syntaxe. En effet on peut déduire la fin de l'appel d'une fonction d'arité fixe du nombre de paramètres déjà fournis, et dans le cas d'une fonction d’arité variable, l’apparition d'un nouvel appel de fonction peut servir de marqueur de fin de la fonction précédente.


con identu bo bon bo identu /* pas d'ambiguïté syntaxique */
bo identu con, bo identu bon /* sémantiquement équivalent mais plus lisible */

Bien entendu, il peut être souhaiter d'intégrer une gestion des appels de fonction imbriqués. Une possibilité est d’utiliser le pronom démonstratif tio et le pronom relatif kio pour manipuler une pile de variables anonymes qui se voient attribuer les résultats des fonctions appelés. Les affectations pouvant se faire de manière implicite, à l'image de la variable par défaut de Perl.

Appels imbriqués
f(); g();
t = h(g());
h(t);
/* ajoute 2 à un produit scalaire de produits vectoriels */
n = sum( dot( cross ( cross( v1, cross( v2, v3 ) ), cross( v4, v5) ), v6) , 2)
fu gu             /* fu(); gu();  */
hu kio gu         /* tio = gu(); hu(tio); */
hu                /* tio = gu(tio) */
vektoreblu v4, v5 /* tio = cross( v4, v5) */
vektoreblu kio vektoreblu v2, v3 kun tio
n = sum( dot( cross ( cross( v1, cross( v2, v3 ) ), cross( v4, v5) ), v6) , 2) /* ajoute 2 à un produit scalaire de produits vectoriels */

On peut également vouloir passer une fonction en argument, ce qu’on peut réaliser de façon assez spontanée en suffixant la fonction par la terminaison de substantif -o.

Le passage de fonction
void g( int ) {return;}
void f( void (*pf)(int) ) {return;}
f(g);
gi: vakutipan, etipa { returnu. }
fi: vakutipan, gotipa { returnu. }
fu go
Expressions arithmétiques[modifier | modifier le wikicode]
Déclaration de variable[modifier | modifier le wikicode]

En nous basant sur la typologie proposée précédemment, et en tenant compte du fait que nous avons retenu une nomenclature imposant la terminaison des littéraux, on peut proposer l’équivalence suivante.

Proposition d’équivalents espérantophones aux instructions de déclaration du C
Déclaration d’une variable
int b;
etipa bo.
Déclaration chaîné de plusieurs variables de même type
int b, c, d;
etipaj bo, co, ĉo.
etipa fo, go. /* on peut décider de considérer cette syntaxe comme erroné. */
Déclaration utilisant plus de mots clés
int const volatile  b, c, d;
etipa senĉesa variema bo, co, ĉo.
Déclaration de pointeur
int *b;
etipa bejo. /* avec l'affixe -ej- indiquant le lieu */
Déclaration de tablo
int b[];
int c[][];
int d[10];
int f[999];
/* … */
int g;
g = f[21];
etipa bopo. /* avec l’affixe -op- indiquant un collectif */
etipa copopo.
etipa ĉodekopo. /* ou "cô-10-opo" ou "dekopa ĉo", ou encore "10-opa cô*/
etipa fo 999-opa.
/* … */
etipa go.
go = 21a-fo.
Affectation de variables[modifier | modifier le wikicode]

Dans la plupart des langage de programmation, l’affection d’une valeur à une variable utilise un symbole non alphanumérique, que ce soit un signe égal "=" ou une flèche vers la gauche "<-", le littéral précédant de l’opérateur prenant la valeur de l’expression qui le suit. Nous pourrions bien sûr nous contenter de reproduire ce schéma. Ceci étant, nous souhaitons profiter ici de l’occasion pour étudier les alternatives ne faisant pas recourt à des symboles extra-alphabétique.

D’autant que les verbes pouvant indiquer l’affectation d’une variable en espéranto ne manque pas : valorizi, valori, ricevi, asigni, igi, iĝi. Commençons par évaluer ces alternatives dans le cas d’une affectation basique.

answer = 42;

une première possibilité est de rendre cette expression par respondo valoru 42. Ici la variable qu’on veut affecter prend le rôle du sujet de notre phrase, et le nombre 42 est le complément, ce qui se démarque moins bien du fait qu’en espéranto un nombre ne prends pas la marque de l’accusatif. Cela ne soulève pourtant aucune ambiguïté dans la mesure où l’affectation de la valeur d’une variable n’est pas un cas à envisager. Si on suppose une autre variable mistero préalablement définie, on voit mieux le rôle de chaque élément dans une instruction comme respondo valoru misteron : "respondo" vaut "mistero".

À l’inverse respondon valorigu mistero indique que "mistero" fait prendre une valeur à "respondo".

En allant un peut plus loin, on peut se poser le problème d’exprimer sans ambiguïté l’assignation du résultat d’une expression plut complexe qu’un unique terminal.

question = 6*9;
credibility = weigh(question)

Il reste bien sûr toujours possible de se contenter d’expressions comme demando valoru 6*9. Profitons cependant de l’occasion pour méditer sur la façon de forger des expressions énonçables sans ambiguïté et faisant sens à un espérantophone. Sachant que l’expression 6∗9 peut se prononcer "ses-oble naŭ", on aura pas d’ambiguïté dans une phrase comme demando valoru ses-oble naŭ. De même on aura variablo valoru bon-oble con pour la multiplication des variables bo et co.

Description BNF d’une traduction esperanto du C[modifier | modifier le wikicode]

On se base ici sur une BNF construite à partir l'implémentation C du projet GNU[25].


Voir pour utiliser The syntax of C in Backus-Naur Form



Hello World et Saluton Mondo[modifier | modifier le wikicode]

Pour illustrer ce que des variations espérantophone du C pourrait donner, nous nous baserons sur l’implémentation du projet GNU du fameux programme Hello World.

/* hello.c -- print a greeting message and exit.

   Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2005,
   2006, 2007, 2008, 2010, 2011 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <config.h>
#include "system.h"
#include "progname.h"
#include "xalloc.h"

static const struct option longopts[] = {
  {"greeting", required_argument, NULL, 'g'},
  {"help", no_argument, NULL, 'h'},
  {"next-generation", no_argument, NULL, 'n'},
  {"traditional", no_argument, NULL, 't'},
  {"version", no_argument, NULL, 'v'},
  {NULL, 0, NULL, 0}
};

/* Different types of greetings; only one per invocation. */
typedef enum
{
  greet_traditional,
  greet_new
} greeting_type;

/* Forward declarations. */
static void print_help (void);
static void print_version (void);
static void print_frame (const size_t len);

int
main (int argc, char *argv[])
{
  int optc;
  int lose = 0;
  const char *greeting_msg = _("Hello, world!");
  wchar_t *mb_greeting;
  size_t len;
  greeting_type g = greet_traditional;

  set_program_name (argv[0]);

  /* Set locale via LC_ALL.  */
  setlocale (LC_ALL, "");

#if ENABLE_NLS
  /* Set the text message domain.  */
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);
#endif

  /* Even exiting has subtleties.  On exit, if any writes failed, change
     the exit status.  The /dev/full device on GNU/Linux can be used for
     testing; for instance, hello >/dev/full should exit unsuccessfully.
     This is implemented in the Gnulib module "closeout".  */
  atexit (close_stdout);

  while ((optc = getopt_long (argc, argv, "g:hntv", longopts, NULL)) != -1)
    switch (optc)
      {
	/* --help and --version exit immediately, per GNU coding standards. */
      case 'v':
	print_version ();
	exit (EXIT_SUCCESS);
	break;
      case 'g':
	greeting_msg = optarg;
	break;
      case 'h':
	print_help ();
	exit (EXIT_SUCCESS);
	break;
      case 'n':
	g = greet_new;
	break;
      case 't':
	g = greet_traditional;
	greeting_msg = _("hello, world");
	break;
      default:
	lose = 1;
	break;
      }

  if (lose || optind < argc)
    {
      /* Print error message and exit.  */
      if (optind < argc)
	fprintf (stderr, _("%s: extra operand: %s\n"), program_name,
		 argv[optind]);
      fprintf (stderr, _("Try `%s --help' for more information.\n"),
	 program_name);
      exit (EXIT_FAILURE);
    }

  len = mbsrtowcs(NULL, &greeting_msg, 0, NULL);
  if (len == (size_t)-1)
    {
      fprintf (stderr, _("%s: conversion to a multibyte string failed\n"), program_name);
      exit (EXIT_FAILURE);
    }
  mb_greeting = xmalloc((len + 1) * sizeof(wchar_t));
  mbsrtowcs(mb_greeting, &greeting_msg, len + 1, NULL);

  /* Print greeting message and exit. */
  if (g != greet_new)
    wprintf (L"%ls\n", mb_greeting);
  else
    {
      print_frame (len);
      wprintf (L"| %ls |\n", mb_greeting);
      print_frame (len);
    }
  free(mb_greeting);

  exit (EXIT_SUCCESS);
}


/* Print new format upper and lower frame. */

void
print_frame (const size_t len)
{
  size_t i;
  fputws (L"+-", stdout);
  for (i = 0; i < len; i++)
    putwchar (L'-');
  fputws (L"-+\n", stdout);
}


/* Print help info. This long message is split into
   several pieces to help translators be able to align different
   blocks and identify the various pieces.  */

static void
print_help (void)
{
  /* TRANSLATORS: --help output 1 (synopsis)
     no-wrap */
  printf (_("\
Usage: %s [OPTION]...\n"), program_name);

  /* TRANSLATORS: --help output 2 (brief description)
     no-wrap */
  fputs (_("\
Print a friendly, customizable greeting.\n"), stdout);

  puts ("");
  /* TRANSLATORS: --help output 3: options 1/2
     no-wrap */
  fputs (_("\
  -h, --help          display this help and exit\n\
  -v, --version       display version information and exit\n"), stdout);

  puts ("");
  /* TRANSLATORS: --help output 4: options 2/2
     no-wrap */
  fputs (_("\
  -t, --traditional       use traditional greeting\n\
  -n, --next-generation   use next-generation greeting\n\
  -g, --greeting=TEXT     use TEXT as the greeting message\n"), stdout);

  printf ("\n");
  /* TRANSLATORS: --help output 5+ (reports)
     TRANSLATORS: the placeholder indicates the bug-reporting address
     for this application.  Please add _another line_ with the
     address for translation bugs.
     no-wrap */
  printf (_("\
Report bugs to: %s\n"), PACKAGE_BUGREPORT);
#ifdef PACKAGE_PACKAGER_BUG_REPORTS
  printf (_("Report %s bugs to: %s\n"), PACKAGE_PACKAGER,
	 PACKAGE_PACKAGER_BUG_REPORTS);
#endif
#ifdef PACKAGE_URL
  printf (_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
#else
  printf (_("%s home page: <http://www.gnu.org/software/%s/>\n"),
	 PACKAGE_NAME, PACKAGE);
#endif
  fputs (_("General help using GNU software: <http://www.gnu.org/gethelp/>\n"),
	 stdout);
}



/* Print version and copyright information. */

static void
print_version (void)
{
  printf ("%s (%s) %s\n", PACKAGE, PACKAGE_NAME, VERSION);
  /* xgettext: no-wrap */
  puts ("");

  /* It is important to separate the year from the rest of the message,
     as done here, to avoid having to retranslate the message when a new
     year comes around.  */
  printf (_("\
Copyright (C) %d Free Software Foundation, Inc.\n\
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
This is free software: you are free to change and redistribute it.\n\
There is NO WARRANTY, to the extent permitted by law.\n"), COPYRIGHT_YEAR);
}

C++[modifier | modifier le wikicode]

Python[modifier | modifier le wikicode]

Lua[modifier | modifier le wikicode]

Les lexèmes des bibliothèques standards[modifier | modifier le wikicode]

MMIX[modifier | modifier le wikicode]

C[modifier | modifier le wikicode]

C++[modifier | modifier le wikicode]

Coljure[modifier | modifier le wikicode]

Python[modifier | modifier le wikicode]

Lua[modifier | modifier le wikicode]

Algorithmes historiques[modifier | modifier le wikicode]

Les patrons de conception[modifier | modifier le wikicode]

desegmodelo[26].

Dans cette partie nous reprenons les plans du wikibook sur les patrons de conception, dont on reprendra également les implémentions quand elles existent pour les langages que nous nous proposons d’étudier. On prendra tout de fois soin de le modifier pour faire apparaître le vocabulaire anglais là où du français apparaît, notamment dans les commentaires.

Patrons du « Gang of Four »[modifier | modifier le wikicode]

Patrons de création[modifier | modifier le wikicode]

Singleton[modifier | modifier le wikicode]
Nom anglais 
Singleton
Description succincte 
Ne permettre la création que d'une seule instance d'une classe.

Vikipedio possède l’article unuera aro qui définie le singleton mathématique. On peut probablement pousser jusqu’à agglutiner en unueraaro, mais pas unueraro ; étant donné que eraro signifie erreur, on se retrouverait avec une possible confusion avec un terme qu’on pourrait traduire par mono-erreur. On constate qu’il existe tout de fois des constructions comme unuĉelulo, organisme unicellulaire, d’une part, et unuigo, union, d’autre part. Ce dernier est construit via l’affixe -ig- permettant de créer un verbe qui indique que l’on cause quelque chose, complété par la terminaison de substantif -o qui en fait une action de rendre/causer (de unir à union donc). Étant donné que -er- exprime la partie d’un tout, on peut sans trop s’avancer se passer ici de aro, et utiliser le terme unuero, unique partie d’un tout. Alternativement on pourrait utiliser solaero voir solero, seul partie d’un tout.

Implémentations[modifier | modifier le wikicode]
C++[modifier | modifier le wikicode]
Implémentation C++ du singleton et son équivalent en pseudo-code espérantophone
C++ Transcription
template<typename T> class Singleton
{
  public:
    static T& Instance()
    {
        static T theSingleInstance; // suppose que T a un constructeur par défaut
        return theSingleInstance;
    }
};

class OnlyOne : public Singleton<OnlyOne>
{
    // constructeurs/destructeur de OnlyOne accessibles au Singleton
    friend class Singleton<OnlyOne>; 
    //...définir ici le reste de l'interface
};
ŝablono<tipnomo T> klaso Solero
{
  publika:
    statika T& Instanco()
    {
        statika T solulo; // supozi ke T havas defaŭltan konstruilon
        rebatu solulo;
    }
};

klaso Unuero : publika Solero<Unuero>
{
    // konstruiloj/malkonstruiloj de Unuero ke estas solero alirebla 
    amika klaso Solero<Unuero>; 
    //...definu ĉi-tie la restan interfacon 
};
Liste du vocabulaire employé et équivalence en espéranto et français
Anglais Espéranto Français
Template Ŝablono Modèle
Python[modifier | modifier le wikicode]
Prototype[modifier | modifier le wikicode]
Fabrique[modifier | modifier le wikicode]
Fabrique abstraite[modifier | modifier le wikicode]
Monteur[modifier | modifier le wikicode]

Patrons de structure[modifier | modifier le wikicode]

Pont[modifier | modifier le wikicode]
Façade[modifier | modifier le wikicode]
Adaptateur[modifier | modifier le wikicode]
Objet composite[modifier | modifier le wikicode]
Proxy[modifier | modifier le wikicode]
Poids-mouche[modifier | modifier le wikicode]
Décorateur[modifier | modifier le wikicode]

Patrons de comportement[modifier | modifier le wikicode]

Chaîne de responsabilité[modifier | modifier le wikicode]
Commande[modifier | modifier le wikicode]
Interpréteur[modifier | modifier le wikicode]
Itérateur[modifier | modifier le wikicode]
Médiateur[modifier | modifier le wikicode]
Mémento[modifier | modifier le wikicode]
Observateur[modifier | modifier le wikicode]
État[modifier | modifier le wikicode]
Stratégie[modifier | modifier le wikicode]
Patron de méthode[modifier | modifier le wikicode]
Visiteur[modifier | modifier le wikicode]

Patrons GRASP[modifier | modifier le wikicode]

Expert en information[modifier | modifier le wikicode]

Créateur[modifier | modifier le wikicode]

Faible couplage[modifier | modifier le wikicode]

Forte cohésion[modifier | modifier le wikicode]

Contrôleur[modifier | modifier le wikicode]

Polymorphisme[modifier | modifier le wikicode]

Fabrication pure[modifier | modifier le wikicode]

Indirection[modifier | modifier le wikicode]

Protection[modifier | modifier le wikicode]

Patrons d'entreprise[modifier | modifier le wikicode]

Logique du domaine[modifier | modifier le wikicode]

Architecture de source de données[modifier | modifier le wikicode]

Comportement objet-relationnel[modifier | modifier le wikicode]

Structure objet-relationnel[modifier | modifier le wikicode]

Association méta-données objet-relationnel[modifier | modifier le wikicode]

Présentation web[modifier | modifier le wikicode]

Distribution[modifier | modifier le wikicode]

Concurrence locale (hors-ligne)[modifier | modifier le wikicode]

État de session (Session State Patterns)[modifier | modifier le wikicode]

Patrons de base[modifier | modifier le wikicode]

Passerelle (Gateway)[modifier | modifier le wikicode]
Mapper[modifier | modifier le wikicode]
Type de base pour la couche[modifier | modifier le wikicode]
Interface séparée[modifier | modifier le wikicode]
Registre[modifier | modifier le wikicode]
Plugin[modifier | modifier le wikicode]

Autres patrons[modifier | modifier le wikicode]

Type fantôme[modifier | modifier le wikicode]

Double-dispatch[modifier | modifier le wikicode]

Post-Redirect-Get[modifier | modifier le wikicode]

Map-Reduce[modifier | modifier le wikicode]

Évaluation retardée[modifier | modifier le wikicode]

Copie sur modification[modifier | modifier le wikicode]

Injection de dépendance[modifier | modifier le wikicode]

Inversion de contrôle[modifier | modifier le wikicode]

Modèle-Vue-Présentateur[modifier | modifier le wikicode]

Écart de génération[modifier | modifier le wikicode]

Objet nul[modifier | modifier le wikicode]

Humoraj algoritmoj[modifier | modifier le wikicode]

Idées pour des langages de programmation tirant partie de la régularité grammaticale et orthographique de l’espéranto[modifier | modifier le wikicode]

On peut envisager, que ce soit en tant que structure grammaticale du langage ou en tant que simple convention de nommage, utiliser les affixes suivants :

  • -j, opo, aro, ingo, ujo pour désigner différents types de collections/conteneurs ;
  • ano, ero pour désigner des éléments/membres ;
  • -ulo pour des représentants/instances d’une classe ;
  • post, antaŭ-, sekve pour désigner des successeurs/prédécesseurs ;
  • -id-, pra- désigner des des relations d’ascendance et descendance
  • mal- et ne- pour exprimer le contraire et la négation.
por(indukta ano = 1; ano < aro; poste-ano) { ano[aro]  }

L’utilisation d’itérateurs à la python permet de se passer des nombres :

por(ero in listo):

    print(ero)

Notoj kaj referencoj[modifier | modifier le wikicode]

Aliaj projektoj relate al esperantprogramlingvo[modifier | modifier le wikicode]

Ce projet n’est pas le seul à s’efforcer de faire usage de l’espéranto dans les langages de programmation. Cette section s’efforce de lister les autres projets qui se fixe ce type d’objectif :

D’autres projets de langages de programmation dans d’autre langues que l'anglais :

Pri la esperanta efikado[modifier | modifier le wikicode]

Laŭdanta kritiko[modifier | modifier le wikicode]

Malaŭdanta kritiko[modifier | modifier le wikicode]

Esperanto kaj programado[modifier | modifier le wikicode]

Esperanto kaj lingvistiko[modifier | modifier le wikicode]

Esperanto kaj matematiko[modifier | modifier le wikicode]

Pri esperanta gamatiko[modifier | modifier le wikicode]

Relate tradukiloj[modifier | modifier le wikicode]

Pri esperanta scienca kaj universitata uzado[modifier | modifier le wikicode]

Pri programado[modifier | modifier le wikicode]

Pri algoritmoj[modifier | modifier le wikicode]

Pri designaĵa patroneo/skemo[modifier | modifier le wikicode]

Pri MMIX[modifier | modifier le wikicode]

  1. http://www-cs-faculty.stanford.edu/~knuth/fasc1.ps.gz

Vortaroj[modifier | modifier le wikicode]

Nefaka:

Fakaj pri komputilo:

Pri programlingvoj gramaroj[modifier | modifier le wikicode]

Pri nek angla kaj nek esperanta programlinvoj[modifier | modifier le wikicode]


Memverkistaj verkoj pri la sama subjekto[modifier | modifier le wikicode]

Notoj[modifier | modifier le wikicode]

  1. All accesses to 2t -byte quantities by MMIX are aligned, in the sense that the first byte is a multiple of 2t.
  2. D’après le Komputada Leksikono
  3. 3,0 et 3,1 La "Bluaj Pagxoj" de Esperanto propose grandkomenca et etkomenca, tandis que Komputada Leksikono donne pezkomenca et pezfina, respectivement pour big-endian et little-endian. Ici on remplace simplement la racine komenca par eka, tiré du préfixe ek- qui indique le commencement.
  4. Le PIV donne comme [http://vortaro.net/#indiki définition de indiki « Precize liveri al iu la bezonatan sciigon ».
  5. Terminologie Unicode français - anglais
  6. 6,0 et 6,1 Du préfixe d’origine sanskrit ashta-, huit, qu'on retrouve dans [[w:ashtanga|]].
  7. Rappelons que bit viens de la contraction de l’anglais binary digit, nombre binaire.

Pri aliaj temoj aŭ ne ordaj hiperligoj[modifier | modifier le wikicode]

  • Komputada leksikono
  • Le dernier axe comprendra donc des algorithmes qui intéresseront les auteurs, tout simplement. Au passage, nous rappelons que ce projet est hébergé sur un wiki, chacun est libre d’y contribuer.
  • MATEMATIKA VORTARO
  • Porteur de nombre
  • Élément de nombre
  • À l’instar du vocabulaire linguistique (sème, rhème), terminaison en -ème désignant une unité le l’élément suffixé
  • 3/8ième d’octet
  • 5/8ième d’octet
  • 6/8=2×3/2×4=3/4ième d’octet
  • 7/8ième d’octet
  • 9/8ième d’octet
  • 10/8=5/4ième d’octet
  • D’un point de vu sémantique, préfixer de signum- et sensignum- les opérateurs manipulant des nombres avec ou sans signe serait préférable. Tout de fois, même en omettant le préfixe le plus long et en prenant la convention inverse de MMIX, à savoir que sans précision on suppose un opérateur signé, signumokumŝargu est un peu long par rapport à ce qu’on pourrait attendre d’un mot clé. On se propose d’utiliser le préfixe ge-, qui indique la réunion des genres, pour désigner les nombres signés qui comprennent aussi bien des positifs que des négatifs.
  • Ici on verbalise les conjonctions de coordination.
  • Voir espéranto l’article wikipedia sur kaŭu.
  • Voir l’entrée plekti du PIV
  • On pourrait utiliser un mot comme adicinenulnombru, adici-ne-nul-nombru, compter les non-nuls de l’addition, si on souhaitais privilégier la précision sur la concision.
  • Komputada leksikono propose eliri. Il propose cependant la même traduction pour exit, qui n’est pas un mot clé du C, mais fait partie de la bibliothèque standard où il définie une fonction pour interrompre l’exécution du processus. Un mot plus précis et approprié pour décrire l’instruction break pourrait être internkontrolsaltu (intern•kontrol•saltu). Mais il s’agirait d'un équivalent un peu long…
  • Le Komputada leksikono propose signo comme traduction de character. On pourrait également partir de kodono qui traduit un codet : un groupe d'éléments représentant, selon un code, une donnée élémentaire. En effet par défaut un char à une taille de un multiplet (byte en anglais), qui correspond généralement à un octet sur les machines modernes, soit huit bits.
  • On pourrait également utiliser konstanta, neŝanĝiĝema ou neŝanĝebla. Ici c’est l’alternative non apocopée la plus courte qui a été retenue.
  • Ici on pourrait également proposer pluiri. On garde ici la notion de saut qui fait écho à celles des traductions retenues pour les mots clés break et goto.
  • what ever happened to the 'entry' keyword?
  • On pourrait également utiliser liveru, mais on réservera plutôt ce mot comme traduction pour yield, bien que ce mot ne fasse pas partie du C. D’autres candidats sont possibles comme resendi et transsendi, mais on préférera sans doute réserver ces mots pour des fonctions de communication réseaux/interprocessus.
  • En espéranto l’usage semble préféré vakuo pour traduire « le vide », et vaki pour « être vacant ». Aussi vako semble plutôt traduire objet vacant. Par exemple dans le poème dankemo de Mao Zifu on lit « vakuo estas vako ».
  • Software Language Processing Suite Grammar Zoo
  • Kiel traduki "design pattern" ?