Bonjour/Bonsoir à tous

J'ai eu il n'y a pas longtemps la chance d'assister à une conférence donnée dans mon lycée par Jean-Francois COLONNA (lien).

Il a entre autre expliqué que sur certains calculs simples, un ordinateur peut se tromper de façon totalement absurde en sortant des résultats très lointains de ce que l'on attend.

Voir la correspondance

Voici par ailleurs un lien venant du SDZ

Le principal reproche adressé par Backus à la programmation impérative est le fait qu'elle repose sur des changements d'état (changement de la valeur des variables, par exemple), qui ont tendance à rendre le programme rapidement imprévisible (comme les fonctions déjà exécutées peuvent affecter les fonctions à venir (si les deux utilisent les mêmes variables), des bugs très étranges peuvent apparaître), et à empêcher de raisonner formellement sur les programmes. On dit des opérations de changement d'état qu'elles provoquent des "effets de bord" (parce qu'elles peuvent provoquer un changement inattendu de comportement du reste du programme).

Voici un petit exemple, très simple : le but du code est d'afficher 10 fois un compte à rebours de 10 à 0. On a donc écrit une fonction "rebours" qui affiche un compte à rebours, et on l'appelle 10 fois dans la fonction "main" à l'aide d'une boucle for.

Code : C
#include <stdio.h>
int i;
void rebours(int);

void rebours(int start)
{
        for (i = start; i > 0; i--)
                printf("%d.. ", i);
        printf("0 !\n" );
}

int main(void)
{
        for (i = 0; i < 10; i++)
                rebours(10);
        return 0;
}

Ce code contient en fait une erreur. Si vous ne la voyez pas, essayez de le tester chez vous et de comprendre ce qui pose problème. Cette erreur est directement liée au "style de Von Neumann", car elle repose précisément sur les changements de valeur des variables manipulées. C'est évidemment une erreur très grossière que des programmeurs expérimentés ne feront jamais, mais il en existe d'autres, bien plus complexes, qui sont la cause d'une partie des bugs des logiciels que vous utilisez tous les jours.

J'avoue ne pas avoir clairement compris les raisons, mais surtout je ne comprends pas pourquoi, étant donné la simplicité programmes comportant des erreurs, ça ne soit jamais ou rarement arrivé à des programmeurs du dimanche que nous sommes beaucoup à être .

J'ouvre le débat

En langage binaire...
Je pense que oui moi.

Pourrais-tu développer un peu plus ta réponse? Car personnellement, je m'y connais un peu en informatique mais  ta réponse ne m'éclaire pas beaucoup. Et je pense que je ne suis pas le seul. Ca serait sympathique si tu pouvais développer un peu ton idée.

Merci!

(Alarkia, c'est pas la première remarque de ce genre qu'on te fait...)

Je pense que Revox en sait plus que moi à ce sujet mais lorsqu'un ordinateur compte il convertit de la base 10 à la base 2

Exemple : 5 + 3 = 8
En binaire
110 + 100 = 1010

C'est juste des bits qui sont retournés je crois, mais ça ne marche pas tout le temps et j'aimerai comprendre pourquoi :/

Je confirme c'est quelque chose qui vient de la conversion en binaire! sans doute que RevoX a plus de précision que moi la-dessus.

Je pense qu'on a eu une introduction la dessus en Fortran ou en microprocesseur? mais c'est loin, je vais regarder si je trouve quelque chose mais je pense que RevoX pourra mieux répondre que moi!

J'attends toujours la réponse d'un de mes professeurs pour savoir si je peux mettre un de ses documents à votre disposition.
Toujours est-il qu'il est bien évident que tout se fait en binaire et qu'il ne sait faire que des simples opérations AND OR XOR NOT. (et, ou, ou exclusif, négation)
J'espère avoir une réponse favorable car sinon ça va être hard à expliquer simplement en quelques lignes  
Je développerai ça un peu plus tard  

Ce que j'ai cru comprendre en spé maths c'est que le AND est un * et le OR un +

1001 && 0100 = 0000   // 1001 * 0100 = 0000
1001 || 0100 = 1101   // 1001 + 0100 = 1101

Pour info :
1&&1 = 1 et 1&&0 = 0&&1 = 0&&0 = 0
1||1 = 1||0 = 0||1 = 1 et 0||0 = 0

oui et XOR est un + entouré !

pour l'addition, le processeur effectue des XOR et des AND
(je l'ai appris en faisant de l'assembleur !)
pour 0010+1010 ( en binaire ) il fait :

0 XOR 1 = 1
0 XOR 0 = 0
1 XOR 1 = 0
0 XOR 0 = 0

il "enregistre" 1000

puis (retenue) :

0 AND 1 = 0
0 AND 0 = 0
1 AND 1 = 1
0 AND 0 = 0
il "enregistre" 0010
il exécute un décalage des bits (je ne sais plus comment on appelle cette fonction) vers la gauche au 2ème nombre enregistré : 00100
il refait l'addition jusqu'au moment où la retenue est nulle
il trouvera 1100 avec retenue nulle
et 0010+1010=1100
( 2+10=12 )
enfin, je crois qu'il procède comme ça, et il enregistre les nombres intermédiaires dans la mémoire des registres, qui est la plus rapide

edit : qui a eu le courage de comprendre   (c'était dur, hein ?)?
edit 2 : ah, je me suis trompé, c'est pas NOT et AND mais XOR

Est-ce vraiment l'ordinateur ou l'utilisateur qui se trompe?
Pour ce qui est du programme de la news du SDZ , il est évident que c'est la variable globales qui pose problème! Donc faut soit utiliser Deux variables i en locale ou deux differentes : i et j par exemple. C'est le language qui veut ca.

Les erreurs trouvés sont plus cherchés à mon gout , effectivement sur un nombre non signés , signés , 4 bits 16 bits etc , tous ont leur limites et faut bien les utilisés. C'est pas que l'ordinateurs ne sais pas compter car il fait très bien ce qu'on lui dit , c'est l'utilisateurs qui utilise mal (ou que le language de programmation a mal été fait , possible aussi)

je suis de l'avis de Kafebis un ordinateur n'est rien d'autre qu'une machine et il fait ce qu'on lui demande de faire rien de plus

il exécute un décalage des bits (je ne sais plus comment on appelle cette fonction) vers la gauche

en assembleur c'est l'instruction SHL

Edit : ... Rien dit, j'aurais dû lire le topic jusqu'au bout ...

Tiens, ça m'est arrivé tout récemment ce genre de truc : j'avais fait un petit programme (en PHP) de rien du tout qui permettait de me renvoyer les nombres de 1 à 200 à la puissance 13. Les 10 premiers nombres étaient corrects, mais dès qu'il dépassait 10, il se trompait...je ne sais pas si c'est dû au langage (PHP), qui en soi n'est pas fait pour calculer de grands nombres...toujours est-il qu'il se trompait!
Certains me diront "comment peux-tu être aussi sûr de tes calculs à toi?". Le fait est que je n'est pas calculé mais juste utilisé une petite "technique" arithmétique : il est assez facile de prouver que le dernier chiffre de tout nombre entier est le même que celui de ce nombre à la puissance 13, chose qui n'est pas appliquée avec le programme.

En fait, un ordinateur ne sais pas non plus faire le XOR. Il connait seulement ET, OU et NON.
A XOR B <=> (A OU B) ET NON(A ET B)