Recherche:Algoritmaro

Algoritmaro kaj algoritmleksemaro

Département de recherche en linguistique

---

Toute réaction ou commentaire par rapport à ce travail de recherche sont les bienvenus sur cette page de discussion.

---

Cette page fait partie de l’espace recherche de Wikiversité et dépend de la faculté linguistique. Pour plus d'informations, consultez le portail de l'espace recherche ou rendez-vous sur l'index des travaux de recherche par faculté.

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.

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.

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.

Structure des langages

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

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
logf(o) = r

MMIX

Vocabulaire général lié aux discours sur les assembleurs

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.

Description d’architecture matérielle

Vocabulaire utilisé pour nommer les différentes représentations numériques

Nom anglais	Nom espéranto	Nom français
alignement (mémoire)	ĝisrandigo	alignement
big-endian	pezeka	petit-boutisme
little-endian	eteka	gros-boutisme

Représentations des nombres

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 : $11110001_{2}$ en binaire, 241 en décimal, f1₁₆ en hexadécimal.

Références aux cellules mémoires

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 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 $M_{2^{t}}[k]$ qui permet désigner le nombre codé sur les $2^{t}$ 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) ($M[k]=M_{2^{64}}[k]$). 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

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, arithmostœchion, nombre unaire
2	bit	duumo	bito	duet	tétracho-octet	bit, binet, binème, quaternoctet, quaternet, nombre binaire
3		triumo		ternet	trisoctacho-octet
4	nybble	kvarumo	kvaropo, bajtduono	quadret	hémi-octet	semi-octet, demi-octet
5		kvinumo		quintet	pentakisoctacho-octet
6		sesumo		sénet	tristétracho-octet
7		sepumo		septet	heptakisoctacho-octet
8	byte	okumo	okopo, bajto, bitoko, duumokopo	octet
9		naŭumo		nonet	ennéakisoctacho-octet
10		dekumo		dénet	pentakistétracho-octet
16	wyde	(okum)duopo	duopokopo, dek-sesopo, okopduoblo, bajtduoblo	seizet	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)

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 ils 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. 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 (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

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

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

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	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

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

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

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
OR $X,$Y,$Z|Z	bitwise or	kaŭu
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
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
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

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

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

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

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

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

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

Mots clés réservés

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*	Entraîne un saut hors de l’actuelle plus profonde structure de contrôle.
case	kas*	Voir switch
char	sign*	Déclare une variable et lui associe le type correspondant à un code caractère.
const	senĉes*	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*	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.
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*	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*
volatile	variem*
while	dum

Utilisation des mots clés et variations grammaticales espérantistes

Déclaration d’une fonction

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

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

Déclaration de variable

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

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

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

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

Hello World et Saluton Mondo

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);
}

Les lexèmes des bibliothèques standards

Les patrons de conception

desegmodelo.

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 »

Patrons de création

Singleton

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

C++

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

Idées pour des langages de programmation tirant partie de la régularité grammaticale et orthographique de l’espéranto

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

Aliaj projektoj relate al esperantprogramlingvo

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 :

• glano
  • https://twitter.com/glano
  • http://www.glano.org/index.html
  • http://glano.wordpress.com/dokumentado/baza-priskribo/
• Simpla - Esperanta Programlingvo
  • Esperanta Programlingvo - First try
  • Programi : Esperante aŭ angle?
• Recherche des projets avec le mot clé esperanto sur gitorious
• Recherche des projets avec le mot clé esperanto sur github
• Nova projekto: Programlingvo tute en Esperanto - Google Groupes
• Katalogo de Esperanta retenhavo/Programoj kaj programado
• analizilo : Esploro pri analizo de Esperanto per komputilo
  • http://analizilo.org
  • http://analizilo.org/javadoc/analizilo/index.html?org/analizilo/motoro/package-summary.html
• Kurso de Esperanto, propose un logiciel d'apprentissage de l'espéranto, codé en C++ avec le code spécifique au projet rédigé en espéranto (pas les mots clés, pas les appels aux bibliothèques)

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

• https://code.google.com/p/zhpy/
• http://www.reganmian.net/blog/2008/11/21/chinese-python-translating-a-programming-language/
• Lingua::Romana::Perligata -- Perl for the XXI-imum Century un module Perl qui permet d'écrire du code en Latin interprétable par la machine virtuel Perl
  • À noter que l’en:Arcaicam Esperantom (fictio-rétro-)introduit le datif avec la terminaison -d, ce qui permettrait de calquer assez simplement le principe de cet implémentation Perligadata

Pri la esperanta efikado

Laŭdanta kritiko

• French business would use Esperanto but
• The language challenge -- facing up to reality

Malaŭdanta kritiko

• Chomsky: 'Esperanto ne estas lingvo'
  • Fadano pri "Chomsky: 'Esperanto ne estas lingvo'"
  • mem fadano
  • Relata vikipedio artikolo
  • Noam Chomsky on Esperanto got completely wrong

Esperanto kaj programado

• (eo) praktikaj informaj pri esperanto por programistoj

Esperanto kaj lingvistiko

• Artificial Languages. Themes in Linguistics and Philosophy
• Prolog and Natural-Language Analysis (in esperanto)
• Silabo kaj silabado

Esperanto kaj matematiko

• MATEMATIKA VORTARO KAJ OKLINGVA LEKSIKONO

Pri esperanta gamatiko

• Esperanto grammar ...
• (en) THE ACCUSATIVE IN ESPERANTO Gaston Waringhien traduit par Don HARLOW
• (en) The Sixteen Rules of Esperanto Grammar
• (en) Parsing and evaluating vortfarado

Relate tradukiloj

• La modélisation mathématique des langues naturelles
• Aŭtomatika Tradukado el Esperanto en la Ĉinan kaj Anglan Lingvojn - Liwei
• DLT - faktoj pri finita projekto
• WikiTrans kiu liveri maŝintradukitajn anglajn vikepediajn artikolojn al esperanto inter alie.

Pri esperanta scienca kaj universitata uzado

• Akademio Internacia de la Sciencoj (AIS) San-Marino
  • w:eo:AIS
• Filozofio kaj Historio de Informadiko
  • Per vimeo
• Inkoj: filozofio kaj artfaritaj lingvoj
  • La neebleco de priesperanta lingvoscienco
• en:Conference on the Application of Esperanto in Science and Technology

Pri programado

Pri algoritmoj

• (en) Algorithm Implementation
• Implémentation d'algorithmes classiques

Pri designaĵa patroneo/skemo

• Patrons de conception
• (en) Implémentations Java de Design Patterns

Pri MMIX

• (en) MMIX 2009 a RISC computer for the third millennium

Vortaroj

Nefaka:

• Plena Ilustrita Vortaro de Esperanto
• La vortaro, dekstrflanke konsultebla

Fakaj pri komputilo:

• (en)Komputada leksikono
• Komputeko : Prikomputila terminokolekto
• Terminologiaj kaj leksikografaj materialoj de Esperanto

Pri programlingvoj gramaroj

• (en) Free Programming Language Grammars for Compiler Construction
• Hyperlinked C++ BNF Grammar
• (en) Python Full Grammar specification

Pri nek angla kaj nek esperanta programlinvoj

• (en) Lingua::Romana::Perligata -- Perl for the XXI-imum Century, Damian Conway

Memverkistaj verkoj pri la sama subjekto

• (fr) Exprimer des appels de fonction imbriqués sans ambiguïté en espéranto
• (fr) Et vous, à votre avis, par où commencer une quête pour une chaîne de compilation espérantophone ?
• (en) Which langages let you use fully customised lexems, including keywords and all symbol defined in their grammar?
• (fr) Recherche une description BNF du C, C++, Python et autres, sous licence libre

Pri aliaj temoj aŭ ne ordaj hiperligoj

• eo:Eckhard Bick kaj en:Eckhard Bick