update readme

README.md

@@ -22,21 +22,39 @@ Sur ce dépôt, vous trouverez les notes de cours ainsi que les sujets des TD/TP
 Le programme prévisionnel est le suivant :
 * CM :
   - [CM1](cm1-caracteres.md) : Codage des caractères
-  - [CM2](cm2-nombres.md) : Codage des entiers et réels
-  - CM3 : Architecture d'un ordinateur
-  - CM4 : Calcul booléen
-  - CM5 : Histoire de l'informatique et des ordinateurs
-  - CM6 : Histoire du libre, de l'open-source et du captif
+  - [CM2](cm2-entiers.md) : Codage des entiers
+  - [CM3](cm3-reels.md) : Codage des réels
+  - [CM4](cm4-archi.md) : Architecture d'un ordinateur
+  - [CM5](cm5-calcul.md) : Calcul booléen
+  - [CM6](cm6-histoire.md) : Histoire moderne, licences et technologies
 * TD :
   - [TD1](td1-caracteres.md) : Codage des caractères
-  - TD2 : Codage des entiers
-  - TD3 : Codage des réels
-  - TD4 : Logique booléenne
-  - TD5 : Additionneur
-  - TD6 : TBA
+  - [TD2](td2-entiers.md) : Codage des entiers
+  - [TD3](td3-reels.md) : Codage des réels
+  - [TD4](td4-logique.md) : Logique booléenne
+  - [TD5](td5-additionneur.md) : Additionneur
+  - TD6 : Révisions
 * TP :
-  - [TP1](tp1-encodage.md) : Encodage binaire vers texte
-  - TP2 : TBA
-  - TP3 : TBA
+  - [TP1](tp1-encodage.md) : Encodage binaire vers texte 1/2
+  - [TP2](tp1-encodage-p2.md) : Encodage binaire vers texte 2/2
+  - [TP3](tp3-demontage.md) : Dismantle Party
 
 L'évaluation sera composée d'une note de contrôle continu (1/3, à partir des comptes-rendus demandés) et d'une note d'examen final (2/3).
+
+
+Annexe -- Périmètre de la matière
+=================================
+
+Ce que vous devez savoir faire :
+- les principes des encodages/conversions vus en TD/TP (et savoir les appliquer)
+- les manipulations de calcul booléen, les tables de vérité des fonctions de base NON, ET, OU, NON-ET, NON-OU, XOR ainsi que leur représentation en porte logique (pas en transistors ! pas non plus les tables de Karnaugh)
+- les composants d'un ordinateur
+
+Ce que vous ne devez pas connaître par cœur (qui serait fourni si nécessaire) mais savoir exploiter :
+- les tables de codage (ASCII, ISO-8859-15, Unicode, Base64, ...)
+- le nombre de bits pour signe, mantisse et exposant et les offsets d'exposant selon les différentes tailles de flottants
+- les décompositions en transistors des portes logiques
+
+Nouvelle matière, nouvel enseignant sur cette matière : il n'y a pas d'anciens contrôles, ceux de l'an dernier ne sont pas représentatifs du programme vu cette année et de ce que vous devrez faire.
+
+Le contrôle sera sans calculatrice et sans documents.

cm2-entiers.md

@@ -1,4 +1,4 @@
-CM2 Codage des nombres - Notes de cours
+CM2 Codage des entiers - Notes de cours
 =======================================
 
 Quizz : Combien vaut 0.1 + 0.2 ?
@@ -91,54 +91,3 @@ Représentation des entiers relatifs
 - Débordement ([char2.c](cm2-nombres-code/char2.c)) :
   - 127 + 1 = 128
   - 0111 1111 + 0000 0001 = 1000 0000 -> -128
-
-
-Les réels
-=========
-
-Ici, 0.1 + 0.2 = 0.30000000000004 ([détails ici](https://0.30000000000000004.com/)) ([double.c](cm2-nombres-code/double.c))
-
-
-Virgule fixe
-------------
-
-- Un réel = une partie entière et une partie fractionnaire séparés par une ','
-- On code par exemple sur 2 octets :
-  - 1 octet pour la partie réelle en complément à 2 (entier relatif)
-  - 1 octet pour la partie fractionnaire en inverse : 1/2, 1/4, 1/8, 1/16, etc. (était en décimal 1/10, 1/100, 1/1000, etc.)
-  - Il n'y a pas 1/10 ! -> On ne peut que s'approcher de 0.1, 0.2 et 0.3...
-- Comme on écrit des nombres en décimal et qu'on les approxime avec des 1/2, 1/4, 1/8, etc. :
-  - 0.1 n'est pas exactement 0.1
-  - 0.2 n'est pas exactement 0.2
-  - donc 0.1 + 0.2 n'est pas exactement 0.3
-  - Note : un nombre en binaire sera aussi approximé pour repasser en base 10...
-- L'approximation n'est pas forcément visible car nous utilisons une précision assez grande mais elle est là
-- => Pas de calcul décimal exact en réels, **pas de tests d'égalités** !!!
-  - égalités entre entiers seulement
-  - au pire test d'écart à la valeur recherchée (mais c'est critiqué)
-- Utilisé en pratique si pas mieux dispo (micro-contrôleur sans unité à virgule flottante par exemple)
-
-
-Virgule flottante
------------------
-
-- Signe (1 bit), exposant, mantisse
-- Nombre = signe * mantisse * 2<sup>exposant</sup>
-- En C, float (32 bits, peu précis à l'usage) et double (64 bits, plus précis)
-- Exemple du double : 1 bit de signe, 11 bits d'exposant, 52 bits de mantisse (norme IEE754)
-- Les mêmes approximations que précédemment ! (et donc pas non plus de tests d'égalité !!!)
-- Couramment utilisé
-
-
-Pour approfondir
-----------------
-
-Pour aller au-delà de ces limites, il faudra utiliser des biblothèques/logiciels dédiés au calcul, par exemple [SageMath](https://www.sagemath.org/). Ici, on pourra avoir 0.1 + 0.2 = 3. Les nombres ne sont alors plus représentés comme les types de base vus précédemment qui sont les seuls sur lesquels savent calculer les CPU classiques. Points d'attention :
-- les calculs sont plus lents, car un calcul SageMath impliquera plusieurs calculs sur des types de base au niveau CPU
-- les types que vous manipulerez par défaut dans les langages de programmation les plus courants sont uniquement les types de base, efficaces mais donc inexacts.
-
-
-Annexes
-=======
-
-- [Entiers, virgules flottantes ou représentations exotiques ... (Olivier Poncet et Fabien Trégan, DevoxxFR 2022)](https://www.youtube.com/watch?v=1upzDFFIODk). Vidéo de 45 minutes, dont 15 premières minutes sur le programme de cette séance.

cm2-nombres-code/char.c

@@ -7,6 +7,4 @@ void main()
 	unsigned char c = a + b;
 
 	printf("Value of c is: %d\n",c);
-	
-
 }

cm2-nombres-code/char2.c

@@ -7,6 +7,4 @@ void main()
 	char c = a + b;
 
 	printf("Value of c is: %d\n",c);
-	
-
 }

cm2-nombres-code/floatdouble.c

@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main()
+{
+	float a = 0.1;
+	float b = 0.2;
+	float c = 0.3;
+
+	/* double a = 0.1;
+	double b = 0.2;
+	double c = 0.3; */
+
+	if (a+b == c) {printf("égaux\n");} else {printf("différents\n");}
+}

cm3-reels.md

@@ -0,0 +1,51 @@
+CM3 Codage des réels - Notes de cours
+======================================
+
+
+Ici, 0.1 + 0.2 = 0.30000000000004 ([détails ici](https://0.30000000000000004.com/)) ([double.c](cm2-nombres-code/double.c))
+
+
+Virgule fixe
+------------
+
+- Un réel = une partie entière et une partie fractionnaire séparés par une ','
+- On code par exemple sur 2 octets :
+  - 1 octet pour la partie réelle en complément à 2 (entier relatif)
+  - 1 octet pour la partie fractionnaire en inverse : 1/2, 1/4, 1/8, 1/16, etc. (était en décimal 1/10, 1/100, 1/1000, etc.)
+  - Il n'y a pas 1/10 ! -> On ne peut que s'approcher de 0.1, 0.2 et 0.3...
+- Comme on écrit des nombres en décimal et qu'on les approxime avec des 1/2, 1/4, 1/8, etc. :
+  - 0.1 n'est pas exactement 0.1
+  - 0.2 n'est pas exactement 0.2
+  - donc 0.1 + 0.2 n'est pas exactement 0.3
+  - Note : un nombre en binaire sera aussi approximé pour repasser en base 10...
+- L'approximation n'est pas forcément visible car nous utilisons une précision assez grande mais elle est là
+- => Pas de calcul décimal exact en réels, **pas de tests d'égalités** !!!
+  - égalités entre entiers seulement
+  - au pire test d'écart à la valeur recherchée (mais c'est critiqué, les incertitudes ne se propagent pas d'une bonne manière)
+- Utilisé en pratique si pas mieux dispo (micro-contrôleur sans unité à virgule flottante par exemple)
+
+
+Virgule flottante
+-----------------
+
+- Signe (1 bit), exposant, mantisse
+- Nombre = signe * mantisse * 2<sup>exposant</sup>
+- En C, float (32 bits, peu précis à l'usage) et double (64 bits, plus précis)
+- Exemple du double : 1 bit de signe, 11 bits d'exposant, 52 bits de mantisse (norme IEE754)
+- Les mêmes approximations que précédemment ! (et donc pas non plus de tests d'égalité !!!)
+- Couramment utilisé
+- ([floatdouble.c](cm2-nombres-code/floatdouble.c))
+
+
+Calcul exact (bonus, hors programme)
+------------------------------------
+
+Pour aller au-delà de ces limites, il faudra utiliser des biblothèques/logiciels dédiés au calcul, par exemple [SageMath](https://www.sagemath.org/), [Calcium](https://fredrikj.net/calcium/), du décimal codé binaire (DCB) ou encore les [fractions python](https://docs.python.org/3/library/fractions.html) (mais c'est une autre histoire...). Ici, on pourra avoir 0.1 + 0.2 = 3. Les nombres ne sont alors plus représentés comme les types de base vus précédemment qui sont les seuls sur lesquels savent calculer les CPU classiques, mais comme des types construits à plus haut niveau. Points d'attention :
+- les calculs sont plus lents, car un calcul de ce type construit impliquera plusieurs calculs sur des types de base au niveau CPU
+- les types que vous manipulerez par défaut dans les langages de programmation les plus courants sont uniquement les types de base, efficaces mais donc inexacts.
+
+
+Annexes
+=======
+
+- [Entiers, virgules flottantes ou représentations exotiques ... (Olivier Poncet et Fabien Trégan, DevoxxFR 2022)](https://www.youtube.com/watch?v=1upzDFFIODk). Vidéo de 45 minutes, dont 15 premières minutes sur le programme de cette séance.

cm4-archi.md

@@ -0,0 +1,105 @@
+CM4 Architecture - Notes de cours
+=================================
+
+J'ai quoi dans un ordinateur ?
+------------------------------
+
+- Carte mère
+- CPU
+- RAM
+- Cartes d'extension
+- Disques
+
+[Architecture de Von Neumann](https://fr.wikipedia.org/wiki/Architecture_de_von_Neumann) :
+- Une unité arithmétique et logique : calcul
+- Une unité de contrôle : séquençage
+- De la mémoire : volatile (RAM), permanente (disque), contenant à la fois du code et des données
+- Des Entrées/Sorties : bus de communication (PCI-e, USB, SATA, Mémoire...), périphériques, monde extérieur
+
+
+
+Parlons du CPU
+--------------
+
+Un CPU c'est quoi ?
+- Un ensemble de cœurs de calcul (1 à ~16)
+- De la mémoire cache (différents niveaux plus ou moins partagés entre les cœurs)
+- Packagés ensemble
+- Soudé ou connecté (via un socket) sur la carte-mère
+- (On parle de SoC si le CPU est lui-même packagé avec RAM et périphériques)
+
+Un cœur (core) = un _pipeline_ (chaîne de traitement)
+- Lié au temps de propagation/stabilisation du signal en sortie
+- Concept : découper la chaîne en plusieurs sous-chaînes plus courtes (exemple Fetch, Decode, Execute)
+- La fréquence / vitesse d'horloge = le temps d'une étape du pipeline
+- Pourquoi s'arrêter là ?
+  - Par exemple 10 sous-chaînes, 10 fois plus de traitement !
+  - Jusque 31 chez Intel à une époque, aujourd'hui plutôt une quinzaine mais avec un cadre plus complexe
+- La limite : les branchements / le code non-linéaire. Si on a mal exécuté, il faut vider le pipeline et reprendre la bonne chaîne (temps perdu, évidemment)
+- Et donc de la prédiction, de la réorganisation (out-of-order) et de l'entremêlage (hyper-threading) pour
+  - faire le bon choix le plus souvent possible
+  - limiter l'impact d'un mauvais choix
+- => Complexité + attaques hardware de la famille [Spectre](https://fr.wikipedia.org/wiki/Spectre_(vuln%C3%A9rabilit%C3%A9))
+
+Évolution :
+- Loi de Moore : ~ doublement de la puissance tous les 18 mois
+- Jusqu'au début des années 2000 : par amélioration architecturale et augmentation de la fréquence
+- Depuis : par amélioration architecturale et augmentation du nombre de cœurs (fréquence stagne)
+- => Exécution parallèle nécessaire pour tirer profit des architectures modernes
+
+
+Quelques éléments qui caractérisent un CPU :
+- Marque/Modèle (ce qui implique son architecture)
+- Jeu d'instructions (architecture) / nombre de bits (32 ou 64 aujourd'hui)
+- Fréquence (rythme d'exécution des instructions)
+- Nombre de cœurs physiques
+- Nombre de cœurs logiques (hyper-threading)
+- Longueur du pipeline
+
+Quelques exemples d'architectures :
+- x86(-64) pour PC/Mac, CPUs conçus par Intel et AMD
+- ARM (nombreuses versions) pour smartphones, SBC (Raspberry) et Mac modernes (Apple Silicon)
+- AVR pour de nombreux Arduino, conçus par Atmel
+
+
+
+Un peu de mémoire
+-----------------
+
+Du plus rapide et plus petit au plus lent et plus gros (on parle de [hiérarchies mémoires](https://fr.wikipedia.org/wiki/Hi%C3%A9rarchie_de_m%C3%A9moire)), avec quelques ordres de grandeur :
+- Des registres :
+  - À l'intérieur de l'unité de calcul du CPU
+  - C'est de là que sont faits les calculs
+  - Exemple x64 : 16 registres généraux de 64 bits : 1ko (1 kilooctet = 1024 octets)
+- De la mémoire cache :
+  - Sur le silicium du CPU mais séparé de l'unité de calcul
+  - Plusieurs niveaux de cache (L1 à L3)
+  - Quelques MO (jusque 20aine), les plus rapides liée à un cœur, les plus loins partagés (1 mégaoctet = 1024 kilooctets)
+  - Vitesse de l'ordre de 0,5-1 To/s
+- De la mémoire vive (RAM) :
+  - Sur la carte mère, séparé du CPU
+  - Quelques Go (environ 4 Go sur un portable de base) (1 gigaoctet = 1024 mégaoctets)
+  - Vitesse de l'ordre de 5-50 GO/s
+- De la mémoire de stockage (disque dur) :
+  - Périphérique branché sur la carte mère (SATA, SAS, ...)
+  - Quelques To (1 téraoctet = 1024 gigaoctets)
+  - Vitesse de l'ordre de 100 Mo/s (disque dur), 500 Mo/s (SSD)
+
+
+Couches d'abstraction / Bas et haut niveau
+------------------------------------------
+
+Découpage en couches :
+- Matériel / _Hardware_
+- Système d'exploitation / _OS_
+- Logiciels / _Software_
+- Encapsulation (poupées russes) :
+  - Virtualisation (VMWare, Virtualbox, ...) : un logiciel qui simule un matériel
+  - Conteneurisation (Docker, LXC, ...) : un logiciel qui simule un système d'exploitation
+  - Des langages s'exécutant dans une machine virtuelle dédiée : Java (la JVM), C# (.Net Framework), ...
+
+Similairement des langages :
+- Binaire
+- Assembleur
+- C
+- Java, Python

cm5-calcul.md

@@ -0,0 +1,79 @@
+CM5 Calcul booléen - Notes de cours
+==========================================
+
+
+Pourquoi ?
+==========
+
+Le calcul informatique se base sur des transistors. Avec des transistors, on va voir qu'on sait faire des fonctions logiques NAND, NON, NOR. Et à partir de ces constructions, on sait construire ET et OU. Et à partir de ET et OU, on sait calculer, par exemple additionner des nombres. Avec tout ça, le calcul booléen sert de base à l'informatique.
+
+
+Transistors et portes
+=====================
+
+Le principe du transistor :
+- 3 pattes
+- Source, Drain, Grille
+- Source = positif, Drain = négatif, Grille = contrôle
+- Version N : ouvert si contrôle vaut 0, fermé si contrôle vaut 1 (Version P = le contraire)
+- Fermé = le courant passe entre S et D
+
+Une porte logique :
+- Un assemblage de transistors
+- Une fonction de plus haut niveau
+- Exemple de la porte NON : ![NON](https://upload.wikimedia.org/wikipedia/commons/thumb/f/f2/Porte_NON_fabriqu%C3%A9e_avec_des_transistors_CMOS._01.jpg/220px-Porte_NON_fabriqu%C3%A9e_avec_des_transistors_CMOS._01.jpg)
+- NAND, NOR, ET, OU, ... ![OU](https://upload.wikimedia.org/wikipedia/commons/thumb/5/5e/CMOS_OR.svg/440px-CMOS_OR.svg.png)
+
+Avec des transistors, on a créé l'implémentation matérielle de la logique booléenne (ET, OU, NON, etc.)
+
+Détails [ici](https://fr.wikibooks.org/wiki/Fonctionnement_d%27un_ordinateur/Les_transistors_et_portes_logiques).
+
+
+Logique booléenne
+=================
+
+Des opérateurs de base :
+- Conjonction ET (., ^, &, &&) ![ET](https://upload.wikimedia.org/wikipedia/commons/thumb/4/46/And.svg/128px-And.svg.png)
+- Disjonction OU (+, v, |, ||) ![OU](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Or-gate-en.svg/128px-Or-gate-en.svg.png)
+- Négation NON (¬, -, !) ![NON](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9f/Not-gate-en.svg/128px-Not-gate-en.svg.png)
+- Tables de vérité
+
+Des compositions :
+- Ou exclusif XOR ![XOR](https://upload.wikimedia.org/wikipedia/commons/thumb/6/6d/Xor-gate-en.svg/128px-Xor-gate-en.svg.png)
+- NAND ![NAND](https://upload.wikimedia.org/wikipedia/commons/thumb/5/58/Nand-gate-en.svg/128px-Nand-gate-en.svg.png)
+- NOR ![NOR](https://upload.wikimedia.org/wikipedia/commons/thumb/9/94/Nor-gate-en.svg/128px-Nor-gate-en.svg.png)
+
+Des règles :
+- Associativité
+- Commutativité
+- Distributivité
+- Idempotence
+- Éléments neutres et absorbants
+- Priorité : NON > ET > OU
+
+Théorème de De Morgan :
+- ¬(a+b) = ¬a . ¬b
+- ¬(a.b) = ¬a + ¬b
+
+Détails [ici](https://fr.wikipedia.org/wiki/Alg%C3%A8bre_de_Boole_(logique))
+
+Usages
+======
+
+Calcul
+------
+
+On peut calculer !
+- XOR = additionneur 1 bit (mais sans la retenue)
+- En TD, on fera un additionneur
+
+Opérations logiques
+-------------------
+
+Conditionnelle avec &&, || : paresseux ET "synthétiques"
+
+Opérations bit à bit
+--------------------
+
+- Opérations avec &, |, !
+- Notion de masque réseau

cm6-histoire.md

@@ -0,0 +1,99 @@
+CM6 Histoire moderne, licences et technologies - Notes de cours
+==========================================
+
+- Histoire moderne = échelle de temps des 20 dernières années = votre vie
+- Choix de synthétiser, au mieux, selon une lecture politique, les évolutions des pratiques, ce qu'elles reflètent de l'organisation du monde (c'est ça la politique)
+- Objectif : aider à initier une compréhension pour savoir vous orienter et comprendre le monde qui vous entoure(ra) au début de votre carrière
+- Pour l'histoire "historique" : moteurs de recherche, Wikipedia.
+
+
+L'informatique, pour quoi ?
+===========================
+
+- L'informatique est une science et une technologie
+- C'est le support technologique de la numérisation du monde
+
+Ce qu'on peut en faire :
+- L'automatisation du répétitif : moins de travail pénible, mais disparition de certains types d'emplois
+- Uber : liberté dans l'organisation du travail, mais peu de sécurité en cas d'imprévu
+- Bitcoin : échappement d'une structure de marché, mais création d'une autre structure de marché énergivore
+- Facebook : outil de regroupement (printemps arabes), mais outil d'influence (élections)
+
+=> Une technologie, ça amène des opportunités et des risques, ce n'est pas neutre !
+
+On va poser 2 éléments de vocabulaires pour comprendre l'articulation et les forces opposées de l'histoire de l'informatique :
+- Technologies asservissantes ou émancipatrices
+- Libertaires et libertarien·nes
+
+
+Les licences et usages
+======================
+
+Comprendre l'évolution des usages
+
+Avant le cloud
+--------------
+
+- Un OS sur son ordinateur
+- Des logiciels sur son ordinateur
+- Des données sur son ordinateur
+
+L'enjeu : maîtriser ce qu'il se passe sur son poste VS vendre du logiciel
+- Des licences *propriétaires*, vente du logiciel sous forme binaire
+- Des licences *ouvertes*, logiciel diffusé librement
+
+Et déjà le début de la notion de *captivité* avec les formats de documents :
+- Un format fermé permet d'enfermer les utilisateurs avec un logiciel
+- Un format ouvert permet de laisser libre le choix du logiciel (et l'émergence d'autres)
+
+=> On arrive sur un vocabulaire captif VS libre, plus représentatif aujourd'hui que propriétaire VS ouvert.
+- La captivité véhicule une dépendance, une part d'asservissement
+- La liberté véhicule une volonté d'émancipation des utilisateurs
+
+Avec le cloud
+-------------
+
+Quelques dates :
+- AWS : 2006
+- IPhone / Android : 2007
+- Google Drive : 2012
+
+L'évolution du cloud :
+- Un OS sur son ordinateur, coquille assez vide
+- Un navigateur sur son ordinateur (qui reprend beaucoup de ce que fait un OS...)
+- Des logiciels hébergés dans le cloud, ie, sur le serveur de quelqu'un d'autre
+- Des données sur ces serveurs tiers
+
+L'enjeu : maîtriser la collecte et le contrôle de nos données VS rentabiliser un service (abonnement, pub)
+- Les termes captif/libre reflètent l'état de nos données
+- La licence d'un logiciel qui s'exécute ailleurs ne nous apporte plus beaucoup de garantie...
+  - Est-ce vraiment le logiciel non modifié ?
+  - Une observation a-t-elle lieu avant/après sur le chemin ?
+  - On ne contrôle pas l'évolution des versions ou des fonctionnalités
+
+=> Le problème s'est déplacé, du logiciel libre dans un monde cloud ne répond plus à l'opposition de départ :
+- Avec un Android qui contient beaucoup de libre, sommes-nous dans une posture de dépendance ou d'émancipation ?
+- Et si Uber utilise uniquement du logiciel libre ?
+
+
+Fermé, Ouvert, Libre ?
+----------------------
+
+Il faut distinguer le modèle de développement et l'enjeu politique.
+
+Deux modèles de développement :
+- Fermé, préservation des secrets de fabrication, développeurs internes à rémunérer
+- Ouvert, pas de secrets, mutualisation des coûts avec d'autres organisations
+
+Différents enjeux :
+- Vendre du logiciel, du service, de l'hébergement, de la pub... => Intérêt lucratif
+- Diffuser du pouvoir de faire quelque chose => Intérêt collectif / non lucratif
+
+Choisir une licence est un acte politique :
+- le modèle de développement : ouvert ou fermé ?
+- les implications de réutilisation : peut-on faire de l'argent avec le travail donné ? Licence contaminante ou pas (GPL vs Apache/BSD/...). Si contaminante, seulement localement ou aussi par les interactions réseau (GPL vs AGPL)
+- les restrictions d'usage : peut-on utiliser mon logiciel pour faire n'importe quoi ? Licences à réciprocité, Coopcycle (2016). Plus libertaires que les autres si on réfléchit par projet politique sous-jacent, moins libertariennes si on réfléchit restriction des usages.
+
+Concrètement, aujourd'hui :
+- L'open-source a plutôt gagné comme modèle de développement. Mais il y a toujours plus d'argent dans l'éco-système numérique donc ce n'est pas très libre... On est sûrement moins libres avec le cloud et nos smartphones aujourd'hui qu'on ne l'était hier avec moins de LL et des PC...
+- Les mouvements du libre, de l'ouvert et du captif ne peuvent être compris que si l'on entend qu'ils sont notamment politiques (en bonne proportion)

td2-entiers.md

@@ -0,0 +1,63 @@
+TD2 Codage des entiers
+======================
+
+Les trois systèmes utilisés ici (entiers positifs, complément à 1, complément à 2) sont décrits avec les détails suffisants sur la [page Wikipedia dédiée](https://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire). Jetez-y un œil très rapide en début de séance (un parcours du plan, pas une lecture) puis revenez-y au moment nécessaire.
+
+L'objectif de ce TD est de faire les calculs, vous ne devez donc pas utiliser de conversion automatique (par une calculatrice ou un site web) lors des passages binaire <-> décimal.
+
+Table de conversion binaire <-> hexadécimal
+-------------------------------------------
+
+Construisez sur votre feuille un tableau de conversion binaire <-> hexadécimal allant de 0x0 à 0xF. Cela sera très utile pour la suite.
+
+| Hexa | Bin  |
+| --- | ---- |
+| 0x0 | 0000 |
+| 0x1 | 0001 |
+| ... | ...  |
+| 0xF | 1111 |
+
+(Il est évidemment facile de trouver une telle table sur internet mais c'est l'occasion de valider votre compréhension du binaire/hexa, faîtes donc l'exercice sans chercher de modèle)
+
+Entiers positifs
+----------------
+
+Les entiers positifs s'encodent en changeant leur base directement du décimal au binaire. C'est par exemple le type "unsigned char" en C, pour un entier non signé sur un seul octet.
+
+> Question 1 : Convertissez en binaire puis en hexadécimal sur un octet le nombre 138. Réalisez le calcul en décomposant en puissances de 2.
+
+> Question 2 : Convertissez en décimal le binaire 0110 1110 en décomposant en somme de puissances de 2.
+
+> Question 3 : Convertissez en binaire puis décimal l'hexadécimal 0x6B, toujours avec les détails de calcul.
+
+> Question 4 : Quelle est la plus grande valeur représentable sur un octet ? Pourquoi ?
+
+
+Complément à 1 (Non mentionné en cours)
+--------------
+
+Le complément à 1 va, ici, nous servir d'étape intermédiaire pour construire le complément à 2. Il s'agit simplement d'inverser tous les bits de la représentation binaire.
+
+> Question 5 : Quel est le complément à 1 sur un octet, en binaire puis en hexadécimal, de 0x6B ?
+
+
+Complément à 2
+--------------
+
+Le complément à 2, comme décrit sur la page Wikipedia liée en haut de sujet, permet de représenter les entiers négatifs en faisant :
+- complément à 1 de la valeur absolue
+- puis +1 sur le binaire
+
+Avec cette norme de codage, les entiers positifs restent représentés comme dans les questions 1 à 4. Le premier bit indique le signe : 0 pour + et 1 pour -.
+
+Le complément à 2 est la façon usuelle de représenter les entiers relatifs en mémoire. C'est par exemple comme ça qu'est représenté en mémoire le type "char" en C, pour un entier signé sur un seul octet (ainsi que tous les autres types d'entiers sur plus d'un octet évidemment).
+
+> Question 6 : Quel est, en binaire puis en hexadécimal, la représentation en complément à 2 de -79 (toujours sur 1 octet) ?
+
+> Question 7 : Faîtes la somme, en calcul binaire, des représentations binaires de 79 + 78, avec un format de sortie sur un octet. Convertissez le résultat en entier base 10 codé en complément à 2. Que constatez-vous ?
+
+> Question 8 : Représentez en hexadécimal sur un octet 79, -79, -1
+
+> Question 9 : Quelles sont les plus grandes valeurs positives et négatives représentables sur un octet ?
+
+> Question 10 : Additionnez en binaire les nombres représentés en compléments à 2 de 66 et -79. Que pouvez-vous dire du résultat ?

td3-reels.md

@@ -0,0 +1,53 @@
+TD3 Codage des réels
+====================
+
+Virgule fixe
+------------
+
+Soit une convention en virgule fixe avec une partie entière sur 1 octet codée en complément à 2 et une partie fractionnaire sur 1 octet également.
+
+Rappel : la partie fractionnaire représente 2<sup>-1</sup> = 1/2, 2<sup>-2</sup> = 1/4, 2<sup>-3</sup> = 1/8, etc.
+
+> Question 1 : Que vaut en base 10 la chaîne binaire 1010 0110 | 1100 0011 ?
+
+> Question 2 : Encodez en binaire le nombre 18,375. Est-ce une conversion exacte ?
+
+> Question 3 : Encodez en binaire le nombre 78,74. Est-ce une conversion exacte ?
+
+> Question 4 : Additionnez les représentations binaires de 18,375 + 78,74. Comment devez-vous procéder ?
+
+> Bilan : la virgule fixe permet de calculer sur les réels à partir d'opérations sur les entiers.
+
+
+Virgule flottante
+-----------------
+
+Adoptons la convention suivante pour la virgule flottante sur 2 octets :
+* 1 bit de signe
+* 5 bits d'exposant
+* 10 bits de mantisse
+
+Il s'agit de la convention [IEEE 754 Half Precision](https://en.wikipedia.org/wiki/Half-precision_floating-point_format). Un guide est disponible [ici](https://fr.wikihow.com/convertir-un-nombre-d%C3%A9cimal-au-format-binaire-IEEE-754) pour l'encodage. Attention le guide est illustré avec un encodage en simple précision sur 32 bits, il faut donc l'adapter. L'offset à utiliser sur l'exposant ici vaut 15.
+
+> Question 5 : Que vaut en base 10 la chaîne binaire 1110 0110 | 1100 0011 ? Attention :
+> - la mantisse à utiliser pour le calcul commence par un bit à 1 implicite, ie, il faut rajouter un bit à 1 à gauche des 10 bits de mantisse encodés, qui devient ainsi "1,(la partie encodée sur 10 bits)".
+> - l'exposant est encodé avec l'offset de 15, il faut donc soustraire 15 au binaire encodé pour avoir l'exposant du calcul (cet exposant est le nombre de décalages de la virgule depuis la notation scientifique)
+
+> Question 6 : Encodez en virgule flottante le nombre 8576,25. Décomposez en plusieurs étapes :
+> - Représentation binaire de la partie entière, de la partie fractionnaire
+> - Calcul de l'exposant permettant de recaler en notation scientifique
+> - Encodage de l'exposant en lui ajoutant l'offset de 15
+
+> Question 7 : Est-ce une conversion exacte ? Redécodez en base 10 le nombre précédemment encodé
+
+> Question 8 : Encodez le nombre 3,12
+
+> Question 9 : Redécodez en base 10
+
+> Question 10 : Additionnez, en virgule flottante binaire, les représentations de 3,12 + 8576,25, puis convertissez le résultat en décimal. Comment devez-vous procéder ? Que pensez-vous du résultat ?
+
+> Question 11 : Sans faire de calcul/conversion supplémentaire, quelle est la représentation en virgule flottante de 8576 + 0,36 ? Son affichage décimal ?
+
+> Question 12 (Bonus) : Quelles sont les plus grandes et plus petites valeurs dans cette convention (exprimez les en décimal ainsi que leur encodage binaire)
+
+> Bilan : la virgule flottante nécessite une unité de calcul spécifique.

td4-logique.md

@@ -0,0 +1,62 @@
+TD4 Logique booléenne
+=====================
+
+Transistors
+-----------
+
+Les informations nécessaires pour ces questions se trouvent sur [cette page](https://fr.wikibooks.org/wiki/Fonctionnement_d%27un_ordinateur/Les_transistors_et_portes_logiques).
+
+> Question 0 : Faîtes une table de correspondance français/anglais pour ET, OU, NAND, NOR, XOR, NON
+
+> Question 1 : Retrouvez et recopiez la décomposition en transistors des portes NON, NAND et NOR.
+
+> Question 2 : Avec par exemple des couleurs, représentez sur ces schémas les différentes combinaisons d'entrées et les états intermédiaires associés. Par exemple, si la couleur verte correspond aux entrées A=0 et B=1, écrivez en vert sur chaque fil la valeur présente 0 ou 1.
+
+À partir d'ici nous utiliserons les symboles des portes logique plutôt que le détail des transistors.
+
+> Question 3 : En vous inspirant du plan transistor de ET et OU de la page Wikibooks, concevez les portes ET et OU à partir des symboles correspondant aux portes déjà décrites NON, NAND et NOR.
+
+
+Tables de vérité
+----------------
+
+Vérifiez la construction précédente du ET à partir des tables de vérité.
+
+> Question 4 : Écrivez les tables de vérité de NAND, de NON et vérifiez que leur composition donne bien ce qui est attendu pour ET.
+
+
+
+Expressions booléennes
+----------------------
+
+> Question 5 : Parenthésez selon les priorités
+> - a + b . c + ¬ a . d
+> - a . a + a . ¬ a + ¬ a
+
+
+> Question 6 : Simplifiez les expressions suivantes
+> - a . a + a . ¬ a + ¬ a
+> - (a + (b + ¬b) + (c.¬c)).a
+
+
+> Question 7 : Distribuez au maximum
+> - (a + b).(c + ¬d).¬(a+b)
+> - ¬(a.b).c
+
+
+> Question 8 : Factorisez au maximum
+> - a.c + a.b + a.¬d
+> - ¬a.c + ¬b.c
+
+
+> Question 9 : Tracez sous forme d'arbre (un nœud = une fonction logique)
+> - a + b . c + ¬ a . d
+> - a . a + a . ¬ a + ¬ a
+
+
+Tables de Karnaugh
+------------------
+
+Les [tables de Karnaugh](https://fr.wikipedia.org/wiki/Table_de_Karnaugh) permettent de simplifier les expressions booléennes complexes.
+
+> Question 10 : Simplifiez l'expression (¬a.b.c) + (¬a.b.(¬c+d)) + (¬a.b.¬d) + a.b.d + a.b.c + a.b.(¬c+¬d) + ¬c.¬d.¬(a+¬b) + ¬a.¬b.¬c.¬d + ¬a.¬b.¬c.d en utilisant une table de Karnaugh

td5-additionneur.md

@@ -0,0 +1,44 @@
+TD5 Additionneur et bascule
+===========================
+
+Additionneur
+============
+
+Nous allons concevoir un additionneur à 2 bits, en plusieurs étapes.
+
+1/2 additionneur
+----------------
+
+Le 1/2 additionneur fait l'addition et expose la retenue en sortie, mais ne gère pas de retenue en entrée. Il a donc 2 entrées a et b à additionner, et 2 sorties s (somme) et c (carry, retenue).
+
+> Question 1 : Écrivez les tables de vérité souhaitées pour s et c en fonction de a et b. Une fois écrites, à quelles fonctions logiques connues correspondent ces deux tables ?
+
+> Question 2 : Tracez, avec des portes logiques, le schéma de ce demi-additionneur.
+
+
+Additionneur 1 bit
+------------------
+
+L'additionneur 1 bit permet de gérer la retenue en entrée. Il a donc 3 entrées a, b et c<sub>in</sub> (retenue en entrée), et 2 sorties s et c<sub>out</sub>.
+
+> Question 3 : Écrivez les tables de vérité souhaitées pour s et c<sub>out</sub> en fonction de a, b et c<sub>in</sub>. Une fois écrites, à quelles fonctions logiques connues correspondent ces tables ?
+
+> Question 4 : Tracez, avec des portes logiques, le schéma de cet additionneur. Indice : Pour un additionneur, il faut 2 demi-additionneurs en cascade + un OU pour gérer la retenue.
+
+
+Additionneur 2 bits
+-------------------
+
+L'additionneur 2 bits permet d'additionner 2 nombres sur 2 bits, sans retenue en entrée (mais donc une retenue intermédiaire + une sortie matérialisant qu'il y a eu débordement, ie, une retenue finale). Il a donc 4 entrées a<sub>0</sub>, a<sub>1</sub>, b<sub>0</sub> et b<sub>1</sub>, et 3 sorties s<sub>0</sub>, s<sub>1</sub> et c (débordement)
+
+> Question 5 : Tracez, avec des portes logiques, le schéma de cet additionneur 2 bits.
+
+
+Bascules
+========
+
+La bascule est un élément permettant de conserver un état transitoire, par exemple pour faire une mémoire. Vous trouverez la description du verrou RS [ici](https://fr.wikipedia.org/wiki/Bascule_(circuit_logique)#Verrou_RS_avec_porte_NON-OU), avec des portes NOR ou NAND.
+
+> Question 6 : Avec des couleurs, représentez sur les schémas en portes logiques les différentes combinaisons d'entrées et les états intermédiaires associés. Par exemple, si la couleur verte correspond aux entrées S=0 et R=1, écrivez en vert sur chaque fil la valeur présente 0 ou 1.
+
+> Question 7 (bonus) : Faîtes de même pour d'autres bascules (verrou D, bascule D, ...)

tp1-encodage-p2.md

@@ -33,11 +33,31 @@ Il est donc indispensable pour tous les acteurs (autant matériels que logiciels
 _[https://xkcd.com/927/](https://xkcd.com/927/)_
 
 
-Bonus : Base64
-==============
+Base64
+======
 
 L'encodage binaire->texte le plus couramment utilisé est le Base64, dont vous trouverez la description [ici](https://fr.wikipedia.org/wiki/Base64).
 
-> Question 7 : Refaîtes l'encodage et le décodage de votre message en Base64
+> Question 7 : Refaîtes l'encodage et le décodage de votre message en Base64 (avec le détail des étapes, pas un outil en ligne)
 
 > Question 8 : Quelle est l'efficacité de Base64 ?
+
+
+Base45 et Base85 (Bonus)
+========================
+
+Les encodages [Base45](https://billatnapier.medium.com/so-what-is-base-45-and-where-is-it-used-1ab53279d705) et [Base85](https://fr.wikipedia.org/wiki/Ascii85) sont des alternatives au Base64. Base45 est par exemple utilisé pour l'encodage de binaire dans des QR-codes (qui ne représentent que du texte) et Base85 se retrouve dans le format PDF. Il y a donc 45 ou 85 symboles, ce qui n'est pas une puissance de 2. La conversion oblige à réaliser des changements de base par division euclidienne.
+
+> Question 9 : Refaîtes l'encodage et le décodage de votre message en Base45 et/ou en Base85 (avec le détail des étapes, pas un outil en ligne)
+
+
+Compte-rendu
+============
+
+Votre compte-rendu sera évalué autant sur le fond que sur la forme.
+
+Il doit contenir les réponses aux questions, le déroulé de votre travail ainsi que les descriptions de votre système d'encodage (symboles, procédure d'encodage, procédure de décodage) et du système d'encodage choisi collectivement (symboles, procédure d'encodage, procédure de décodage). Évidemment, la description du système d'encodage collectif sera beaucoup plus succincte et synthétique, mais vous rendrez compte brièvement de la discussion ayant eu lieu lors de cette partie. Si c'est votre système qui a été retenu collectivement, vous devez présenter un autre système (le 2è, celui du message reçu, ou ...) dans cette partie en précisant cela. Une attention particulière doit être apportée à la clarté des explications.
+
+Il doit être bien présenté et structuré. Il doit impérativement mentionner, sur la première page, le nom de la matière, le numéro et nom du TP ainsi que les **noms, prénoms et groupe** des 2 membres du binôme. Tout prénom/nom absent des documents déposés recevra 0 au TP.
+
+Le compte-rendu doit être déposé sur Moodle au format PDF uniquement. Un dépôt par binôme suffit.

tp1-encodage.md

@@ -5,7 +5,7 @@ Nous partitionnons classiquement en informatique les fichiers entre fichiers tex
 
 Dans ce TP, vous allez concevoir et analyser un système d'encodage du binaire vers du "texte", ainsi que le décodage associé.
 
-> Si vous souhaitez approfondir les notions après le TD, les pages Wikipedia associées : [fichier texte](https://fr.wikipedia.org/wiki/Fichier_texte), [fichier binaire](https://fr.wikipedia.org/wiki/Fichier_binaire), [conversion binaire/texte](https://fr.wikipedia.org/wiki/Conversion_du_binaire_en_texte).
+> Si vous souhaitez approfondir les notions après le TP, les pages Wikipedia associées : [fichier texte](https://fr.wikipedia.org/wiki/Fichier_texte), [fichier binaire](https://fr.wikipedia.org/wiki/Fichier_binaire), [conversion binaire/texte](https://fr.wikipedia.org/wiki/Conversion_du_binaire_en_texte).
 
 > Ce TP est à réaliser en binôme. Un compte-rendu devra être déposé sur Moodle, en format PDF uniquement. Un seul compte-rendu par binôme suffira (pensez bien à mettre les 2 noms sur le document !)
 

tp3-demontage.md

@@ -0,0 +1,45 @@
+TP3 (Dé)montage d'un ordinateur (1h30)
+======================================
+
+Vous avez un ordinateur, un tournevis, et 1h30 devant vous. Durant ce temps, votre mission, que vous ne pouvez refuser :
+- ouvrir un ordinateur
+- démonter tout ce que vous pouvez
+- remonter pour le groupe suivant
+
+Le dernier point est extrêmement important et évidemment le plus proche de l'impossible : puisque les mêmes ordinateurs vont être utilisés pour tous les groupes TP, votre boîtier doit être remis en état correct (permettant son re-démontage) avant la fin de la séance. Vous prévoirez impérativement les 30 dernières minutes pour cela.
+
+> Ce TP est à réaliser en binôme. Un compte-rendu devra être déposé sur Moodle, en format PDF uniquement. Un seul compte-rendu par binôme suffira (pensez bien à mettre les 2 noms sur le document !)
+
+
+Les composants
+==============
+
+Commencez par ouvrir le boîtier.
+
+> Question 1 : Trouvez et repérez sur la photo l'alimentation, la carte mère, le CPU, la RAM, le disque dur, les éventuels lecteurs de disques et cartes d'extension.
+
+> Question 2 : Trouvez la référence de la carte mère et retrouvez ses spécifications précises sur Internet.
+
+> Question 3 : Retirez les barrettes de RAM, trouvez leur référence et leur spécification complète (recherche internet).
+
+> Question 4 : Retirez le ventirad sur le CPU et accédez au CPU. Détachez le CPU de la carte-mère (il y a une manipulation souvent avec un levier). Pouvez-vous trouver la référence du CPU ? Quel est le type de socket ?
+
+> Question 5 : Observez tous les connecteurs branchés sur la carte mère. Sur une photo, légendez l'usage de chaque connecteur. Assurez-vous que la photo permette bien d'observer les couleurs des fils pour vous aider si besoin lors du remontage.
+
+> Question 6 : Retirez le disque dur du boîtier et essayez de l'ouvrir. Décrivez l'intérieur en légendant une photo. (Attention, ne faîtes jamais cela sur un disque dur utilisé, l'ouverture va le rendre inutilisable si c'est un disque à plateaux)
+
+> Question 7 : Sortez l'alimentation du boîtier. Quels types de prises avez-vous (noms des connecteurs) ? Quelle est la signification des couleurs de câbles ? Ouvrez la. Reconnaissez-vous certains éléments ? Légendez une photo.
+
+> Question 8 : Retirez la carte mère, si possible sans débrancher tous les fils type USB ou boutons/voyants de façade (il y a normalement la longueur pour poser la carte mère sur le boîtier ; lors du montage, quand c'est possible, on branche les fils *puis* on met la CM à sa place dans le boîtier)
+
+
+Compte-rendu
+============
+
+Votre compte-rendu sera évalué autant sur le fond que sur la forme.
+
+Il doit contenir les réponses aux questions, le déroulé de votre travail ainsi que vos photos d'illustration légendées. Une attention particulière doit être apportée à la clarté des explications.
+
+Il doit être bien présenté et structuré. Il doit impérativement mentionner, sur la première page, le nom de la matière, le numéro et nom du TP ainsi que les **noms, prénoms et groupe** des 2 membres du binôme. Tout prénom/nom absent des documents déposés recevra 0 au TP.
+
+Le compte-rendu doit être déposé sur Moodle au format PDF uniquement. Un dépôt par binôme suffit.