cours 1 et 2 complets

1ComputationAndData.md

@@ -0,0 +1,18 @@
+Cours de Pierre.
+
+# Système de fichier, Codage et découverte du terminal. I/II
+
+## Terminal à la linux
+
+Installation Ubuntu sous windows (WSL, ubuntu via couche machine virtuelle hyperV).
+https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux
+
+Autres étudiants avec Mac et un shell ("BSD"?)
+
+## Arborescence fichier
+répertoire (noeuds internes) vs
+Fichier (feuilles)
+
+## Codage
+Codage, en particulier binaire et ASCII.
+Exemple avec les salles de la fac de droit en binaire.

2ComputationAndData.md

@@ -0,0 +1,362 @@
+Cours de Florent.
+
+# Système de fichier, Codage et découverte du terminal II/II
+
+## Éditeur et fichier texte
+
+Qu'on programme ou qu'on prépare un mail, il faut éditer un fichier texte.
+Ce texte va transiter sur le réseau ou être stocké dans un fichier selon un code bien choisi. 
+
+Le code ASCII est inspiré de code pour le télégraphe, comme le code Baudot (1870) : c'est un standard américain initialement pour teleprinter (Bell lab 1961). Il comporte en plus des codes pour des caractères imprimables (chiffres, lettres minuscules et majuscules latines, etc) de nombreux codes pour des opérations spécifiques au mécanisme de communication d'un teleprinter maintenant obsolètes.
+
+[Code Baudot](https://en.wikipedia.org/wiki/Baudot_code)
+[ASCII](https://en.wikipedia.org/wiki/ASCII)
+
+### digression
+L'ordre des charactères induit par la valeur de leur code ASCII est utilisé pour trier du texte ASCII.
+> ASCII-code order is also called ASCIIbetical order
+
+Trier, stocker, indexer et chercher de l'information sont des tâches essentielles qu'on automatise dès la fin du XIXe siècle.
+
+Pour automatiser le recensement américain (le census de 1880 a demandé 8 ans...), Herman Hollerith met au point une machine electro-mécanique manipulant des cartes perforées et flottant dans des bains de mercure. Son entreprise et 4 autres forment un conglomérat qui deviendra IBM en 1924.
+
+[Machines à tabuler](https://en.wikipedia.org/wiki/Tabulating_machine)
+
+### Et si notre alphabet est plus grand?
+Pour tester un clavier, ou exhiber une fonte, on peut en anglais écrire.
+> The quick brown fox jumps over the lazy dog
+
+En français, on pourra utiliser
+> Dès Noël, où un zéphyr haï me vêt de glaçons würmiens, je dîne d’exquis rôtis de bœuf au kir, à l’aÿ d’âge mûr, &cætera.
+
+[tester un clavier](https://fr.wikipedia.org/wiki/The_quick_brown_fox_jumps_over_the_lazy_dog)
+
+De nombreux pays vont donc étendre/changer le code ASCII pour y introduire leurs symboles (par exemple les accents en français) avec un soucis d'internationalisation.
+En effet, le code ascii ne peut pas facilement accommoder tous les alphabets même si on se restreint aux alphabets latins ou grecs car nous avons seulement 7 bits soit 2^7=128 codes.
+On ajoute donc un bit de plus pour permettre d'échanger des données textuelles "internationales".
+
+[ISO/IEC 8859](https://en.wikipedia.org/wiki/ISO/IEC_8859)
+
+Il y a en fait 15 variantes selon les besoins de langues avec des besoins proches.
+Un des plus connu, adapté pour le français, est la version 1
+
+[latin-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
+
+Ces systèmes restent trop limités car ni vraiment adapté pour de la typographie, ni applicable pour tous les alphabets en usage. 
+Depuis 2008, le standard est l'UTF-8 (sur le web initialement). 
+C'est une abbréviation de
+
+> Unicode Transformation Format – 8-bit
+
+où Unicode signifie
+
+> Universal Coded Character Set
+
+Une idée intéressante de ce code est qu'on va utiliser un **nombre variable de bytes** (entre 1 et 4). 
+Typiquement ce qu'on codait en ASCII prendra 1 byte, toutes les langues couvertes par la norme ISO 8859 pourront coder leurs caractères avec au plus 2 bytes, les caractères fréquents de CJK avec 3 bytes et le reste avec 4 permet de coder des symboles moins fréquents (de math, des emoji etc). 
+
+[UTF-8](https://en.wikipedia.org/wiki/UTF-8)
+
+## Discussion au tableau de UTF-8
+Calcul du nombre de symboles qu'on peut coder.
+Perte de place pour les symboles codés par 1 bloc, 2 blocs, 3 blocs, 4 blocs.
+
+évocation du changement de pratique autres systèmes de codage vs UTF-8 (graphiques sur wikipedia).
+
+### Détails techniques de WSL
+
+Le système de fichier linux WSL est monté dans le système windows.
+On peut a priori transférer des fichiers vers windows mais pas l'inverse.
+
+Linux ne permet a priori pas d'accéder au système de fichier windows.
+
+Attention. si vous réinstallez WSL vous allez écraser votre home et tout le travail fait sous linux.
+
+[Où est le home linux sous WSL](https://superuser.com/questions/1185033/what-is-the-home-directory-on-windows-subsystem-for-linux)
+
+Vous pouvez lancer dans l'explorateur de fichier windows le home linux en saisissant dans votre terminal linux la commande suivante.
+
+```bash
+explorer.exe .
+```
+
+Si vous avez installé WSL sans créer de compte utilisateur, vous êtes l'administrateur système linux, connu sous le nom de root. L'invite du terminal indique un dièse \#
+
+Pas de danger vous ne pouvez rien casser dans le système windows.
+
+Par contre par défaut vous êtes dans ... system32 le répertoire système de windows.
+Le système winos ne vous laisse pas écrire de fichier à cet endroit.
+Il faut vous placer ailleur, par exemple en saisissant la commande suivante.
+
+
+```bash
+cd
+```
+
+
+### explication au tableau de la navigation
+
+   _ .. pour revenir en arrière
+   _ . pour là où on est
+   _ ~ pour votre home linux
+   _ / pour la racine du système de fichier linux.
+
+Question ontologique de l'oeuf ou la poule: qui est le .. de / ?
+
+
+
+### exercice
+
+1. Ouvrez un terminal.
+1. Créer un répertoire folderA (commande mkdir).
+1. Placez vous dans ce répertoire (commande cd, pour change directory).
+1. Créer un fichier vide grapevine.txt (commande touch).
+1. Ouvrez le avec un éditeur de texte (par exemple gedit ou emacs voir nano ou vim).
+1. Copiez dans ce fichier un texte de votre choix avec de nombreux caractères qui ne sont pas codable en ascii.
+1. Sauvez le.
+1. Envoyez un mail avec en pièce jointe ce fichier à votre voisine ou voisin de table.
+1. Ouvrez le fichier de votre voisin, sauvez le sous le nom grapevine2.txt et testez si vous pouvez lire le fichier correctement avec votre éditeur.
+
+Parfois votre éditeur ne détectera pas correctement et automatiquement le codage.
+Vous pouvez dans certains cas forcer ce codage (e.g. dans emacs Options-Multilingual environment).
+
+### exercice
+la commande suivante permet de revenir dans le répertoire parent.
+```bash
+cd .. 
+```
+
+Complétez votre arborescence pour arriver à celle-ci.
+```
+folderA
+  grapevine.txt
+  grapevine2.txt
+  folderAA
+    toto.txt
+    titi.txt
+folderB
+    toto.txt
+folderC
+    tata.txt
+```
+
+NB. vous pouvez le faire sans utiliser un éditeur ni un logiciel de naviguation de fichier graphique. Seulement en ligne de commande.
+
+La commande 
+
+```bash
+man
+```
+permet d'avoir accès au manuel.
+
+testez par exemple
+
+```bash
+man ls
+```
+lisez cette documentation pour chercher l'option qui permet un affichage récursif.
+
+
+**Correction Indicative**
+
+```bash
+mkdir folderA
+mkdir folderB
+mkdir folderC
+cd folderA/
+touch grapevine.txt
+mkdir folderAA
+cd folderAA/
+touch toto.txt
+touch titi.txt
+cd ../
+cd ..
+cd folderB
+touch toto.txt
+cd ..
+cd folderC/
+touch tata.txt
+cd ..
+ls -R
+history | cut -c 8-
+```
+
+NB. la dernière commande permet d'enlever les numéros de l'historique. 
+    Le | (on dit pipe) permet d'envoyer le résultat de history dans la commande cut.
+    La commande cut avec ces options permet d'enlever le numéro de l'historique.
+    C'est d'ailleurs avec cette commande que j'ai fabriqué la correction indicative ci-dessus.
+    
+### exercice
+
+Dans un second temps vous pouvez créer un lien / ou créer un raccourci avec votre système de naviguation de fichier graphique (probablement nautilus sous ubuntu) de grapevine.txt dans le répertoire folderC.
+
+Vous pouvez aussi vous placer vous dans folderC et écrire en ligne de commande
+```bash
+ln -s ../folderA/grapevine.txt
+```
+
+Selon votre configuration en revenant en arrière et en faisant à nouveau un ls avec l'option permettant l'affichage récursif vous allez voir le nom du grapevin.txt sous une couleur différente de l'original.
+
+Nous allons d'abord chercher dans le manuel ce que fait l'option -l de ls
+```bash
+man ls
+```
+puis nous allons tester sur notre lien en faisant
+```bash
+ls -l
+```
+
+Je n'ai pas traité en cours les parties ci-dessous.
+Vous pouvez ouvrir chaque section en cliquant sur le triangle.
+
+<details><summary>Zoom sur les briques élémentaires du système de fichier</summary>
+<p>
+
+
+
+### exercice 
+
+L'arbre de notre système de fichier est fabriqué à partir de 2 éléments.
+    1. une feuille de l'arbre = des données stockées à une certaine adresse dans la mémoire
+    2. un noeud interne de l'arbre = des données stockées à une certaine adresse dans la mémoire qui associe un nom (de fichier ou de répertoire) à un élément de type 1. ou 2. identifiable par le système. En gros le fichier correspondant à un répertoire est une sorte de *livret de famille*.
+    
+En pratique, le système utilise une structure de donnée particulière à la fois pour les fichiers et les répertoires (puisqu'il s'agit dans les deux cas de fichiers) qui s'appelle un [inode](https://en.wikipedia.org/wiki/Inode).
+
+
+En pratique vous pouvez utiliser l'option suivante pour affichier les numéros des inode.
+```bash
+ls -i
+```
+
+### exercice pour aller encore plus loin
+Nous avons évoqué les liens symboliques qui sont des raccourcis.
+Littéralement c'est juste un fichier texte un peu spécial qui contient comme données la chaîne de caractère du fichier vers lequel on pointe.
+
+Donc quand on a fait ci-dessus.
+```bash
+ln -s ../folderA/grapevine.txt
+```
+On a fabriqué un fichier raccourci spécial qui contient essentiellement l'information
+```bash
+../folderA/grapevine.txt
+```
+Si vous utilisez la même commande mais en omettant l'option -s vous êtes en train de définir un nouveau nom pour l'inode du fichier grapevine.txt
+
+Donc la métaphore de l'arbre n'est pas tout à fait correcte puisque par plusieurs chemins dans les répertoires il est possible d'atteindre le même fichier.
+
+La commande de suppression de fichier rm (pour remove) ne supprime pas vraiment l'inode, elle va juste effacer le nom du fichier (et la référence vers l'inode associé à ce nom) dans le répertoire.
+
+[Détails sur stackoverflow](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
+
+NB. Je n'ai pas testé sous WSL puisque je n'ai pas windows. Il serait amusant de regarder ce qui arrive aux fichiers linux avec plusieurs noms quand on les regarde en vue détaillée dans l'explorateur de fichier de windows. A priori NTFS a une notion compatible
+
+</p>
+</details>
+
+
+### Commandes utilisées jusqu'à présent
+```bash
+mkdir
+cd
+touch
+ls
+ln
+```
+
+<details><summary>Manipuler du texte avec la commande tr</summary>
+<p>
+
+## Manipulation de fichier
+
+Pour simplifier un texte, par exemple pour l'indexer ou pour normaliser un nom dans une base de données il est fréquent qu'on bascule un mot en majuscule.
+Nous allons travailler avec la commande tr qui permet de faire de tel changement caractère par caractère.
+Par exemple ceci permet de transformer les minuscules en majuscule.
+
+```bash
+tr '[a-z]' '[A-Z]' 
+```
+La commande tr attend un flux textuel en entrée et transmet un flux textuel en sortie. 
+On parle de filtre pour ce genre de commande.
+On ne peut pas a priori lui passer de fichier en paramètre.
+Il faut *rediriger* le contenu du fichier vers la commande.
+
+```bash
+tr '[a-z]' '[A-Z]' < grapevine.txt
+```
+Par défaut le résultat apparaît à l'écran.
+
+On peut rediriger ce résultat dans un fichier en utilisant >
+
+```bash
+tr '[a-z]' '[A-Z]' < grapevine.txt > grapevineUp.txt
+```
+Vous pouvez consulter le contenu d'un fichier directement en utilisant la commande more
+```bash
+more grapevineUp.txt
+```
+Attention toutefois avec > car le contenu du fichier si il existe est écrasé.
+
+Il existe une variante utile >> qui écrit à la fin du fichier.
+C'est utilisé par exemple pour créer des fichiers de log.
+
+### exercice
+
+Redirigez le résultat de la commande history dans un fichier de sauveguarde myFirstDayWithTheCommandLine.txt.
+
+
+```bash
+history > myFirstDayWithTheCommandLine.txt
+```
+Vous pouvez consulter ce fichier en utilisant more.
+
+Vous pouvez voir le haut du fichier en faisant head, la fin du fichier en faisant tail.
+
+## Code de césar
+
+Cherchez à appliquer le code de césar (rot13) à un fichier contenant du texte non accentué (i.e. ascii historique).
+
+Envoyez le par mail à votre voisin.
+
+Ce dernier doit le décoder.
+
+```bash
+tr '[A-Z]' '[N-ZA-M]'
+```
+</p>
+</details>
+
+
+## droit d'accès
+
+chmod
+
+Il s'agit de la commande permettant de changer les droits pour un fichier.
+
+
+## Bonus : jouons avec le pipe
+
+1. installer fortune
+1. installer cowsay
+
+```bash
+echo moooooo | cowsay
+```
+
+
+```bash
+fortune
+```
+
+
+```bash
+fortune | cowsay
+```
+
+## Bonus : sl
+
+1. installer sl (dans le terminal de votre collègue quand il va boire un café)
+1. demandez lui de vous montrer comment ls fonctionne très rapidement (il va probalement écrire sl au lieu de ls à un moment)
+
+
+
+

3ComputationAndData.md

@@ -0,0 +1,127 @@
+Cours de Florent.
+
+# Calculer en théorie et en pratique I/III
+
+Dans la prochaine séquence de cours, nous allons tenter de répondre à la question suivante.
+
+C'est quoi un ordinateur?
+
+Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.
+
+Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?
+
+Nous allons explorer rapidement ce sujet en évoquant à la fois des modèles théoriques et des explication sur l'architecture matérielle et le fonctionnement d'ordinateurs modernes.
+
+## Calcul Matériel.
+
+Initialement, les "computer" sont des humains, qui s'aident de divers mécanisme pour faire des calculs rapidement en essayant de faire le moins d'erreurs possibles, par exemple avec un boulier ou des cordes nouées. 
+
+Les premières machines à calculer sont mécaniques et peuvent être discrètes (nombre fini de position avec par exemple des roues crantées) ou continues (position continue sur un astrolabe ou une table à tracer pour calculer des intégrales). 
+
+Les machines modernes possèdent différents composants electroniques et ce sont les transistors qui permettent de passer d'une information analogique/continue 
+
+> quelle est la puissance du courant?
+
+à une information discrète, oui ou non, qu'on peut interpréter comme 0 ou 1.
+
+> est-ce-que le courant dépasse un certain seuil?
+
+On peut à l'aide de quelques composants de base faire des calculs sur ces valeurs 0 ou 1. On parle alors de calcul Booléen (du nom du logicien Boole).
+
+### circuit booléen
+consiste en
+1. des entrées contenant des valeurs booléennes.
+1. des portes logiques permettant de calculer
+   * le ET binaire (&) 
+   * le OU binaire (v)
+   * la négation NON unaire (-)
+1. des "cables" pour relier ces portes
+1. des sorties correspondant à la sortie du calcul.
+
+Au tableau
+* table du ET
+* table du OU
+* table du NON
+
+### exercices 
+
+1. Écrire la table de Non de x ou y.
+1. Décrire un circuit permettant de tester si deux entrée x et y sont égales.
+Le circuit doit renvoyer 1 si c'est le cas et 0 sinon.
+NB. on peut noter cette opération <-> ou 
+2. Même question pour le circuit qui permet de calculer le XOR (Ou eXclusif).
+3. Même question pour le circuit permettant de calculer la majorité de trois arguments
+
+### Digression : le schéma de chiffrement de Vernam
+Il s'agit d'un schéma très simple et incassable à moins de connaître la clé secrète.
+L'inconvénient est qu'il faut fabriquer et partager avec son destinataire une clé secrète aussi longue que le message. On parle aussi de "one time pad" en anglais.
+
+Pendant la seconde guerre mondiale, à Bletchley Park, des opératrices fabriquaient de telles clés mais en quantité trop réduite. Une tentative de mécanisation pour pallier à ce soucis a permis de générer des clés rapidement mais qui avaient une différence avec les véritables clés.
+
+
+> 
+
+    "Enoch, why are you . . . here?"
+
+    "Oh. I am here, in a larger sense, because Mrs. Tenney, the vicar’s wife, has become sloppy, and forgotten to close her eyes when she takes the balls out of the bingo machine."
+
+Neal Stephenson. Cryptonomicon.
+
+[Discussion sur stackexchange](https://crypto.stackexchange.com/questions/25214/has-human-generated-entropy-ever-been-a-real-problem)
+
+
+Nous allons mettre en oeuvre ce chiffrement.
+1. Tout d'abord le message à chiffrer M, qu'on suppose encodable en ASCII est transformé en un séquence de 0 et de 1 qu'on note B.
+1. La clé secrète S est une série de 0 et de 1 de même longueur.
+1. On additionne "modulo 2" B à S pour obtenir le message chiffré C (c'est le XOR de tout à l'heure).
+1. On transmet le message chiffré C au destinataire.
+1. La destinataire reçoit C.
+1. Pour décoder, elle procède de même mais à l'envers.
+   * ajout de S à C
+   * découpage en bloc de 7 bits
+   * décodage ASCII
+   
+[page du code ASCII](https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange)
+   
+NB. pour faire plus proche de la réalité, on préfixe le code ASCII d'un 0 pour obtenir un octet.
+
+### exercice
+Nous allons mettre en oeuvre ce chiffrement pour le mot BINGO.
+Fabriquez au préalable une clé de la taille adapté
+(vous pouvez par exemple tirer à pile ou face successivement). 
+
+Pour simplifier, vous pouvez le faire avec OK.
+
+Réfléchissez à une mise en oeuvre pratique sur papier.
+
+## Retour à nos circuits.
+
+Nous allons maintenant mettre en oeuvre des circuits pour faire des opérations arithmétiques.
+
+
+1. Même question pour un circuit qui réalise une somme "modulo 2"
+   NB. c'est le chiffrement de Vernam.
+1. Même question pour un circuit qui réalise une somme en binaire.
+   Pour ce second circuit on s'autorise une porte de duplication notée D qui prend en entrée x et a deux sorties valant toutes deux x.
+
+### Indication.
+Pour rappel en binaire 1+1 vaut 10; 1+0 comme 0+1 valent 1; et, 0+0 vaut 0.
+
+**Exemple**
+```
+0110
+0111
+====
+...1
+..01 retenue 1
+.101 retenue 1
+1101 Fin
+```
+### Indication 2
+2 questions rhétoriques :
+
+  * Comment faire la retenue?
+  * Comment calcule la somme dans la même colonne?
+
+
+

4ComputationAndData.md

@@ -0,0 +1,134 @@
+Cours de Florent.
+
+# Calculer en théorie et en pratique II/III
+
+Dans cette séquence de cours, nous tentons de répondre à la question suivante.
+
+C'est quoi un ordinateur?
+
+Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.
+
+Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?
+
+Nous avons vu une approximation de calcul théorique basé sur le calcul booléen et des portes logiques qui sont implémentable avec des composants electroniques, permettant de réaliser divers opérations comme l'addition bit à bit (schéma de Vernam en cryptographie), la majorité ou encore l'addition avec retenue.
+
+Aujourd'hui nous poursuivons avec un modèle théorique, qui est celui de l'**automate fini**, un modèle assez restreint de machine. L'adjectif fini s'applique à la mémoire de la machine qui est finie.
+
+Nous verrons plus tard un modèle plus général avec une mémoire arbitrairement grande : la machine deTuring. 
+
+## Le modèle d'automate fini.
+
+* La machine va lire en entrée un mot sur un alphabet A de taille finie (on peut par exemple imaginer qu'il s'agit d'un mot en binaire et l'alphabet A serait par exemple composé des symboles 0 et 1).
+* La machine possède plusieurs états. Intuitivement, chaque état code pour ce qu'on stocke dans la mémoire finie de la machine.
+* Certains états sont dit **acceptant**.
+* Un état spécial est celui dans lequel la machine débute son calcul. C'est l'**état initial**.
+* La machine va "manger" le mot d'entrée lettre par lettre et passe d'un état à l'autre selon ce que son **programme** lui dicte.
+* Quand toutes les lettres sont lues, si l'état dans lequel la machine se trouve est acceptant, la machine répond OUI (elle **accepte** le mot) sinon elle répond NON (elle **rejette** le mot).
+* L'ensemble des mots sur l'alphabet A qui sont acceptés par la machine forme le *langage reconnu par l'automate*.
+
+### Le programme de l'automate.
+On peut l'écrire dans un tableur, sous forme d'une succession fini de lignes avec trois colonnes. 
+La première colonne est l'état actuel, la seconde colonne est la lettre lue, la troisième colonne est le nouvel état.
+
+Pour un état donné q et une lettre lue x, l'automate va se placer dans un état donné q' (il est possible que q et q' soit le même état).
+
+Si le programme est incomplet et que le tableur n'explique pas comment faire, on arrête le calcul et on rejette le mot.
+
+Si le tableur n'est pas ambigu et que on n'a jamais deux lignes indiquant pour la même paire de lettre lue et d'état un nouvel état différent, on dit que l'automate est **déterministe**.
+
+Sinon l'automate n'est pas déterministe -- on dit aussi **non-déterministe** -- et on considère que la machine peut choisir une action du tableur parmi celles qui sont listées.
+
+Pour un automate non déterministe, on considère qu'un mot est accepté si il existe un calcul qui accepte.
+
+Analogie : vous cherchez à sortir d'un labyrinthe, il y a de nombreux chemins possibles. Si il en existe un vers la sortie alors vous pouvez gagner au jeu du labyrinthe. 
+
+## Exemples avec JFLAP.
+
+JFLAP est un logiciel de simulation de machines théoriques qui permet de définir, manipuler, exécuter et transformer des machines. En pratique c'est une archive jar.
+
+Une archive jar est un programme codé dans le langage java que vous pouvez exécuter.
+L'archive se compose de divers fichiers, dont un fichier principal, des librairies etc.
+
+Pour utiliser le logiciel, vous devez commencer par installer java.
+Suivez les recommandations de votre système d'exploitation.
+
+Ensuite, il vous suffit souvent de double-cliquer sur l'archive jar.
+
+Vous pouvez aussi en ligne de commande sous linux écrire.
+
+```bash
+java -jar <nom de l'archive jar>
+```
+Sur les machines virtuelles, 
+
+### Prise en main de JFlap.
+
+1. Lancez JFLAP et ouvrez [l'automate sauvegardé ici](https://www.lacl.fr/fmadelaine/Download/M1Droit/Automates/TP2NDA.jff)
+2. Allez dans le menu *Input* et choisissez *Step by State*. Entrez le mot **babb** et observez la simulation des exécutions parallèles étape par étape en appuyant sur *step*. 
+3. Testez ensuite avec le mot **baaa**.
+4. Relancez les tests ci-dessus. Cette fois essayez les autres
+  options.
+  * *Reset* permet de revenir au début du calcul
+  *  *Trace* après sélection en bas d'une exécution permet
+    de montrer cette exécution depuis le début.
+  *  *Remove* élimine l'exécution sélectionnée
+  *  *Freeze*/*Thaw* permet de mettre en pause ou de
+    reprendre une exécution (on perd la synchronisation)
+5. Vous pouvez aussi tester sans les étapes avec *Fast Run*
+  voir plusieurs entrées en même temps avec
+  *Multiple Run*   (tous les deux dans le menu *Input*).
+  Faites le par exemple pour les deux mots précédents.
+6. Pour information, *Step with closure* fait la même chose
+  que *step by State* sauf pour les automates ayant des
+  transitions avec le mot-vide (mais on ne les considère pas dans
+  ce cours).
+
+### Hello World
+Votre but est de créer l'automate dessiné ci-dessous.
+
+    ![images/HelloWorldAutomate.jpg]
+
+1. Cliquez sur *File* puis *New*.
+2. JFLAP permet de gérer différents modèles de calcul. Nous allons
+  nous en tenir aux automates finis. Cliquez sur *Finite Automaton*.
+  Vous avez accès à une nouvelle fenêtre en mode éditeur.
+  * Cliquez sur le petit cercle avec un q à l'intérieur, puis sur
+    le canevas pour ajouter des états.
+  *  Les deux derniers boutons permettent de faire du undo/redo.
+  *  La flèche fine permet d'ajouter une transition entre 1 ou 2
+    états (ne pas oublier de mettre une lettre).
+  *  La flèche plus épaisse à gauche permet de sélectionner,
+    déplacer, éditer les propriétés des différents éléments (par
+    exemple de faire un état initial).
+  *  La tête de mort permet de détruire des états ou des transitions.
+
+### Exercices
+Dessinez les automates qui reconnaissent :
+
+(pour l'alphabet $\{a,b\}$) 
+
+1. les mots de 2 lettres;
+2. les mots contenant exactement 2 a;
+3. les mots contenant 2 a consécutifs;
+4. les mots commençant par b;
+5. les mots se terminant par bab;
+6. le langage réduit au mot vide;
+
+(pour l'alphabet $\{a,b,c\}$)
+
+7. les mots qui contiennent $aabcc$;
+8. les mots de taille multiple de 3;
+9. les mots de la forme abcabcabc... (une ou plusieurs successions des 3 lettres abc);
+10. les mots dont la première lettre est égale à la dernière. 
+
+<details><summary>Calcul modulaire en base 2</summary>
+<p>
+
+### Compter avec les automates
+On ne le verra pas dans ce cours, mais il est possible d'établir que le modèle des automates ne permet pas de compter. Par exemple, on ne peut pas lire une expression avec des parenthèses et vérifier qu'il y a autant de parenthèses ouvrantes que de parenthèses fermantes. On ne peut pas non plus vérifier que les parenthèses correspondent bien. Ainsi ce modèle n'est pas suffisant pour vérifier par exemple qu'une chaîne de caractères est un programme suivant un syntaxe fixée du C.
+
+Par contre, on peut compter facilement modulo N, puisque celà revient à se souvenir 
+
+
+</p>
+</details>