* lundi 15/9. Architecture : mémoire, processus etc.
* lundi 29/9. Modèle de calcul des automates finis.
* lundi 6/10. Machine virtuelle à pile (MVàP).
* lundi 13/10. Fin MVàP + révisions
à planifier un examen sur table.
Ce cours est un peu réduit par rapport aux autres années (moins de séances).
Pas de détails sur le codage des fichiers dont le texte (ASCII, UTF-8), ni sur le système des fichiers (arborescence, comment c'est codé etc), ni sur les commandes unix.
### Anglais
L'objectif est de travailler en anglais (écouter, écrire, discuter) autour de sujets en lien avec l'informatique, soit historique, soit plus récents et en lien avec le droit.
* lundi 17/11. Présentation de page du manuel unix en anglais.
Discussion d'articles de Alan Turing.
Présentation de ressources en anglais pour continuer la suite du cours sous la forme d'un séminaire participatif.
* lundi 8/12. à organiser selon choix sujets étudiants
* lundi 15/12. à organiser selon choix sujets étudiants
évaluation en cours: participation + présentation en petit groupes.
Un peu de background sur l'architecture, en particulier la hiérarchie de la mémoire d'une machine moderne. Illustration sur mon portable.
* Registres : une dizaine 64 bits chaque.
* Cache L1, L2, L3 : entre la RAM et les registres, quelques Mo (ma méchine 16 Mo Bytes).
* RAM : plusieurs Giga (mémoire vive) 32 Ga sur ma machine
* Disque : 1 Tera.
à chaque étage, on fait en gros fois 1000. La vitesse d'accès (et le prix) est inversement proportionnel.
Explication : assembleur pour chaque famille de processeur (dépend du fabriquant AMD ou Intel)
En pratique: on a souvent un assembleur abstrait indépendant du matériel.
La traduction d'un code de haut niveau se fait en deux temps. D'abord du langage de haut niveau vers cet assembleur, puis de cet assembleur vers le véritable assembleur du constructeur du processeur.
Évocation Loi de Moore : doublement de la mémoire dans les années 80, 90, viser le bon bussiness plan car projet prend 10 ans entre début et livraison des premiers clients.
Évocation: partage de la RAM entre chaque processus.
Un processus a une pile (pour les choses petites) et un tas (pour les choses grandes). Sur la pile on indique l'adresse de quelque chose de gros dans le tas.
Rappel des instructions élémentaires pour faire des calculs sur la pile (pousser un entier, 4 opérations arithmétique). Exemple d'un calcul de moyenne avec deux notes et des coefficients différents.
Présentation de l'intérêt d'avoir des variables dans la pile, et des entrées sorties avec l'utilisateur. Exemple avec le cacul de la moyenne précédent.
Évolution du calcul de la moyenne, avec l'apparition d'un maximum. Il est nécessaire de pouvoir dépasser le stade d'instructions successives systématiques et d'avoir des blocs d'instructions, avec des sauts, en particuliers des sauts conditionnés ou résultat d'un test.
Formalisation d'un if-then-else avec la MVàP.
Évocation de boucles. Formalisation d'une boucle while.
Arbre syntaxique de l'expression pour générer le code à pile dans le bon ordre.
On remarque que l'expression peut s'écrire plus simplement en
$$ a^2 -1 $$.
Arbre syntaxique de cette expression simplifiée pour générer le code à pile dans le bon ordre.
#### Révisions automates finis
Rappel vocabulaire automate.
* Alphabet formée d'un nombre fini de symboles lus par l'automate,
* états (initial un seul, acceptant plusieurs possibles) en un nombre fini
* calcul dans l'automate pour un mot en entrée, succession de état initial, première lettre, un état, une lettre lue etc.
* Si dernier état (après la dernière lettre) est acceptant, on accepte le mot, sinon on rejette.
On peut donner l'automate de 2 manières équivalentes.
* soit graphiquement
* soit sous forme de table de transition
Si un calcul s'arrête en cours de mot on rejette. Cette situation correspond à une case vide de la table de transition.
On peut remédier à cet aspect en ajoutant un état poubelle non acceptant (nommons le KO) en dernière ligne de la table de transition (avec KO partout, c'est un puit, on y reste coincé). En jargon de théorie des langages, on dit qu'on complète l'automate.
Exercices de révision.
On se place sur l'alphabet a,b.
Proposez un automate en expliquant bien le rôle des états pour les langages ci-dessous.
Pour chaque langage, proposez un mot accepté et un mot rejeté puis illustrer le fonctionnement de votre automate en donnant le chemin de calcul pour ces 2 exemples.
1. Le langage qui contient juste le mot ab.
2. Le langage formée des mots qui contient ab (de la forme n'importe quoi puis ab puis n'importe quoi, n'importe quoi pouvant être vide).
###### Le langage formée des mots qui contient ab (de la forme n'importe quoi puis ab puis n'importe quoi, n'importe quoi pouvant être vide).
On peut reprendre l'automate déterministe précédent. Il suffit de transformer l'état qab en un puit acceptant (on a rencontré le motif ab on est content).
| état | a | b |
|:----------------|:----|:----|
| q0 (initial) | qa | qb |
| qa | qaa | qab |
| qb | qba | qbb |
| qaa | qaa | qab |
| qab (acceptant) | **qab** | **qab** |
| qba | qaa | qab |
| qbb | qba | qbb |
**Retour sur le non déterministe.**
Si on a queleque part dans la table de transition deux états ou plus dans une case, on a un choix.
Dans ce cas un calcul peut en fait avoir plusieurs branches.
On a un **arbre de calcul** plutôt qu'un chemin unique.
On accepte un mot, si l'arbre de calcul a un chemin acceptant.
On peut facilement produire par exemple un automate non déterministe pour les mots qui terminent par ab.
On a vu en cours l'arbre de calcul pour le mot abab.
Il y a trois chemins acceptants dont un seul accepte en terminant dans l'état acceptant.
Peut-on toujours trouver un automate déterministe?
Oui. On peut fabriquer un automate qui simule en parralèle tous les chemins de calculs.
JFLAP permet de faire la transformation.
