Linux est un excellent outil de développement. De plus, la connaissance même succinte d'un ou deux langages de programmation interprétés (on parle alors de langages <<scripts>>) du type Shell, Perl ou Tcl, permet de réaliser nombres d'opérations complexes en quelques lignes de code.
Notez bien, toutefois, que cet ouvrage ne prétend pas être un manuel de programmation
: ne sont évoquées ici que quelques notions essentielles, dans leurs grandes
lignes, pour vous permettre de débuter sur de bonnes bases. Mais en aucun cas
ce qui suit n'est suffisant pour vous permettre de rédiger vos propres programmes,
si vous ne possédez pas déjà une certaine expérience du domaine. Simplement
serez-vous mieux à même de comprendre comment sont réalisés des programmes existants
: nous vous recommandons vivement d'aller jeter un coup d'
il aux contenus
des scripts de démarrage.
Les langages disponibles sous Linux sont très nombreux : il est presque impossible d'en donner une liste exhaustive. Nous ne citerons ici que les plus connus, ceux bénéficiant du meilleur support.
Dans le domaine de l'art de la programmation (car il s'agit d'une forme d'art, selon certains), on retrouve toujours quelques notions fondamentales, quel que soit le langage utilisé. Ces notions, fort simples en elle-mêmes, permettent de créer des programmes extrèmement complexes, tels qu'un système d'exploitation comme Linux...
Une variable est un outil de stockage d'informations lors de l'exécution du programme. Les régles régissant son utilisation peuvent varier grandement d'un langage à l'autre, mais l'idée reste la même : une variable est une boîte, avec une étiquette pour la reconnaître, utilisée pour stocker quelque chose (on dit <<lui effecter une valeur>>) en vue d'une utilisation ultérieure ; le contenu de la variable peut évoluer au cours de l'exécution du programme et il est irrémédiablement perdu lorsqu'elle se termine.
Il est fréquent que les variables soient <<typées>>, c'est-à-dire qu'on ne
peut pas leur affecter n'importe quel genre de valeur. Par exemple, une variable
de type <<nombre entier>> ne pourra recevoir de valeur du genre 3.14 (
),
sauf à utiliser des outils de conversion d'un genre vers l'autre. Cet aspect,
qui peut paraître contraignant, apporte beaucoup à la qualité de la programmation
en facilitant la détection des erreurs. Il est toutefois généralement absent
des langages de type scripts, tels que les langages shell, Perl, etc.
Une alternative est une structure qui prend la forme générale :
| si <une certaine condition> | ||
| alors <faire quelque chose> | ||
| sinon <faire autre chose> |
Cette structure permet d'adapter les actions du programme selon différentes situations. On la désigne parfois par <<structure if...then...else>>2.42 ou simplement <<if...then>>, si la partie commençant par sinon (on dit aussi la clause sinon, ou la clause else) est absente (il arrive en effet qu'elle soit sans objet).
Encore une fois, chaque langage possède ses propres règles d'écriture de l'alternative.
Cette structure prend l'une des deux formes suivantes :
| tant que <une certaine condition> | ||
| faire <quelque chose> |
| faire <quelque chose> | ||
| tant que <une certaine condition> |
Ceci permet d'exécuter plusieurs fois une séquence d'instructions, la répétition étant conditionnée par généralement un test sur la valeur d'une variable. Il semble évident qu'à chaque exécution (on dit aussi <<à chaque tour de boucle>> ou <<à chaque itération>>) les termes de la condition soient modifiés, pour que celle-ci ait une chance de ne pas être vérifiée après un certain nombre d'itérations. Sinon, la boucle ne se terminera jamais et répètera sa séquence d'instructions à l'infinie, ce qui peut avoir des conséquences fort désagréables.
Une petite subtilité : les deux formes ne sont pas exactement équivalentes. Dans la première (à gauche), la condition est vérifiée avant l'exécution de la séquence d'instructions : il peut donc arriver que celle-ci ne soit jamais exécutée, si la condition est fausse dès le départ. La seconde forme, par contre, ne vérifie la condition qu'à la fin de la séquence d'instructions : celle-ci sera donc toujours exécutée au moins une fois - mais peut-être qu'une seule fois...
Boucle infinie et ordre d'évaluation de la condition sont deux pièges très communs pour les programmeurs, même les plus expérimentés : méfiez-vous donc.
Voici une structure qui n'est pas offerte par tous les langages, bien que très répandue. Elle permet d'écrire simplement l'imbrication de plusieurs alternatives. Sa forme générale est :
| selon <valeur d'une variable> | ||
| si <valeur 1> faire <action 1> | ||
| si <valeur 2> faire <action 2> |
 |
| si <valeur n> faire <action n> | ||
| sinon faire <action par défaut> |
Il existe pratiquement autant de comportements du choix multiple qu'il y a de langages le proposant. En gros, à chaque valeur possible de la variable on associe une action (ce peut être d'ailleurs une séquence d'instructions), l'action par défaut (si elle est présente) n'étant exécutée que si aucune des valeurs proposées ne correspond à celle de la variable.
Si nous ne disposions que des structures évoquées plus haut, l'écriture de programmes complexes serait particulièrement fastidieuse : comment faire si l'on a besoin d'une même séquence d'instructions en différents points éloignés du programme ? Une solution consiste à recopier cette séquence à chaque fois : le résultat serait des programmes d'une longueur colossale, pratiquement impossible à entretenir (on dit plutôt <<maintenir>>) ou à modifier.
La solution retenue est infiniment plus élégante et pratique : celle des sous-programmes. Vous écrivez votre séquence une seule fois, vous l'enfermer dans une boîte avec une étiquette, et lorsque vous en avez besoin il suffit d'indiquer le nom qui figure sur l'étiquette pour que tout se passe (presque) comme si vous aviez recopié la séquence.
Dans le vocabulaire des programmeurs, les sous-programmes sont désignés par les termes procédure et fonction. La distinction entre les deux n'est pas toujours très nette. Pour fixer les idées, disont qu'en gros une fonction renvoie une valeur unique, résultant d'un certain calcul (au sens large, pas nécessairement numérique), tandis qu'une procédure effectue diverses actions mais sans renvoyer une valeur unique (soit aucune, soit plusieurs).
Comme il est rare que les sous-programmes doivent toujours travailler sur les mêmes données, il est possible de leur passer des paramètres pour que le grain qui leur est donné à moudre ne soit pas toujours le même. Imagniez une fonction qui calcule la moyenne de plusieurs valeurs : une telle fonction aurait au moins un paramètre, un tableau de valeurs (et probablement leur nombre), pour faire son travail.
La technique des sous-programmes est à la base de ce que l'on appelle la programmation structurée. Leur utilité est telle que les langages qui n'offrent pas cette facilité sont très rares, ou alors très anciens...