λ-machine

λ-machine :: codage

www!k! v.20120517

λ-machine :: éditeur

{div {@ font:bold 3.9em courier; color:white; background:red; margin-top:20px; line-height:0.8em;} codage des informations}
_center{Les langages modélisent nos pensées et en déterminent les limites. (Benjamin Lee Whorf)}
{div {@ float:left;}
_show{data/einstein.png|200|600|Einstein pensait différemment !}
}
{div {@ float:right; width:75%; font-size:2em;}

_p _b{Sommaire}
_ol du bit à l'octet
_ol usages de l'octet
_ol programme informatique
_ol balade dans la mémoire
}
{div {@ clear:both;}}

{div {@ font:bold 3em courier; color:white; background:#888; margin-top:20px; line-height:0.8em;} 1) du bit à l'octet}

_column{
_p L'électronique fournit des circuits électriques pouvant être mis dans un état ouvert ou fermé, allumé ou éteint, +5v ou 0v ; on peut ainsi représenter deux états : faux ou vrai, 0 ou 1, et on appelle _b{bit} (binary digit) ce type d'information binaire. 
_p _b{C'est sous cette forme que sont mémorisées les informations {span {@ color:red;}de bas niveau} dans un ordinateur}.

_p Exemple : d'un écran standard VGA de 768 lignes de 1024 pixels noirs ou blancs, l’ordinateur ne connait que 786432 valeurs binaires mises bout à bout. Cela ne représente aucun sens pour lui, mais pas pour nous qui voyons les lignes regroupées les unes au dessous des autres pour former une image bidimensionnelle reconnaissable.

_p _b{C'est ce principe de regroupement qui est à la base du codage {span {@ color:red;}de haut niveau} en informatique}.

_p Nous allons voir ce qu’il est possible de faire avec des regroupements de bits de plus en plus complexes.
}

_h6 1.1) avec 1 bit
_p Avec 1 bit on peut coder 2 états :

_pre{
0   0  - > noir
1   1  - > blanc
}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#000; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#fff; }}
{div {@ clear:both;}}
_p Les pixels des premiers écrans d'ordinateur étaient codés sur 1 bit et ne pouvaient représenter que des images en Noir & Blanc.

_h6 1.2) avec 2 bits
_p En regroupant 2 bits, on obtient 2_sup{2} = 4 combinaisons notées de 0 à 3 :
_pre{
0   0 0  - > noir         - > 0%
1   0 1  - > gris foncé   - > 33%
2   1 0  - > gris clair   - > 67%
3   1 1  - > blanc        - > 100%
}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#000; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#666; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#aaa; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#fff; }}
{div {@ clear:both;}}
_p Les pixels des écrans des stations NEXT étaient codés sur 2 bits et pouvaient représenter des images en Noir & Blanc avec deux niveaux de gris. Steve Jobs avait décidé que c'était suffisant pour les besoins courants. La suite lui prouva que non !

_h6 1.3) avec 3 bits
_p En regroupant 3 bits, on obtient 2_sup{3} = 8 combinaisons notées de 0 à 7 :
_pre{
0   0 0 0  - > noir
1   0 0 1  - > bleu
2   0 1 0  - > vert
3   0 1 1  - > cyan
4   1 0 0  - > rouge
5   1 0 1  - > magenta
6   1 1 0  - > jaune
7   1 1 1  - > blanc
}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#000; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#00f; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#0f0; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#0ff; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#f00; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#f0f; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#ff0; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; background:#fff; }}
{div {@ width:50px; height:50px; border:1px solid; float:left; }
{show {@ src:data/8couleurs.png; height:50; width:700; }8 couleurs}}
{div {@ clear:both;}}

_p Les huit couleurs ainsi définies sont :
_ul les trois couleurs [rouge vert bleu] composant les pixels affichés par les écrans (TV, ordinateur),
_ul les trois couleurs [magenta, jaune, cyan] utilisées dans les cartouches des imprimantes.
_ul et les deux couleurs [noir, blanc].
_p Dans l'imprimerie classique les couleurs [magenta, jaune, cyan] s'appellent [rouge, jaune, bleu] ; mélanger ces trois couleurs sur du papier blanc produit du noir (un marron très foncé). On parle de synthèse soustractive.
_p Sur un écran d'ordinateur, noir par défaut, mélanger les couleurs [rouge vert bleu] produit du blanc. On parle de synthèse additive.
_p Photoshop gère très bien le passage des images conçues sur un écran en synthèse additive à l'impression qui se fait en synthèse soustractive.

_h6 1.4) avec 4 bits
_p En regroupant 4 bits, on obtient 2_sup{4} = 16 combinaisons notées de 0 à F :
_pre{
0   0 0 0 0  - > 0  - > 0%
1   0 0 0 1  - > 1
2   0 0 1 0  - > 2
3   0 0 1 1  - > 3
4   0 1 0 0  - > 4  - > 25%
5   0 1 0 1  - > 5
6   0 1 1 0  - > 6
7   0 1 1 1  - > 7  
8   1 0 0 0  - > 8  - > 50%
9   1 0 0 1  - > 9
10  1 0 1 0  - > A
11  1 0 1 1  - > B
12  1 1 0 0  - > C  - > 75%
13  1 1 0 1  - > D
14  1 1 1 0  - > E
15  1 1 1 1  - > F  - > 100%
}
_p Dans le système décimal, on dispose de 10 symboles [0,1,2,3,4,5,6,7,8,9]. Il est impossible de représenter "directement" les nombres suivant 9. On convient de les écrire en groupant deux symboles comme ceci : 10, 11, 13, ..., 19, puis 20, 21, ... 98, 99 ; puis 100, 101, ... etc.
_p La représentation décimale des 16 combinaisons obtenues en regroupant 4 bits étant peu pratique, on a eu l'idée d'ajouter cinq symboles choisis sur le clavier, "au hasard" : [A,B,C,D,E,F]. Et comme dans le système décimal, comme il est impossible de représenter "directement" les nombres suivant F, on convient de les écrire en groupant deux symboles comme ceci : 10, 11, 13, ..., 19, 1A, 1B, 1C, 1D, 1E, 1F, puis 20, 21, ..., FE, FF.
_p Cette petite gymnastique intellectuelle vaut l'investissement si l'on veut comprendre un minimum ce qui suit. Désolé de ne pas pouvoir vous l'éviter !

_h6 1.5) avec 8 bits
_p En regroupant 8 bits, on obtient 2_sup{8} = 256 combinaisons notées de 00 à FF :
_pre{
0     0000 0000   - > 00
1     0000 0001   - > 01
2     0000 0010   - > 02
3     0000 0011   - > 03

253   1111 1101   - > FD
254   1111 1110   - > FE
255   1111 1111   - > FF
}
_p Le groupe de 8 bits, encore appelé _i{_b{octet}, est l’unité fondamentale pour coder tous les types d’information de haut niveau en informatique}, le bit n’étant utilisé que dans des cas très particuliers. 
_p On est conduit à définir des multiples de cette unité :
_pre{
      1 ko = 2_sup{10} = 1 024 octets     = 1 kilo-octet
      1 Mo = 2_sup{20} = 1 024 kilo_octet = 1 méga_octet
      1 Go = 2_sup{30} = 1 024 méga_octet = 1 giga_octet
      1 To = 2_sup{10} = 1 024 giga_octet = 1 téra_octet
}
_p _b{Note 1} : on définit aujourd'hui le kioctet = 1 000 octets, et suivants ; oublions !
_p _b{Note 2} : la définition de l'octet comme unité d'information va nous permettre de passer du _b{bas niveau} électronique "binaire" au _b{haut niveau} des informations gérées par l'informatique. L'octet est la clé ouvrant le monde du multimedia ! Une construction simple et puissante. La comprendre aide à passer du consommateur passif au producteur actif. 
_p Un architecte est un producteur actif !

_p ...

{div {@ font:bold 3em courier; color:white; background:#888; margin-top:20px; line-height:0.8em;} 2) usages de l'octet}

_h6 2.1) les caractères alphanumériques
_p Un clavier contient une cinquantaine de touches (26 caractères alphabétiques, 10 chiffres, opérations, signes de ponctuation, ...). 
_p L'introduction d'une touche "MAJUSCULE" sur les anciennes machines à écrire avait déjà permis de multiplier par deux le nombre de caractères, bien au-delà des majuscules, pour en gérer une centaine environ.
_p Avec les ordinateurs est apparue la touche "ALT" (alternative) multipliant encore par deux les possibilités, pour un total de 200 environ. On pourrait appeler "ALT_1" la touche "MAJUSCULE" et "ALT_2" la touche "ALT", les deux ayant le même rôle, démultiplier le nombre de caractères accessibles à partir d'un clavier de 50 touches.

_p _u{D'où le choix de l'octet pour coder les caractères entrés au clavier}.

_p Avec un octet il est possible de coder 256 états et donc la plupart des caractères alphanumériques (des langues occidentales) ainsi que divers symboles et opérateurs. Le standard ASCII associe aux 128 premières combinaisons de l'octet les caractères alphabétiques et numériques courants ainsi que quelques instructions et opérateurs du type +,-,*,/. Par exemple, le caractère "A" est associé à la 65ème combinaison, le caractère "1" est associé à la 49ème  combinaison,  le retour chariot est associé à la 13ème  combinaison,  etc...
  
_center{_show{data/ASCII.png|400|800|le codage ASCII}}

_p Le standard ASCII s’impose à tous les constructeurs d’ordinateurs. Mais cela ne concerne que les 128 premiers caractères codables sur un octet, dont sont exclus les caractères accentués ou propres à une langue comme le français, le suédois ou l’espagnol. Comme il n’y a pas de standard de fait en la matière, chacun a choisi son propre code pour les 128 caractères suivants, et en conséquence, un texte écrit sur une machine WINTEL doit être filtré dans une matrice de transcodage pour être lu correctement sur un MAC ou une station UNIX.
_p Et de toute façon, les langues orientales, avec leurs milliers de caractères sont exclues du jeu. Aujourd’hui, avec Internet, un nouveau codage se profile sur la base de deux octets (soit plus de 30 000 caractères possibles). Il s’agit du système UNICODE qui devrait remplacer les acrobaties imposées aujourd’hui pour les échanges, dans le genre de ce qu’on utilise dans le langage HTML où par exemple : 
_p le caractère "é" s’écrit : "& eacute ;". 
_p Ce qui n'est pas vraiment joli !

_h5 2.2) les nombres
_p Hors des pays francophones, un ordinateur s'appelle un "computer" (et ma belle-soeur vivant du côté de Carmaux l'appelle même "computé" !) Un ordinateur est aussi utilisé pour calculer et se pose la question de représenter les nombres avec notre unité de base, l'octet. On distingue les nombres entiers naturels, les nombres relatifs, les nombres fractionnaires et les nombres réels.

_h6 2.2.1) les nombres entiers naturels
_p En fonction de l'étendue de l'intervalle de travail, on regroupe plus ou moins d'octets :
_pre{
 1 octet  - > 2_sup{8}  =           256 entiers positifs de 0 à 255 
 2 octets - > 2_sup{16} =        65 536 entiers positifs de 0 à 65 535  ( environ 65 milles )
 3 octets - > 2_sup{24} =    16 777 216 entiers positifs de 0 à 16 777 215  ( environ 16 millions )
 4 octets - > 2_sup{32} = 4 294 967 296 entiers positifs de 0 à 4 294 967 295  ( environ 4 milliards )
}
_p Notez cette méthode qui reviendra constamment : le regroupement.

_h6 2.2.2) les nombres entiers relatifs
_p On code les nombres négatifs en décalant de moitié l'intervalle de définition des entiers positifs : 
_pre{
 1 octet  - > intervalle de           -128 à           +127
 2 octets - > intervalle de        -32 768 à        +32 767 ( environ -32 à +32 milles )
 3 octets - > intervalle de     -8 388 608 à     +8 388 607 ( environ -8 à +8 millions )
 4 octets - > intervalle de -2 147 483 648 à +2 147 483 647 ( environ -2 à +2 milliards )
}
_h6 2.2.3) les nombres fractionnaires
_p Le codage des nombres fractionnaires, comme 3/4 ou 123/456 est moins immédiat et il existe plusieurs méthodes. On peut convenir que l’octet de gauche représente la partie entière et l’octet de droite la partie décimale. Ainsi, dans la représentation dite FIXED le nombre hexadécimal "0180" représente le nombre décimal 1,5 : 
_pre{
    l'hexadécimal "01" représente "1" en décimal et 
    l'hexadécimal "80" qui se trouve au milieu de l'intervalle [00,FF] représente la valeur 0,5.
}
_h6 2.2.4) les nombres réels
_p Le codage des nombres tels que racine(2) ou pi=3,141592, se fait de façon analogue. Etudions les nombres réels suivants et une réécriture possible conduisant à un codage basée sur l'octet :
_pre{
         1280 | 128 | 12,8 | 1,28 | 0,128 | 0,0128

1280   = +0,128•10_sup{+4} codé sous la forme - > [+128,+4]
128    = +0,128 10_sup{+3} codé sous la forme - > [+128,+3]
12,8   = +0,128 10_sup{+2} codé sous la forme - > [+128,+2]
1,28   = +0,128 10_sup{+1} codé sous la forme - > [+128,+1]
0,128  = +0,128 10_sup{+0} codé sous la forme - > [+128,+0]
0,0128 = +0,128 10_sup{-1} codé sous la forme - > [+128,-1]
}
_p Cette représentation  normalisée des nombres réels, dite _b{à virgule flottante} permet de ramener leur représentation à celui d'un couple de deux nombres relatifs, _b{l'exposant et la mantisse}, donc à un couple d'octets. L'intervalle de définition étant vraiment réduit, on est amené à coder sur 4 octets, et obtenir l'intervalle [-1.5*10_sup{45}, 3.4*10_sup{38}] avec une précision de 7 à 8 décimales. En codant sur 8 octets, l'exposant atteindra environ 300 et la précision 16 décimales. E codant sur 10 et même 12 octets, on dépasse le nombre de grains contenus dans l'univers.

_p _b{Note} : c’est toujours le même principe, on remplace un problème complexe par deux problèmes plus simples.

_h5 2.2.5) et les couleurs ?

_p Sur un moniteur la couleur est obtenue par composition de trois composantes: ROUGE, VERT, BLEU (RVB ou RGB in english). On sait que pour obtenir une qualité photo-réaliste avec des dégradés sans bandes, il faut dépasser 200 nuances pour chaque composante. Avec 1 octet (soit 8 bits) par couleur, on atteint 256 nuances et on peut composer :
_pre{ 256 x 256 x 256 = 2_sup{8} x 2_sup{8} x 2_sup{8} = 2_sup{24} ≠ 16 millions couleurs.}

_p Les processeurs préférent travailler sur des combinaisons paires d’octets et on code en fait sur 4 octets soit 32 bits ; le 4ème octet permet de représenter 256 états de ce qu’on veut, et on en profite pour décrire le caractère plus ou moins transparent de la couleur (nom de code alpha channel).
_pre{
          codage                  R  G  B  A
Le rouge opaque s'écrit           FF 00 00 FF
Le vert opaque s'écrit            00 FF 00 FF
Le gris transparent 50% s'écrit   80 80 80 80
}

{div {@ width:50px; height:50px; border:1px solid; float:left; background:#ff0000; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#00ff00; }}
{div {@ width:50px; height:50px; border:1px solid;float:left; background:#808080; opacity:0.5; margin-left:-75px; margin-top:25px;}}
{div {@ clear:both;}}

_p Ce codage est largement utilisé sur internet.

_h5 2.3) les adresses
_p La mémoire d’un ordinateur est une suite d’emplacements pouvant contenir 1 bit. On ne s'intéresse en fait qu'à des groupes de 8 bits successifs formant des cases contenant 1 octet, et c’est à ces cases que l’on va attribuer une adresse. Une donnée pourra ainsi être repérée dans la mémoire (au moins par l'intermédiaire de son octet de poids le plus fort : par exemple, l'adresse d'un entier codé sur deux octets est l'adresse de l'octet de gauche ; on parle de mots courts, double, long). Les adresses sont des nombres entiers positifs. Du codage des nombres entiers naturels vus plus haut, on déduit donc que :
_pre{
 avec 1 octet on peut adresser            256 cases de 1 octet, soit 1/4 ko
 avec 2 octets on peut adresser        65 536 cases de 1 octet, soit 64 ko
 avec 3 octets on peut adresser    16 777 216 cases de 1 octet, soit 16 Mo
 avec 4 octets on peut adresser 4 294 967 296 cases de 1 octet, soit 4 Go
}

_ul Sur une calculatrice programmable HP67, on ne disposait que d’un octet (8 bits) pour coder les adresses, soit au total 256 mémoires ou encore 1/4 de kilo octet.
_ul Sur un Apple II ou les premiers PC, on disposait de deux octets (16 bits), soit 64ko. Bill Gates avait même assuré que personne n'aurait jamais besoin de davantage de mémoire !
_ul Sur les derniers MAC et PC, on dispose de quatre octets, soit 4 Go, ce qui laisse de la place ( pour l’instant ).

_p Actuellement les mémoires physiques installées sont au minimum de 2 Go, permettant d'accueillir les logiciels les plus complexes et leurs volumineuses données associées ; une solution au coût important des mémoires physiques est d’utiliser ce que l’on appelle la mémoire virtuelle, un concept qui dépasse le cadre de cette initiation. Dans tous les cas l’adressage sur 32 bits est devenu la règle, en attendant les 64 et 128 bits.

_h6 et internet ?

_p Le même problème se pose sur Internet : chaque ordinateur sur la planète doit avoir une adresse. On la code aujourd'hui sur 4 octets, soit 32 bits, l'adresse étant écrite sous la forme de 4 nombres inférieurs à 256. Par exemple l’adresse Internet de l’école d’architecture de Montpellier est : _b{194.199.210.33}. Avec ce codage, il y a 4 milliards d’adresses possible. Encore un peu et ce sera saturé, et il faudra passer à 64 bits et même plus.

_h5 2.4) les instructions

_p Il faut bien agir sur les données : aligner des caractères, additionner des nombres, tracer des lignes de pixels, mélanger des couleurs. Il faut donc définir des opérations, des instructions.

_p Avec un octet on peut coder un maximum de 256 instructions ; on trouve ce choix dans certaines calculatrices programmables (ma vieille calculatrice HP67 de 1975) où la place mémoire était comptée. Les instructions étaient directement entrées au clavier ou mémorisées dans une partie de la mémoire de la machine pour être exécutées ensuite  séquentiellement.
_p Dans les ordinateurs on utilise habituellement deux octets et l'on peut coder en principe 65.536 instructions. On compte tout d’abord le bon millier d’instructions de base (code cablé ou microprogrammé) du microprocesseur.
_p A titre d'illustration la valeur hexadécimale : _b{2C4F} correspond sur le microprocesseur MOTOROLA 68k à une instruction dont la mnémonique en langage assembleur est "MOVE.L A7,A6" :

_pre{ l'octet 2C4F est associé à l'instruction :  MOVE.L A7,A6
    c'est à dire :
    MOVE.L     // transfèrer  4 octets ( L veut dire long = 4 octets)
    A7         // du registre A7
    ,          // au 
    A6         // au registre A6 
}

_p Concernant le grand nombre de combinaisons inutilisées, chaque constructeur peut les utiliser à sa guise pour appeler quelques milliers de routines (le cas de la ToolBox du Macintosh par exemple). Un processeur MOTOROLA aura un comportement différent suivant qu’il sera installé sur un MAC, un NEXT ou une station graphique. Ces routines sont contenues en ROM ou en RAM comme par exemple la valeur hexadécimale _b{A8A1} correspondant sur MAC à la procédure _b{FrameRect} qui trace tout simplement un rectangle.

_h5 2.5) le contexte

_p _b{Notez l'importance du contexte}. Suivant le contexte un groupe de deux octets sera considéré comme :
_ul deux caractères alphabétiques successifs parmi 256 possibles, 
_ul un nombre entier positif dans l'intervalle [0,+64000],
_ul un nombre relatif dans l'intervalle [-32000,+32000],
_ul un nombre fractionnaire ou réel,
_ul une adresse ou une instruction parmi 64000.

_p Le contexte sera défini par le logiciel utilisé : un traitement de texte, un tableur, un logiciel de manipulation d'images, un logiciel de DAO/CAO, un logiciel de musique, le navigateur WEB.
_p Mais au fond, tous ces logiciels travaillent sur le même principe de codage basé sur l'octet. Et grâce à cela, il est facile de comprendre comment ces outils peuvent échanger leurs données apparemment si différentes. Et comment un logiciel de CAO peut ainsi assurer le chaînage complet entre le modèle 3D, les plans et coupes 2D, le DQE (descriptif/quantitatif/estimatif) et la machine-outil produisant l'objet, _i{in fine}.

_p ...

{div {@ font:bold 3em courier; color:white; background:#888; margin-top:20px; line-height:0.8em;} 3) programme informatique}

_p On dispose maintenant de tout ce qu’il nous faut pour définir ce qu’est un programme informatique. 
_p Pour mémoire, le mathématicien britannique Alan Turing (1912/1954) est l'auteur d'un article fondateur de la science informatique qui allait donner le coup d'envoi à la création des calculateurs universels programmables (ordinateurs). Il est à l'origine des concepts modernes de programmation et de programme. Présenter la machine de Turing dépassant le cadre de cette initiation, nous nous contenterons de donner la définition la plus simple possible basées sur les informations que nous venons d'aborder.

_h5 3.1) définition

{blockquote {@ font-size:1.5em;}
_p Un programme informatique se présente sous la forme d’une suite de données et d’instructions contenues dans la mémoire. 
_p L’exécution du programme consiste à lire séquentiellement le contenu de la mémoire et exécuter les instructions rencontrées.
_p En fonction du contexte, chaque instruction agit sur les données qui lui sont associées ou éventuellement provoque un saut à une adresse différente de l’adresse suivante, à un sous-programme par exemple. 
_p Le saut peut ou non être soumis à une ou plusieurs conditions ; de là découlent les possibilités de bouclage et d’interaction avec l’extérieur.
}
	
_p Cette définition s’applique au programme fondamental qui est lancé au démarrage de la machine (le système d'exploitation), au programme _b{interface} qui assure la gestion de base (Finder, Windows, ...), et aux divers logiciels spécialisés dans diverses taches (texte, calculs, dessins, ...) Ci-dessous est donnée une représentation schématique  de la cascade de boucles que suit le programme contenu dans un ordinateur entre son démarrage et son arrêt.

_center{_show{data/programme.png|400|800|les boucles d'un programme informatique}}

_h5 3.2) en conclusion
_p Dans les premiers temps de l’informatique, les ingénieurs écrivaient les calculs directement en binaire sur des pupitres à interrupteurs, puis en hexadécimal à partir de claviers.

_p Actuellement, on peut les écrire dans un langage comme _b{l’assembleur} (les instructions niveau machine aperçues plus haut) ou dans un langage évolué comme _b{le C} et ce sont des traducteurs (interpréteurs et compilateurs) qui se chargent de recomposer dans la mémoire les suites d’octets (et donc de bits) seuls compréhensibles ou plutôt manipulables par l’ordinateur. Un ordinateur qui de toute façon ne comprend strictement rien à tout ce qui lui passe dedans !
	
_p _b{Une seule forme} (le bit), pour de _b{multiples sens dépendant du contexte}, grâce à la seule puissance de l'octet, voilà l’énorme saut qualitatif qui sépare l’informatique d’une électronique _b{binaire}, la raison de la richesse des possibilités ouvertes par cette construction purement intellectuelle pour l’analyse et la représentation du monde réel et au delà pour la création de nouveaux mondes virtuels !

_p ...

{div {@ font:bold 3em courier; color:white; background:#888; margin-top:20px; line-height:0.8em;} 4) une balade dans la mémoire}

_p Au point où nous en sommes, nous pouvons retenir que suivant le    contexte, une suite de bits contenus dans la mémoire pourra être   considérée, suivant le contexte, comme étant des caractères, des nombres entiers ou réels, des instructions, ou un mélange plus ou moins complexe de tout cela. Cela peut très bien être une zone de   stockage de données, ou une routine entière, ou encore une suite sans  contexte précis et ne présentant aucun sens, comme celle-ci :
_pre{
......................................................................................
...00110000001011100000000000001010110100000110111000000000000010001101000001000000...
......................................................................................
}

_h5 4.1) décoder
_p Nous allons tenter de trouver un sens à cette suite de bits, en l’écrivant tout d’abord comme une suite d'octets dont le premier serait par exemple à l'adresse 0010 0000 :

_pre{

adresse     binaire   hexa   
0001 1110   .... ....   ..   
0001 1111   .... ....   ..   
0010 0000   0011 0000   30   
0010 0001   0010 1110   2E   
0010 0002   0000 0000   00   
0010 0003   0000 1010   0A   
0010 0004   1101 0000   D0   
0010 0005   0110 1110   6E   
0010 0006   0000 0000   00   
0010 0007   0000 1000   08   
0010 0008   1101 0000   D0   
0010 0009   0000 0100   40   
0010 000A   .... ....   ..   
0010 000B   .... ....   ..   
}
_p puis en regroupant les octets deux à deux :
_pre{ 302E   000A   D06E   0008   D040 }

_p Sous cette forme, vous aurez reconnu ( bien sûr :)  trois instructions du microprocesseur Motorola 68k :
_pre{
1)   302E   000A   MOVE.W b(A6),D0    // charger b dans D0
2)   D06E   0008   ADD.W  a(A6),D0    // charger a dans D0
3)   D040          ADD.W  D0,D0       // ajouter D0   à D0
}
_p qui sont équivalentes à l'expression suivante :

_pre{ 2*(a+b)                         // calculer le périmètre d'un rectangle de côtés a et b}

_p _u{Suivre séquentiellement cette suite de bits revient donc à exécuter une fonction qui calcule le périmètre d'un rectangle de cotés a et b}.

_p _b{Note :} Les pirates savent décoder ainsi, repérer dans les fichiers remplis de nombres hexadécimaux des suites "qui ont un sens" et en faire quelque chose de bien ou de moins bien !

_h5 4.2) coder
_p Nous allons décrire quatre façons différentes d'aboutir au code ci-dessus :
_ol en écrivant les instructions dans un langage relativement lisible pour l'homme, le  langage C,
_ol en écrivant les instructions dans le langage assembleur adapté au  micro-processeur,
_ol en écrivant directement les suites d'octets équivalents à ces instructions en représentation hexadécimale,
_ol en écrivant directement les suites de bits équivalents à cette suite d'octets.

_h6 4.2.1) langage C :
_pre{°°
int c_perim( int a, int b )
{
  return 2 * ( a + b );   // le périmètre d'un rectangle
}
°°}

_h6 4.2.2) langage assembleur ( embarqué dans le C ) :
_pre{°°
int a_perim( int a, int b )
{  
  asm
  {  
    MOVE.W b(A6),D0   // charger b     les routines critiques des jeux
    ADD.W  a(A6),D0   // ajouter a     sont écrites en assembleur,
    ADD.W  D0,D0      // (a+b) + (a+b) le langage natif du processeur
  }
}
°°}

_h6 4.2.3) langage hexadécimal ( embarqué dans le C ) :
_pre{°°
int h_perim( int a, int b )
{  
  asm
  {  
    dc.w 0x302E   // certains hackers
    dc.w 0x000A   // écrivent ainsi
    dc.w 0xD06E   // les programmes
    dc.w 0x0008   // qui viennent véroler
    dc.w 0xD040   // nos machines
  }
}
°°}

_h6 4.2.4) langage binaire ( embarqué dans le C ) :
_pre{°°
int b_perim( int a, int b )
{  
  asm
  {  
    dc.w 0011 0000 0010 1110   // les premiers informaticiens
    dc.w 0000 0000 0000 1010   // entraient ainsi les données
    dc.w 1101 0000 0110 1110   // et les instructions en
    dc.w 0000 0000 0000 1000   // abaissant ou non des rangées
    dc.w 1101 0000 0100 0000   // d'interrupteurs
  }
}
°°}

_h6 4.2.4) compiler
_p Une fois compilées, les trois premières écritures aboutissent   toutes à la suite de bits analysée, seule mémorisable (sinon comprise) par l’ordinateur : 
_pre{
......................................................................................
...00110000001011100000000000001010110100000110111000000000000010001101000001000000...
......................................................................................
}

_p Voila comment on peut faire calculer le périmètre d'un rectangle à un ordinateur qui ne connait que le langage binaire et ne verra jamais un rectangle de sa vie !

_p Dans le cours suivant sur les _b{composants de la machine}, on étudiera les composants de l'ordinateur qui abritent et traitent les informations de bas niveau que sont les bits.

_p Merci pour votre attention.

_center{
_show{data/gremlins.png|600|600|cé koooool le codage !!!}

}