Commandes Linux

Introduction

Le but de cet article est de fournir une introduction utile et pratique de la technique des machines à états finis. Dans cet article, l’accent sera mis sur le côté pratique de la définition et de l’explication, plutôt que sur les concepts théoriques et mathématiques lourds qui sous-tendent la technique. 

Une Machine à Etats c’est quoi?

Les développeurs ont besoin aujourd’hui de trouver des astuces leur permettant de réduire les délais de mise sur le marché tout en augmentant la fiabilité et la maintenabilité du code. L’un des outils que beaucoup de développeurs connaissent mais n’utilisent pas souvent est la machine à états. C’est d’autant plus vrai pour les informaticiens autodidactes qui n’ont pas été formés par des professeurs d’informatique. Les machines à états sont l’un des outils les plus simples et utiles que nous avons à notre disposition. Elles permettent de diviser les algorithmes complexes et pénibles en petits éléments faciles à gérer. Les machines à états introduisent une architecture de programmation qui peut être utilisée pour implémenter n’importe quel algorithme qui peut être explicitement décrit par un diagramme d’état ou un organigramme. Les machines à états sont devenues extrêmement populaires et ont aidé les développeurs de jeux à construire des jeux amusants.

La machine à états est un mécanisme abstrait qui possède un certain nombre d’états prédéfinis. Suivant l’usage prévu les données fournies à la machine entraînent un changement d’état. Nous nous intéressons ici aux machines à états finis (qui ont un nombre fini d’états) implémentées dans des logiciels et matériels. Nous examinerons un certain nombre d’exemples.

Les petites machines à états sont représentées par des diagrammes à bulles, chaque bulle représentant un état de repos. Voir Figure 1. Les lignes entre les états sont appelées des transitions. Une machine à états ne peut avoir qu’un seul état à la fois, ne peut passer d’un état à un autre qu’en respectant des transitions prédéfinies et des conditions indiquées. 

Exemple d’une machine à états basique

Dans l’exemple, la machine à états recherche les occurrences des lettres «A» et «B» dans un flux de texte. (D’où vient le texte et comment la machine à états détecte les caractères? Les détails ne sont généralement pas exprimés sur le diagramme).

Lorsqu’un ‘A’ est détecté dans le flux à l’état 0, la machine effectue une transition de l’état 0 à l’état 1, en suivant la direction de la flèche. Si un ‘B’ est détecté dans l’état 1, une transition est faite vers l’état 0. Comme la machine à états ne peut avoir qu’un seul état à la fois, l’état actif indique si le dernier caractère détecté était «A» ou «B». Il est concevable qu’un autre caractère puisse être reçu (‘C’), auquel cas aucune transition ne se produit.

Figure 1 – Machines à états basique

C’est un exemple trivial, bien sûr. Dans la réalité, des actions sont également associées à chaque transition.

Exemple d’une machine à états avec actions associées

Par exemple, allumer une LED verte lorsque « A » est détecté, et une LED rouge lorsque « B » est détecté. Si une condition d’un état devient vraie, l’état est modifié et une action peut être prise en conséquence. L’action est notée sur le bord. Voir la figure 2.

Figure – Machines à états avec actions associées

Les deux principaux types de machines à états sont celles de Mealy et Moore. Les machines de Mealy effectuent : une action lorsqu’une transition se produit, des actions à l’intérieur de chaque état. nous parlons dans cet articles des machines de Mealy. 

Les transitions pour sortir d’un état

Dans chaque état le code examine seulement les conditions liées aux transitions de sortie de l’état. C’est un point très important. Lorsque vous concevez une machine à états et réfléchissez à un état, vous n’avez qu’à vous soucier des transitions qui sortent de ce dernier. Une fois que la machine est dans un état, la façon dont elle y est arrivée n’est pas important. Donc, le programme que vous écrivez doit seulement être préoccupé par les transitions qui sortent d’un état. 

Exemple avec le Baseball

Examinons un exemple avec du baseball. Les quatre bases sont les états. L’objectif est de passer de la maison (home plate) à la première base, puis à la deuxième base, la troisième base, et de nouveau à la maison. Une fois que vous arrivez à la deuxième base, qui se soucie de comment vous y êtes arrivé? Votre objectif est maintenant de tenter d’aller (transition) à la troisième base. De la même manière, l’état d’une machine ne se préoccupe pas sur la façon dont il est apparu, mais seulement sur ce qu’il doit faire. 

Pourquoi utiliser des machines à états?

Alors, avant de plonger et passer beaucoup de temps dans le codage des machines à états, pourquoi les utiliser? Pour certaines tâches, les machines d’état sont plus faciles à penser et à lire que les méthodes procédurales telles que les organigrammes ou les pseudocodes. Une définition procédurale d’une tâche est habituellement chargée d’une grande partie du détail de l’opération en cours, alors qu’un diagramme d’état vit à un niveau supérieur, laissant de côté une grande partie des détails ennuyeux. Je ne commets pas d’hérésie, en niant l’utilité d’autres méthodes, mais il y a des moments où les machines d’état sont juste le bon outil.

Pour résoudre quels problèmes?

Les machines à états sont appropriées pour tout problème où le système occupe différents états de repos distincts. Les machines à états ne sont généralement pas appropriées pour les algorithmes mathématiques. D’un autre côté, les machines d’état sont appropriées pour les interfaces utilisateur, les protocoles de communication et certaines tâches de reconnaissance de formes car la fonction du système ou du processus peut être décomposée en étapes discrètes.

Diviser les fonctions du système

Un autre avantage des machines d’état est que l’état actuel du système est complètement résumé par un numéro. La machine à états est conçue pour incarner dans chaque état un fonctionnement significatif du système. Ce processus de conception met en lumière les sections (divisions) naturellement présentes dans les fonctions du système. 

Offre une vue de haut niveau

Il en résulte que l’état de la machine est objectivement significatif pour le concepteur, en tant que vue de haut niveau, plus qu’une valeur de compteur de programme, un numéro de page d’organigramme, un niveau d’imbrication if-then-else ou une valeur variable. Même les systèmes compliqués avec des dizaines de milliers de lignes de code peuvent être rendus dans quelques dizaines d’états; le système fonctionne en petits morceaux qui peuvent être facilement compris. 

Une conception facile à modifier

Les conceptions de machines d’état sont généralement faciles à modifier. En fonction de votre implémentation spécifique et des restrictions matérielles / logicielles, le câblage d’un autre état dans une machine existante n’est pas difficile. Il s’agit d’une demande fréquente sur les interfaces utilisateur dans les programmes embarqués : « Oui, Romain, cette machine à coiffure automatisée est superbe, mais pouvez-vous ajouter trois actions supplémentaires à la clé? les machines d’état rendent cela facile, et Romain n’a même pas à travailler pendant le déjeuner !

Impact et régression minimiser

Enfin, avec précaution (et vous êtes un programmeur prudent), il est possible dans une machine de modifier le comportement d’un état sans se soucier d’avoir une régression et un impact sur le fonctionnement des autres états et de devoir débogué le code; contrairement aux grands programmes procéduraux entremêlés qui peuvent partager de grandes quantités de code de manière non intuitive et sournoise.

Toujours réticents?

Nous semblons être réticents à l’égard des machines à états en raison d’une mauvaise compréhension de leur complexité et/ou d’une incapacité à quantifier les avantages. Mais, il y a moins de complexité que vous ne le pensez et plus d’avantages qu’on ne s’ y attendrait. Ainsi, la prochaine fois que vous aurez un objet qui suggère même d’avoir qu’un champ « status », n’hésitez pas à y mettre une machine à états, vous serez heureux de l’avoir fait.

Avantages des machines à états

• Leur simplicité facilite la mise en œuvre par des développeurs inexpérimentés;
• Compte tenu d’un ensemble d’entrées et de l’état actuel connu, il est possible de prédire la transition entre les états, ce qui facilite les tests;
• En raison de leur simplicité, les machines à états sont rapides à concevoir, à mettre en œuvre et à exécuter;
• Les machines à états représente une technique ancienne de modélisation de systèmes qui a fait ses preuves depuis longtemps; et qui a fait ses preuves même en tant que technique d’intelligence artificielle.
• Les machines à états sont relativement flexibles. Il existe plusieurs façons de mettre en œuvre un système basé sur les machines à états en termes de topologie; 
• Transfert facile d’une représentation abstraite significative vers une implémentation codée;
• Faible surcharge processeur; bien adapté aux domaines où le temps d’exécution est partagé entre modules ou sous-systèmes. Seul le code de l’état actuel doit être exécuté, et peut-être un peu de logique pour déterminer l’état actuel;
• Détermination facile de l’accessibilité d’un état, lorsqu’il est représenté sous une forme abstraite, il est immédiatement évident de savoir si un état est réalisable à partir d’un autre état, et ce qui est nécessaire pour atteindre l’état.

Inconvénients des machines à états

• La nature prévisible des machines à états déterministes peut être indésirable dans certains domaines tels que les jeux d’ordinateur;
• Larger systems implemented using a FSM can be difficult to manage and maintainwithout a well thought out design. The state transitions can cause a fair degree of “spaghetti- factor” when trying to follow the line of execution;
• Il peut être difficile de gérer et d’entretenir des systèmes plus grands mis en œuvre à l’aide d’une machine à états sans une conception bien pensée. Les transitions d’état peuvent causer un certain degré de « facteur spaghetti » en essayant de suivre la ligne d’exécution;
• Ne convient pas à tous les domaines problématiques, ne devrait être utilisé que lorsque le comportement d’un système peut se lier à des états séparés. Cela signifie que tous les états, transitions et conditions doivent être connus d’avance et bien définis;
• Les conditions pour les transitions d’états sont crénelées, ce qui signifie qu’elles sont fixes.

Machines à états pour quels domaines?

L’heuristique pour déterminer quand et comment implémenter des machines à états finis est et spécifique au problème. Les machines à états sont bien adaptés aux domaines de problèmes qui s’expriment facilement à l’aide d’un organigramme; et qui possèdent un ensemble d’états et de règles bien définis pour gouverner les transitions d’états.

Quand on est un adepte de la ligne de commande, on aime manipuler nos fichiers de travail avec les commandes usuelles (cd, ls, mv, rm). Seulement voilà, si vous êtes comme moi, vous savez qu’il arrive parfois de supprimer un fichier par erreur, ou de vouloir recuperer un fichier qu’on avait supprimer il y a quelque jour.

Alors, là, on se dit que Linux n’est pas si puissant que ça. Quel dommage ne ne pas avoir une corbeille permettant de contenir les fichiers dont on veut se debarrasser.

J’ai décidé ce matin de creer dans mon bashrc un alias de la commande rm afin que cette derniere ne supprime plus mes fichiers mais les deplaces dans un repertoire « Poubelle ».

An commençant mon alis, j’ai rencontré rapidement quelques soucis, j’ai donc du creer une fonction appellée rm dans mon fichier bashrc. Cette fonction va être appelée à chaque fois que la commande rm est tapée dans le terminal.

Cette fonction, vérifie s’il y a des options passées à l’appelle de la commande, si c’est le cas, alors elle verifie s’il y a l’option force (-f), si ce n’est pas le cas alors le ou les fichiers (ou repertoires) sont deplacés dans le repertoire POUBELLE défini dans la variable POUBELLE_DIRECTORY. Vous pouvez mettre le chemin du repertoire que vous souhaitez utiliser comme corbeille. Si le repertoire n’existe pas alors la fonction le creera automatiquement. Pas belle la vie?

J’oubliais de vous dire, si l’option -f est utilisée avec l’appelle de la commande rm, alors le ou les fichiers seront reelements surpprimés.

# Surcharges de la commande rm, si l'option -f n'est pas utilisée alors
# le(s) fichier(s) sont deplaces dans le repertoire POUBELLE_DIRECTORY
function rm {

# Repertoire contenant corbeille
POUBELLE_DIRECTORY="~/POUBELLE"

# si le repertoire corbeille n'existe pas alors le creer
if [ ! -d "$POUBELLE_DIRECTORY" ]; then
mkdir -p $POUBELLE_DIRECTORY

# Si erreur retournée par mkdir alors sortir en erreur
if [ $? -gt 0 ]
then
echo "Script .bashrc (Function rm) : Erreur de creation du repertoire $POUBELLE_DIRECTORY"
exit 1;
fi
fi

# si la commande rm a des options (argument 1 contient le caractere "-")
if [ $(expr index $1 -) -gt 0 ]
then
# si la commande rm ne contient l'option f (force)
if [ $(expr index $1 f) -eq 0 ]
then
mv "$2" $POUBELLE_DIRECTORY
if [ $? -eq 0 ]; then echo "Deplacement dans $POUBELLE_DIRECTORY"; fi
else
# Commandes rm classiques avec les arguments fournis
/usr/bin/rm $*
fi
else # Sinon la commande rm n'a pas d'option
mv "$1" $POUBELLE_DIRECTORY
if [ $? -eq 0 ]; then echo "Deplacement dans $POUBELLE_DIRECTORY"; fi
fi
}
export -f rm


Une interface décrit le comportement ou les capacités d’une classe C++ sans pour autant imposer une implémentation spécifique à cette dernière. 

Les interfaces C++ sont faites à l’aide des classes abstraites.

Nous sommes faces à une classe abstraite dès qu’une des fonctions est déclarée virtuelle pure. Une fonction est virtuelle lorsqu’on ajoute « =0 » après sa déclaration.

Ci-dessou, voici un exemple de déclaration d’une méthode virtuelle pure :

L’objectif d’une classe abstraite est de fournir aux autres classes une classe de base appropriée dont elles pourront hériter. Les classes abstraites ne peuvent être instanciées, ni servir seulement d’interface. Tenter d’instancier un objet à partir d’une classe abstraite cause une erreur de compilation.

L’objet d’une classe abstraite est de fournir une classe de base appropriée à partir de laquelle les autres classes pourront hériter. Les classes abstraites ne peuvent pas être utilisées pour instancier des objets. Si vous essayez d’instancier un objet à partir d’une classe abstraite, vous aurez une erreur de compilation.

Par conséquent, si vous souhaitez instancier la sous classe (d’une classe abstraite) il est nécessaire que vous implémentiez chacune des fonctions virtuelles. Sinon vous aurez une erreur de compilation.

On appelle classes concrètes les classes pouvant être utilisées pour instancier des objets.

Exemple d’une Classe Abstraite

Considérons l’exemple suivant dans lequel une classe mère fournit une interface à la classe de base pour implémenter une fonction appelée getSurface().

Lorsque le code ci-dessus est compilé et exécuté il produit le résultat suivant :

Vous pouvez voir dans l’exemple ci-dessus comment une classe abstraite définit une interface avec getSurface() et comment deux autres classes implémentent cette même fonction mais avec un algorithme différent pour calculer la surface spécifique à la forme géométrique.

Stratégie de conception

Une architecture orientée objet doit utiliser des classes de base abstraites pour fournir des interfaces standards et communes aux applications utilisatrices. 

Donc, par héritage de ces classe abstraites, les classes dérivées sont construites pour fonctionner toutes de la même façon. 

Les possibilités (e.g. fonctions publiques) offertes aux fonctions externes sont fournies en tant que méthodes virtuelles pures dans la classe de base abstraite. Les implémentations de ces méthodes virtuelles pures sont fournies dans les classes dérivées qui sont conformes au genre spécifique du programme.

De plus cette architecture permet à de nouvelles fonctions d’être ajoutées facilement au système.

Syntax

Description

Valeurs de retour

Retourne un entier indiquant les différences détectées.

Exemple

Sortie

Syntax

Description

La fonction strcpy() copie la chaine pointée par source, sur le tampon pointé par destination. La copie comprend le caractère de terminaison ‘\0’. Attention, le tampon de destination doit être suffisamment grand afin de pouvoir recevoir la chaîne de caractères.

Exemple

Dans l’exemple ci-dessus, on copie la chaîne s1 dans s2.

Nous allons au travers de ce tutoriel expliquer comment programmer en C  la lecture d’un fichier texte. Nous expliquerons chaque ligne de code ajoutée afin d’arriver à un programme fonctionnel.

Tout d’abord, afin de faire des opérations d’entrées sorties, commençons par inclure le fichier d’entête stdio.h (Standard Input/Ouuput Header).

Tout programme écrit en C doit contenir une fonction principale appelée main, c’est à partir de cette dernière que débute un programme.

Comme vous pouvez le voir ci-dessus, à la ligne 3, le mot clé int précède la fonction main pour indiquer que cette dernière retourne un entier.

Nous ajoutons la primitive return à la fin de notre fonction afin de retourner une valeur.

Habituellement un programme retourne 1 en cas d’erreur sinon 0. Considérons que si notre programme arrive à la fin de la fonction main c’est qu’il n’y a pas eu d’erreur.

Afin de pouvoir lire notre fichier nous avons besoin du pointeur de fichier :

FILE* pFichier

Pour stocker les caractères nous utilisons la variable (type entier) :

int c

Nous ouvrons le fichier avec la fonction fopen qui retourne un pointeur sur le fichier. En cas d’échec elle retourne NULL.

La valeur de retour de la fonction fopen est utilisée afin d’initialiser notre pointeur pFichier .

La fonction fopen attend deux paramètres qui sont respectivement, le nom du fichier et mode d’ouverture.

Nous ouvrons un fichier nommé fichier.txt et utilisons le mode d’ouverture « r » pour read (accès en lecture).

Si un echec a eu lieu lors de l’ouverture du fichier, le pointeur pFichier est égal à NULL, dans ce cas nous affichons un message d’erreur à l’aide de la fonction  perror.

La fonction fgetc lit le fichier et retourne le caractère courant, la position dans le fichier est modifiée.

Affichons sur la sortie standard le caractère lu à l’aide de la fonction printf. Nous indiquons que nous souhaitons afficher un caractère avec %c et nous lui fournissons le caractère à afficher c en paramètre.

Notre programme n’est pas encore fini, il lit pour l’instant que le premier caractère du fichier avant de se terminer.

Implémentons une boucle afin d’appeler la fonction fgetc tant que des caractères sont présents. Nous pouvons savoir lorsque nous sommes à la fin du fichier grâce à la fonction fgetc qui retournera dans ce cas EOF.

Ajoutons une boucle infinie while depuis laquelle nous sortirons si le caractère EOF est détecté.

Si le caractère courant est égal à EOF (End Of File – Fin du fichier) nous sortons de la boucle  à l’aide de l’instruction break .

Ajoutons l’instruction fclose afin de fermer correctement le fichier une fois la lecture terminée.

Ci-dessous un morceau de code en langage c qui affiche simplement le nombre d’arguments passés en paramètre au programme.

Ci-dessus, notre code source.

Maintenant compilons…

Et lançons notre programme.

Tiens!! bizarre?!? Il affiche 1 alors que je n’ai fourni aucun parametre. Je vais lui donné un paramètre pour voir ce que cela donne.

Ah ben, ca y est, je crois avoir compris. Vous aussi? Le nom du programme est lui aussi comptabilisé.

Alors que je passe beaucoup de temps à administrer des machines en lignes de commandes, je pense qu’il est très utile d’écrire cet article sur une fonctionnalité de BASH parfois méconnue mais indispensable à connaitre.

Cette dernière permet en effet de rechercher dans l’historique des commandes déjà exécutées dans BASH.

Autrefois, j’utilisais la flèche du haut pour afficher les commandes précédentes. J’utilisais aussi la commande history qui affiche un listing de toute les commandes BASH.

Un jour j’ai découvert (enfin on m’a montré) le raccourci clavier CTRL + r et depuis je n’utilise plus que ça !

Je vous explique, c’est très simple :

Exemple :

Dans votre terminal si vous tapez Ctrl + r, vous obtiendrez :

Ensuite tapez un mot clé correspondant à ce que vous pourriez avoir envié de rechercher dans l’historique :

Ces derniers jours, j’ai utilisé des lignes de commandes qui comportées « gcc », si je tape « gcc » il m’affiche :

Ci-dessus, on peut voir qu’il m’affiche une ligne commande entière (avec les arguments) qui contient l’expression « gcc ». Cette ligne de commande correspond à la dernière ligne de commande que j’ai tapé et qui contenait le mot clé gcc.

En appuyant une deuxième fois sur Ctrl + R, je remonte dans l’historique Bash enregistré. Il m’affiche :

Ci-dessus, il m’affiche une autre ligne de commande que j’ai tapé dernièrement et qui contient également l’expression « gcc ».

En appuyant successivement sur CTRL + r vous pouvez remonter dans l’historique des commandes.

Un autre exemple, si je tape Ctrl +r vfat, il m’affiche :

Il a trouvé la dernière commande que j’avais tapé et qui comprenait le mot clé vfat.

Si vous souhaitez sélectionner la ligne de commande qu’il vous propose, rien de plus simple, soit vous appuyez sur la touche entrée pour éxecuter la commande, soit vous l’éditer directement. Pour l’éditer, déplacer le curseur avec les flèches droite et gauche. Pour annuler appuyer sur Ctrl +c.

Dans Vim les macros permettent d’enregistrer et de jouer une séquence d’actions dans l’éditeur.

A l’aide d’exemples détaillés je vais vous expliquer comment faire pour enregistrer et lancer des macros dans les éditeurs Vi et Vim.

Les étapes pour faire une macro dans Vim sont les suivantes :

1. Démarrez l’enregistrement en appuyant sur la touche q, suivi d’un caractère minuscule afin de nommer la macro
2. Effectuez les actions qui seront enregistrées à l’intérieur de l’éditeur Vim
3. Stoppez l’enregistrement en appuyant sur la touche q
4. Jouez la macro enregistrée en appuyant sur la touche @ suivi du nom de la macro
5. Pour répéter la macro plusieurs fois, appuyer sur : NN @ ‘nom macro’. NN étant un nombre

Exemple : Génération d’une séquence de nombre à l’intérieur d’un fichier en utilisant une Macro Vim

1. Créez et ouvrez un fichier test.txt pour générer la séquence:

2. Passer en mode insertion et tapez « 1 . » comme ci-dessous:
Appuyer sur ‘Echap’ ‘i’ puis ‘1 .’

3. Lancer l’enregistrement et appeler la macro ‘a’
Appuyez sur ‘Echap’ ‘q’ puis ‘a’
q lance l’enregistrement
a permet de nommée la macro a

Quand vous appuierez sur q a, l’indication « recording » (ou « enregistrement ») apparaîtra en bas de l’éditeur vi.

4. Copier la première ligne sur la seconde de manière à avoir deux lignes avec « 1 . » comme ci-dessous :
Appuyez sur: ‘Echap’ ‘yy’ puis ‘p’
yy va copier la ligne courante
p va coller la ligne qui vient d’être copiée

Vim va afficher la mention « recording » (ou « enregistrement ») au bas de l’écran comme ci-dessous.

Vim affiche le message « Enregistrement » en bas

5. Incrémentez le nombre
Pressez: Control + a
Incrémentez le nombre en plaçant le curseur sur la seconde ligne et en appuyant sur la combinaison de touches Ctrl+a

Vim affiche toujours « Enregistrement » en bas de l’écran.

6. Stopper l’enregistrement

Appuyez sur q
Pressez q pour stopper l’enregistrement. Vous allez avoir le message en bas de l’écran qui va disparaître.

7. Répéter l’action enregistrée 98 fois

Appuyez sur [email protected]

Maintenant répéter cette action en appuyant sur 98 @ a
@a répète la macro « a » une fois
[email protected] répète la macro « a » 98 fois, ce qui va permettre d’avoir la séquence de nombre de 1 à 100 comme ci-dessous :

Génération d’une séquence de nombre en utilisant une macro Vim

VIM (vi) permet de travailler avec plusieurs fenêtres. Vous pouvez par exemple avoir l’écran coupé en deux de manière horizontale ou verticale. Il est parfois utile ou nécessaire de modifier leur taille. C’est ce que je vais vous expliquer ici. Vous allez voir, il n’y a rien de compliqué.

Pour agrandir la largeur d’une fenêtre utiliser la combinaison de touches suivantes :
CTRL+w >

Pour rétrécir la largeur d’une fenêtre :
CTRL+w <

Pour agrandir la hauteur d’une fenêtre :
CTRL+w +

Pour rétrécir la hauteur d’une fenêtre :
CTRL+w –

Vous l’aurez remarqué en pratiquement ces combinaisons de touches, la taille n’est modifiée que d’un seul caractère à chaque manipulation.

Pour rétrécir la hauteur de la fenêtre de 10 caractère vous pouvez faire :
CTRL+w 10-

Pour agrandir la largeur d’une fenêtre de 15 caractères :
CTRL+w 15>

Vous pouvez essayer la commande suivante pour modifier la largeur de la fenêtre de 30 caractères :

Il existe d’autre méthodes non évoquées ici.