Le topic de la programmation: Et envoyez des sioux!

**Nilsou** · 27/09/2018, 01h46

Nan mais j'alloue la structure mon_bidule_a avant si nécessaire, quitte à laisser des membres vide ou inutile dans mon_bidule, donc les mallocs sont déjà fait. Ça ne me gêne pas plus que ça. (la structure "mon bidule" est déjà grosse et n'est pas appelé séquentiellement en dehors de ces quelques membres "a", "b" etc...)

Et c'est du C malheureusement ...
Évidemment une solution "macro" serait l'idéale, mais j'ai l'impression que c'est beaucoup en demander au pre-compilo.

Je suis assez étonné qu'il n'existe pas un éventuel mot clé pour faire ceci, ça semble pourtant un jeu d'enfant pour le compilo...

Enfin bon, si quelqu'un a une solution élégante à ce type de soucis, je prends.

**William Vaurien** · 27/09/2018, 09h59

Toujours est-il que démarrer à 0 a du sens sur un langage bas niveau car cela reflète (vaguement) l'organisation interne de mémoire. (Vaguement, parce-que c'est pas si simple apparemment.)

Maintenant dans un langage plus 'haut niveau' ça n'a plus beaucoup de sens. Sur mon exemple Java, faire un maListe.get(0) reste absurde car nous demandons le premier élément d'une série d'éléments indexés sans nous préoccuper de savoir si c'est l'index indique une adresse dans une série de zone contiguë en mémoire ou non. (ArrayList vs LinkedList).

Donc la convention de l'index du premier élément est un héritage, une habitude. Le fait que certains langages ne l'utilisent pas est un peu problématique car peut occasionner des bugs à la con.

Par exemple en SQL et par extension JDBC les index commencent à 1 également, donc configurer le premier paramètre d'une requête s'écrit:
- updateSales.setInt(1, e.getValue().intValue());
Et lire la valeur de première colonne de la première ligne:
- String coffeeName = rs.getString(1);

(c'est pas recommandé du tout d'écrire du JDBC comme ça, mais bon les débutants le font souvent un jour ou l'autre)

https://en.wikipedia.org/wiki/Compar...guages_(array)

**Tramb** · 27/09/2018, 10h15

Comme disait Ducon, les suites sont indexées à 0 en maths.

C'est de toute façon une non-problématique : Quand est-ce qu'on met un immédiate pour un accès de tableau, finalement ?

**newbie06** · 27/09/2018, 10h15

Envoyé par Nilsou

je ne sais pas si je suis clair. Mais à priori, qu'est ce qui empêche le compilo de faire ce genre de boulot ? Je veut dire, ça n'a pas l'air si difficile que ça ...

Certains compilos font le changement AoS <-> SoA, mais il faut vraiment des conditions particulières genre j'ai détecté libquantum

Y'a eu des études mais je ne sais pas si ça a fini en prod. Par exemple : https://llvm.org/devmtg/2014-10/Slid...shanth-DLO.pdf

**Tramb** · 27/09/2018, 10h23

Envoyé par newbie06

Certains compilos font le changement AoS <-> SoA, mais il faut vraiment des conditions particulières genre j'ai détecté libquantum

Y'a eu des études mais je ne sais pas si ça a fini en prod. Par exemple : https://llvm.org/devmtg/2014-10/Slid...shanth-DLO.pdf

Le problème c'est la lifetime et la cohérence spatiale, il faut de nouveaux langages pour ça.
Beaucoup de gens espèrent faire des new Struct individuelles et obtenir du SoA en sortie, ça viole trop d'invariants des langages courants.

**Møgluglu** · 27/09/2018, 11h01

Envoyé par Nilsou

D'ailleurs c'est quoi la raison logique qui a fait abandonner le ternaire ? J'imagine qu'il y avais une histoire de fiabilité des processeur sur des pas plus petit vis à vis du bruit, mais aujourd'hui cet argument est-il encore valable ? J'imagine qu'on pourrait tout à fait pondre des systèmes mathématique qui fonctionne avec 4 paliers et de pondre les puces qui vont bien. En plus avec 4 pallier c'est toujours possible d'imaginer une compatibilité avec le binaire.

C'est probablement une raison techno, à partir du moment où on a commencé à vouloir construire des machines avec des transistors.

Il y a des devises Shadok qu'on apprend dans tous les cours et les bouquins d'électronique numérique du genre « On arrive souvent à monter plus bas en descendant un transistor PMOS prévu pour la montée qu'on ne serait descendu haut en remontant un transistor NMOS prévu pour la descente. » et « C'est pour ça que les transistors PMOS qui vivent en haut de la porte logique doivent être collectivement aussi lourds que les transistors NMOS qui vivent en bas et ne pas se mettre tous du même côté pour ne pas tomber. » Ou quelque chose comme ça.

Du coup, tant que tu mets tes transistors dans le bon sens, tu peux faire de la logique PMOS entre -15V et 0V (années 1960), ou du NMOS entre 0V et 5V (années 1980), ou du CMOS entre 0V et 1V (années 2000).
Mais 3 niveaux c'est pénible pour la logique, ne serait-ce que parce que passer de -1 à +1 demande plus d'énergie que passer de -1 à 0.

Pour le stockage magnétique ou flash par contre, on a déjà plus de 2 paliers. Et avoir des portes logiques binaires n'empêche pas de construire de la logique en base supérieure par dessus, par exemple les multiplieurs utilisent un système redondant avec des chiffres entre -2 et +2.

Pour ton problème de threads, tu va devoir commencer à faire du profiling pour déterminer d'où vient le problème.

**brundleti** · 27/09/2018, 12h05

Envoyé par William Vaurien

Toujours est-il que démarrer à 0 a du sens sur un langage bas niveau car cela reflète (vaguement) l'organisation interne de mémoire. (Vaguement, parce-que c'est pas si simple apparemment.)

Maintenant dans un langage plus 'haut niveau' ça n'a plus beaucoup de sens. Sur mon exemple Java, faire un maListe.get(0) reste absurde car nous demandons le premier élément d'une série d'éléments indexés sans nous préoccuper de savoir si c'est l'index indique une adresse dans une série de zone contiguë en mémoire ou non. (ArrayList vs LinkedList).

Donc la convention de l'index du premier élément est un héritage, une habitude. Le fait que certains langages ne l'utilisent pas est un peu problématique car peut occasionner des bugs à la con.

Par exemple en SQL et par extension JDBC les index commencent à 1 également, donc configurer le premier paramètre d'une requête s'écrit:
- updateSales.setInt(1, e.getValue().intValue());
Et lire la valeur de première colonne de la première ligne:
- String coffeeName = rs.getString(1);

(c'est pas recommandé du tout d'écrire du JDBC comme ça, mais bon les débutants le font souvent un jour ou l'autre)

https://en.wikipedia.org/wiki/Compar...guages_(array)

En Fortran 90+ , pour éviter ce genre de discussion 0 ou 1, on peut directement préciser (voir par exemple p. 73 de cette doc http://www.idris.fr/media/formations...ance_cours.pdf)des tableaux avec des indices négatifs (qui ne marchent pas comme en python !). Problem solved ! Les entiers naturels pour indexer les tableaux c'est pour les lows

Comme on dit a l’Académie Française, " les réels programmateurs utilisent Fortran"

Bon, par contre, je ne sais pas a quoi ils turbinent dans les comites de normalisation Fortran, mais c'est puissant

Dernièrement, il y avait tout un fil de commentaires sur LWNhttps://lwn.net/Articles/763626/ a ce sujet dans le language Julia. Il y avait notamment un lien sur un (court) texte de Dijkstra sur pourquoi 0 est "meilleur" : https://www.cs.utexas.edu/users/EWD/...xx/EWD831.html

**Shosuro Phil** · 27/09/2018, 12h27

Envoyé par Tramb

Comme disait Ducon, les suites sont indexées à 0 en maths.

C'est une convention qui en vaut une autre, et qui complique le discours oral (au lieu lieu de dire "le 12e terme de la suite", il faut, si on veut être propre, dire "le terme d'indice 12 de la suite", pour désigner u_{12}). Résultat, dans certaines situations, on a envie de commencer à 1, aussi.

Et inversement, y'a plein de situations où avoir un indice 0 simplifie les écritures. C'est plus simple d'exprimer le terme général d'une suite arithmétique ou géométrique en fonction du terme d'indice 0 (u_n = u_0 + n.r, c'est plus simple que u_n = u_1 + (n-1).r).

Résultat, les matheux indicent la plupart de leurs suites à partir de 0, mais la plupart de leurs matrices à partir de 1. Les physiciens, eux, indicent leurs matrices par les entiers relatifs ou les réels ou je ne sais quoi, ça leur pose pas de problème

Bref, tout ça c'est de la gymnastique mentale, pas grand-chose de plus. Rien n'empêche, en C, d'avoir des tableaux indexés à partir de 1, il suffit de décrémenter l'adresse récupérée

(à éviter avec les langages qui surveillent la gestion mémoire, par contre)

**Tramb** · 27/09/2018, 12h34

Tu dis souvent douzième en maths ?
Moi je dis premier, second, et plus souvent tu utilises les indices u_zéro, u_un.

**TiNitro** · 27/09/2018, 13h05

Je comprends pas pourquoi c'est un débat en fait.
On te dit ça commence à 1, ben tu commences à un, si c'est zéro tu commences à zéro. Ça n'a de toutes façons aucune signification autre que "élément initial", et on a effectivement de moins en moins besoin d'y faire référence avec les opérateurs modernes donc bon...

@Mogluglu: merci pour l'historique, j'ai bien aimé !

**William Vaurien** · 27/09/2018, 13h54

Envoyé par TiNitro

Je comprends pas pourquoi c'est un débat en fait.
On te dit ça commence à 1, ben tu commences à un, si c'est zéro tu commences à zéro. Ça n'a de toutes façons aucune signification autre que "élément initial", et on a effectivement de moins en moins besoin d'y faire référence avec les opérateurs modernes donc bon...

Tu peux aller faire un tour ici: c'est une petite 'guerre de chapelle' assez commune:

Envoyé par brundleti

Dernièrement, il y avait tout un fil de commentaires sur LWNhttps://lwn.net/Articles/763626/ a ce sujet dans le language Julia.

Je défendais le pauvre windev qui n'est déjà pas aidé à la base. Pour ma part je me suis habitué au indice démarrant à 0, mais ça ne me choque pas qu'un langage propose de partir à 1... (par contre il faut pas trop mélanger les 2 styles en même temps

)

**Møgluglu** · 27/09/2018, 14h05

De toute façon, dans les vrais langages comme Ada ou VHDL, on spécifie les bornes inf et sup du tableau, et l'ordre des éléments. Ou bien on indexe avec n'importe quelle énumération munie d'un ordre total :

Code:

type Vecteur is array (-40 to 40) of Integer;

signal autobus : std_logic_vector(31 downto 0);

type Atout is (Valet, Neuf, As, Dix, Roi, Dame, Huit, Sept);

type Main is array (Atout) of Boolean;

**Lazyjoe** · 27/09/2018, 14h27

Argument en faveur du 0 : quand on définit l'évaluation de fin de boucle on va faire un test de la forme "i < longueur"

Si on commence à 1 il faut faire un test "i <= longueur" ce qui est plus long à calculer !

**William Vaurien** · 27/09/2018, 14h29

- - - Mise à jour - - -

Envoyé par Lazyjoe

Argument en faveur du 0 : quand on définit l'évaluation de fin de boucle on va faire un test de la forme "i < longueur"

Si on commence à 1 il faut faire un test "i <= longueur" ce qui est plus long à calculer !

Par contre pour accéder au dernier élément tu n'as pas besoin de faire toto = data[datasize-1]

Tous les arguments sont dans les commentaires du lien sur Julia envoyé @brundleti...

**Møgluglu** · 27/09/2018, 14h50

Envoyé par Lazyjoe

Argument en faveur du 0 : quand on définit l'évaluation de fin de boucle on va faire un test de la forme "i < longueur"

Si on commence à 1 il faut faire un test "i <= longueur" ce qui est plus long à calculer !

Bah ouais, le processeur doit faire le < et le =, ça lui fait plus de boulot.

Mais pourquoi commencer à zéro quand on peut finir à un :

Code:

for(int i = longueur; i > 0; --i)

Sérieusement, la plupart des arguments confondent le concept de donnée abstraite et celui de son encodage. C'est pas parce qu'on appelle les éléments un deux trois quatre qu'on va forcément envoyer les bits 0001, 0010, 0011 et 0100 sur le bus d'adresse pour y accéder.

Au fait, il manque le numéro de version du topic dans le titre.

**Tramb** · 27/09/2018, 14h53

Envoyé par William Vaurien

Par contre pour accéder au dernier élément tu n'as pas besoin de faire toto = data[datasize-1]

De toute façon tu y accèdes au fin fond d'une récursion, ou dans une fonction d'ordre supérieur, à la limite avec last/end/back. Pourquoi répéter datasize ?

**Helix** · 27/09/2018, 15h28

Envoyé par Møgluglu

Au fait, il manque le numéro de version du topic dans le titre.

La première version était 0 ou 1 ?

**Nilsou** · 27/09/2018, 16h22

Envoyé par Møgluglu

C'est probablement une raison techno, à partir du moment où on a commencé à vouloir construire des machines avec des transistors.

Il y a des devises Shadok qu'on apprend dans tous les cours et les bouquins d'électronique numérique du genre « On arrive souvent à monter plus bas en descendant un transistor PMOS prévu pour la montée qu'on ne serait descendu haut en remontant un transistor NMOS prévu pour la descente. » et « C'est pour ça que les transistors PMOS qui vivent en haut de la porte logique doivent être collectivement aussi lourds que les transistors NMOS qui vivent en bas et ne pas se mettre tous du même côté pour ne pas tomber. » Ou quelque chose comme ça.

Du coup, tant que tu mets tes transistors dans le bon sens, tu peux faire de la logique PMOS entre -15V et 0V (années 1960), ou du NMOS entre 0V et 5V (années 1980), ou du CMOS entre 0V et 1V (années 2000).
Mais 3 niveaux c'est pénible pour la logique, ne serait-ce que parce que passer de -1 à +1 demande plus d'énergie que passer de -1 à 0.

Pour le stockage magnétique ou flash par contre, on a déjà plus de 2 paliers. Et avoir des portes logiques binaires n'empêche pas de construire de la logique en base supérieure par dessus, par exemple les multiplieurs utilisent un système redondant avec des chiffres entre -2 et +2.

Mais qu'est ce qui t’empêche de passer du 0 au 2.5V puis au 5V par exemple ?
Avec un pallier au milieu. Alors oui tu a besoin d'un pallier intermédiaire relou à gérer. Et ta résistance au bruit s'effondre. Néanmoins sur des archis moderne, je vois mal le soucis au niveau du matos. Et énergétiquement tu a bien un passage qui coûte plus cher, mais c'était le passage employé pour le binaire. Donc en pratique tu consomme moins non ? Vu qu'au lieu de faire des transitions 0->5 tu a pleins de 5->2.5 2.5->5 0->2.5 etc...

Envoyé par Møgluglu

Pour ton problème de threads, tu va devoir commencer à faire du profiling pour déterminer d'où vient le problème.

Bvoui bvoui, c'est prévu

- - - Mise à jour - - -

Envoyé par Helix

La première version était 0 ou 1 ?

10/10

**ducon** · 27/09/2018, 17h00

En binaire ?

**Tramb** · 27/09/2018, 17h01

En code Gray ?

**Møgluglu** · 27/09/2018, 17h13

Envoyé par Nilsou

Mais qu'est ce qui t’empêche de passer du 0 au 2.5V puis au 5V par exemple ?
Avec un pallier au milieu. Alors oui tu a besoin d'un pallier intermédiaire relou à gérer. Et ta résistance au bruit s'effondre. Néanmoins sur des archis moderne, je vois mal le soucis au niveau du matos. Et énergétiquement tu a bien un passage qui coûte plus cher, mais c'était le passage employé pour le binaire. Donc en pratique tu consomme moins non ? Vu qu'au lieu de faire des transitions 0->5 tu a pleins de 5->2.5 2.5->5 0->2.5 etc...

Si tu as assez de marge de bruit pour ça, alors tu peux faire du binaire entre 0 et 2,5V et aller plus vite.

Le souci pour de la techno CMOS, c'est que tu n'as que 2 types de transistors : les p et les n. Comme chez les Shadoks, il y a les p qui servent à "monter à 1" et les n qui servent à "descendre à 0".
Pour dessiner une porte logique :
- tu pars d'un fil à 1 en haut et un fil à 0 en bas,
- tu dessines la sortie au milieu,
- tu dessines un réseau de transistors p entre la sortie et le 1 en haut qui sert à tirer la sortie vers le haut,
- tu dessines un réseau de transistors n en bas,
- tu dimensionnes tes transistors pour que le temps de montée soit égal au temps de descente.
Par exemple pour une porte NAND :

... pardon, mauvaise image :

Si tu généralises ça à du ternaire avec une troisième tension, quel type de transistor vas-tu utiliser pour atteindre la tension intermédiaire ? Dans les deux cas, tu vas te retrouver soit à monter avec des transistors n, soit à descendre avec des transistors p, et c'est mal. Ou alors tu mets les deux à la fois en parallèle, mais alors tu doubles ta capacitance d'entrée. Au total tu as multiplié la surface et la capacitance par 3 au moins pour avoir juste un état en plus. Autant coder tes 3 états sur 2 bits et utiliser des portes logiques binaires.

Au moins sur les technos de semiconducteurs silicium. Sur d'autres technos plus exotiques du genre qubits supraconducteurs, les paris sont ouverts (mais on en reparlera quand on maitrisera déjà le binaire).

10/10

Jelb.

**Shosuro Phil** · 27/09/2018, 20h15

Envoyé par Tramb

Tu dis souvent douzième en maths ?
Moi je dis premier, second, et plus souvent tu utilises les indices u_zéro, u_un.

Bah j'ai souvent envie de dire que je regarde le n-ème élément, et résultat, il faut s'assurer que l'interlocuteur a bien compris si je parlais de celui d'indice n-1, ou, par abus de langage, de celui d'indice n.

**Nilsou** · 27/09/2018, 20h59

Envoyé par Møgluglu

Si tu as assez de marge de bruit pour ça, alors tu peux faire du binaire entre 0 et 2,5V et aller plus vite.

Le souci pour de la techno CMOS, c'est que tu n'as que 2 types de transistors : les p et les n. Comme chez les Shadoks, il y a les p qui servent à "monter à 1" et les n qui servent à "descendre à 0".
Pour dessiner une porte logique :
- tu pars d'un fil à 1 en haut et un fil à 0 en bas,
- tu dessines la sortie au milieu,
- tu dessines un réseau de transistors p entre la sortie et le 1 en haut qui sert à tirer la sortie vers le haut,
- tu dessines un réseau de transistors n en bas,
- tu dimensionnes tes transistors pour que le temps de montée soit égal au temps de descente.
Par exemple pour une porte NAND :
http://i.skyrock.net/8540/19968540/pics/568809728.jpg

... pardon, mauvaise image :
https://upload.wikimedia.org/wikiped...S_NAND.svg.png

Je ne me souviens plus trop des détails technologiques entre les CMOS les NMOS et les PMOS... c'est ça quand on commence à bosser dans un domaine qui n'a pas de rapport pendant trop longtemps

Néanmoins je me doute bien que le schéma de la porte NAND classique est caduque sur les transistors à effets de champs, si on souhaite introduire un nouvel état.

Par contre avec d'autres type de transistor c'est plus simple non ? Genre un bipolaire ? Tu l'utilise dans son domaine analogique et pouf. Mais j'imagine que si ils ne le font pas c'est qu'il y a une raison (ça doit sacrement chauffer notamment pour maintenir un "demi état" ...)

**Tramb** · 27/09/2018, 21h21

Envoyé par Shosuro Phil

Bah j'ai souvent envie de dire que je regarde le n-ème élément, et résultat, il faut s'assurer que l'interlocuteur a bien compris si je parlais de celui d'indice n-1, ou, par abus de langage, de celui d'indice n.

Mais ce "n" est souvent issu d'une query (donc on s'en fout que ce soit basé 0, 1 ou 17) ou sert à itérer (et donc tu les fais sur une slice que tu as query et on revient au même, soit sur l'intégralité et n disparaît).
Encore une fois, je pense qu'il n'y a que pour les indices immediate que ça pose problème, et donc que ce n'est pas un problème dans du vrai bon code maintenable.

**William Vaurien** · 27/09/2018, 21h37

C'est pas un problème, mais en même temps il faut que ce soit 0 le premier indice ?

**Tramb** · 27/09/2018, 22h06

Bah ça donne des opportunités d'optimisation sur le hard, toutes autres choses étant égales.
Donc ouais.
Et si tu commences à 1, dans un entier de n bits, tu indexes un élément de moins. Pourquoi se taper ce coût débile ?
Ou alors il te faut abandonner l'indexation par un entier, et ne vouloir qu'un type itérateur. Bref pouah.

Après comme dit Moglu, dès 1983 il y avait un langage qui te laissait définir les bornes de tes tableaux et qui définissait le comportement de taper en dehors.

**TiNitro** · 27/09/2018, 22h38

Envoyé par Møgluglu

De toute façon, dans les vrais langages comme Ada ou VHDL, on spécifie les bornes inf et sup du tableau, et l'ordre des éléments.

Ou Pascal d'ailleurs. J'avais failli le préciser mais comme je ne trouve pas ça méga important

**William Vaurien** · 27/09/2018, 22h41

Non, mais encore une fois je m'en tape. Je suis habitué à commencé un tableau à l'indice 0, et effectivement je ne code plus beaucoup d'accès via index, ou alors c'est mon IDE qui le fait à ma place.
Par contre c'est drôle de voir comment ça part en bisbille dès que la boite du sujet est ouverte

En plus celui là il n'avait pas encore fait trop parler de lui entre un emacs vs vi, IDE vs vi et autre tab vs space !

**Tramb** · 27/09/2018, 22h44

Envoyé par TiNitro

Ou Pascal d'ailleurs. J'avais failli le préciser mais comme je ne trouve pas ça méga important

Ah mais oui t'as raison, je pensais que c'était postérieur au Pascal de Wirth ! Merci pour la correction

- - - Mise à jour - - -

Envoyé par William Vaurien

Non, mais encore une fois je m'en tape. Je suis habitué à commencé un tableau à l'indice 0, et effectivement je ne code plus beaucoup d'accès via index, ou alors c'est mon IDE qui le fait à ma place.
Par contre c'est drôle de voir comment ça part en bisbille dès que la boite du sujet est ouverte

En plus celui là il n'avait pas encore fait trop parler de lui entre un emacs vs vi, IDE vs vi et autre tab vs space !

Que veux-tu, quand je lis que le SIDA se transmet par imposition des mains, ou qu'il n'y a pas d'intérêt à indexer à 0, je me sens obligé de corriger.
J'espère que tu vois la différence avec vi vs emacs

(Cependant, scientifiquement, Emacs est mieux, c'est prouvé)

**William Vaurien** · 27/09/2018, 23h52

Je te laisse avec tes comparaisons douteuses...

Discussion: Le topic de la programmation: Et envoyez des sioux!

Outils de la discussion

Règles de messages