Think Julia

Une déclaration d'affectation crée une nouvelle variable et lui attribue une valeur :

julia> message = "À présent, quelque chose de nouveau"
"À présent, quelque chose de nouveau"
julia> n = 17
17
julia> π_val = 3.141592653589793
3.141592653589793

Dans cet exemple, la première affectation associe une chaîne à une nouvelle variable nommée message. La deuxième associe l'entier 17 à n. La troisième apparie la valeur approximative de π à la variable π_val (pour obtenir le symbole π, il convient de saisir \pi et de presser la touche TAB).

Une manière courante de représenter les variables sur papier consiste à écrire le nom avec une flèche pointant vers sa valeur. Ce type de figure est appelé diagramme d'état, car il montre dans quel état se trouve chacune des variables. La figure 2.1.1 représente le diagramme d'état de l'encadré précédent.

Généralement, les programmeurs choisissent pour leurs variables des noms qui sont expressifs et, au besoin, ils associent un élément de documentation à la variable afin d'améliorer la compréhension du code.

La longueur des noms des variables n'est pas limitée. Ces noms peuvent contenir presque tous les caractères Unicode (voir la section 8.1Caractères), mais ils ne peuvent pas commencer par un nombre. Les lettres majuscules sont autorisées, quoiqu'il soit conventionnel de n'utiliser que des minuscules pour les noms de variables. Les caractères Unicode peuvent être saisis en complétant les abréviations de type kitxmlcodeinlinelatexdvp\LaTeXfinkitxmlcodeinlinelatexdvp dans le REPL, et ce, par des tabulations.

Le caractère de soulignement _ peut apparaître dans un nom. Il est souvent utilisé dans les noms comportant plusieurs mots.

Si un nom inapproprié est attribué à une variable, Julia retourne une erreur de syntaxe :

julia> 76trombones = ("Belle fanfare")
ERROR: syntax: "76" is not a valid function argument name
julia> more@ = 1000000
ERROR: syntax: extra token "@" after end of expression
julia> struct = "Advanced Theoretical Zimurgy"
ERROR: syntax: unexpected "="

76trombones est incorrect parce que la variable commence par un chiffre. more@ est erroné parce cette formulation contient un caractère non autorisé, @. Mais qu'est-ce qui ne va pas avec la troisième déclaration ? Il s'avère que struct est un des mots-clés de Julia. Le REPL utilise des mots-clés pour reconnaître la structure d'un programme. Or, ceux-ci ne peuvent pas être utilisés comme noms de variables.

Julia comporte les mots-clés suivants repris dans le tableau 2.1.

Il est inutile de mémoriser cette liste. Dans la plupart des environnements de développement, les mots-clés sont affichés dans une couleur déterminée. Si un mot de cette liste est attribué à une variable, un message d'alerte/d'erreur apparaîtra.

Une expression est une combinaison de valeurs, de variables et d'opérateurs. Une valeur en soi est considérée comme une expression, de même qu'une variable, de sorte que les expressions suivantes sont toutes autorisées :

julia> 42
42
julia> n
17
julia> n + 25
42

Lorsqu'une expression est saisie à l'invite, le REPL l'évalue pour trouver sa valeur. Dans cet exemple, n a la valeur 17 et n + 25 prend la valeur 42.

Une déclaration (ou une instruction) est une unité de code qui produit un effet, comme la création d'une variable ou l'affichage d'une valeur.

julia> n = 17
17
julia> println(n)
17

La première ligne est une déclaration d'affectation qui associe une valeur à n. La deuxième ligne est une instruction qui conduit à l'affichage de la valeur de n.

Lorsqu'une instruction est saisie, le REPL l'exécute, ce qui signifie qu'il effectue tout ce que contient l'instruction.

Jusqu'à présent, nous avons pratiqué Julia en mode interactif, ce qui signifie que nous interagissons directement avec le REPL. Le mode interactif est un bon moyen de démarrer, mais, lors d’un usage intensif, cette technique devient rapidement fastidieuse.

L'autre possibilité consiste à enregistrer le code dans un fichier. On se réfère à ce dernier en disant qu'il s'agit d'un script. Ensuite, l'utilisateur lance Julia en mode script pour exécuter le code qu'il contient. Par convention, les scripts en Julia portent des noms se terminant par .jl.

Si nous savons comment créer et exécuter un script, nous sommes prêts (sinon, il faudra utiliser en local Jupyter ou Pluto, par exemple ; voir l'annexe BAnnexe B : Installation de Julia). À ce stade, il existe deux méthodes :

• soit ouvrir un fichier texte (avec Vim, Emacs, etc.), y écrire le code du script et l'enregistrer avec une extension .jl. Le script peut être exécuté dans un terminal bash (ou analogue) pour autant que le dossier courant soit le répertoire contenant le script à exécuter :

   

  Sélectionnez

  1.
  

  name@computer:~$ julia  nom_du_programme.jl
  

• soit recourir à un environnement de développement intégré comme VSCodium (voir l'annexe BAnnexe B : Installation de Julia). En supposant que le script est enregistré dans un répertoire dénommé Prgm_Julia. Dans VS Codium, il suffit de cliquer sur File → Open File et de sélectionner le script. Celui-ci apparaît, colorisé, la partie supérieure de Codium. Il convient de cliquer sur une des lignes du code puis de cliquer sur l'icône kitxmlcodeinlinelatexdvp\vartrianglerightfinkitxmlcodeinlinelatexdvp de la barre de commandes supérieure afin de le lancer.

Quoi qu'il en soit, parce que Julia propose les deux modes (REPL et exécution de script), il est possible de tester des bouts de code en mode interactif avant de les insérer dans un script. Cependant, il existe des différences entre le mode interactif et le mode script qui peuvent être surprenantes. Par exemple, utilisons Julia comme calculatrice et saisissons :

julia> miles = 26.2
26.2
julia> miles * 1.61
42.182

La première ligne attribue une valeur à miles et affiche la valeur. La deuxième ligne est une expression. Par conséquent, le REPL l'évalue et affiche le résultat(4).

Néanmoins, l'exécution du même code dans un script ne produit aucun résultat. En mode script, une expression, à elle seule, n'a aucun effet visible. Julia évalue bel et bien l'expression, mais n'affiche pas la valeur, sauf à lui demander de le faire :

miles = 26.2
println(miles * 1.61)

Ce comportement peut être déroutant au début.

Un script contient généralement une séquence d'instructions. S'il y a plus d'une déclaration, les résultats apparaissent un à un, à mesure de l'exécution des déclarations.

Par exemple, le code suivant :

println(1)
x = 2
println(x)

affiche :

1
2

Les déclarations d'affectation ne produisent aucun résultat.

2-4-1. Exercice 2-1▲

5
x + 5
x + 1

Lorsqu'une expression contient plus d'un opérateur, l'ordre d'évaluation dépend de la préséance des opérateurs entre eux. Pour les opérateurs mathématiques, Julia suit la convention mathématique. L'acronyme PEMDAS constitue un moyen mnémotechnique :

1. Les Parenthèses ont la plus haute priorité et peuvent être utilisées pour forcer une expression à être évaluée dans l'ordre souhaité. Comme les expressions entre parenthèses sont évaluées en premier, 2*(3-1) vaut 4 et (1+1)^(5-2) vaut 8. L'usage de parenthèses contribue à rendre une expression plus facile à lire, comme dans (minute * 100) / 60, même si cela ne change pas le résultat ;

2. L'Exponentiation a la priorité suivante, donc 1+2^3 vaut 9 (et non 27), et 2*3^2 donne 18 (et non 36) ;

3. La Multiplication et la Division ont la préséance sur l'Addition et la Soustraction. Ainsi, 2*3-1 a pour valeur 5 (et non 4) et 6+4/2 est évalué comme 8 (et non 5) ;

4. Les opérateurs ayant la même priorité sont évalués de gauche à droite (sauf l'exponentiation). Ainsi, dans l'expression degrés / 2 * π, la division se fait en premier et le résultat est multiplié par π. Pour diviser par 2π, il est possible d'utiliser des parenthèses degrés / (2 * π), d'écrire degrés / 2 / π ou encore degrés / 2π.

En général, les opérations mathématiques sur des chaînes de caractères ne sont pas permises, même si ces dernières ressemblent à des nombres. Les opérations suivantes sont donc illicites :

"2" - "1"    "un œuf" / "le plat"    "top" + "charm"

Cependant, il existe deux exceptions : * et ^.

L'opérateur * effectue la concaténation des chaînes de caractères, ce qui signifie qu'il joint les chaînes en les reliant bout à bout. Par exemple :

julia> first_str = "paruline "
"paruline "
julia> second_str = "à "
"à "
julia> third_str = "gorge "
"gorge "
julia> fourth_str = "jaune"
"jaune"
julia> first_str * second_str * third_str * fourth_str
"paruline à gorge jaune"

L'opérateur ^ procède également sur des chaînes de caractères. Il effectue des répétitions. Par exemple, "Spam"^3 retourne "SpamSpamSpam". Si une des valeurs est une chaîne, l'autre doit être un nombre entier.

Cette utilisation de * et ^ est logique par analogie avec la multiplication et l'exponentiation. Tout comme 4^3 est équivalent à 4*4*4, nous nous attendons à ce que "Spam"^3 soit identique à "Spam" * "Spam" * "Spam", ce qui est bien le cas.

Plus les programmes deviennent volumineux et complexes, plus ils sont difficiles à lire. Les langages formels sont denses et il est souvent difficile de regarder un morceau de code et de comprendre ce qu'il représente.

C'est pourquoi il est bon d'ajouter des notes à nos programmes pour expliquer en langage naturel ce que réalise le code. Ces notes sont appelées des commentaires et elles commencent par le symbole # :

# calcule le pourcentage d'heure écoulé
pourcentage = (minute * 100) / 60

Dans ce cas, le commentaire apparaît sur une ligne séparée. Cependant, les commentaires peuvent se trouver à la fin d'une ligne :

pourcentage = (minute * 100) / 60    # calcule le pourcentage d'heure écoulé

Tout ce qui suit le caractère # jusqu'à la fin de la ligne est ignoré. Un commentaire n'altère pas l'exécution d'un programme.

Les commentaires sont toujours utiles lorsqu'ils documentent des caractéristiques non évidentes du code. Il est raisonnable de supposer que le lecteur peut comprendre ce que fait le code. Il est plus utile d'expliquer pourquoi.

Par exemple, ce commentaire est redondant avec le code et, par conséquent, inutile :

v = 5    # attribue 5 à v

Cependant, le commentaire suivant contient une information réellement pertinente :

v = 5    # vitesse exprimée en m/s

Trois types d'erreurs se produisent dans un programme : des erreurs de syntaxe, des erreurs d'exécution et des erreurs sémantiques. Ce point sera approfondi au chapitre 21Débogage. Il est utile de les distinguer afin de les repérer le plus rapidement possible.

Erreur de syntaxe La « syntaxe » fait référence à la structure d'un programme et aux règles relatives à cette structure. Par exemple, les parenthèses doivent venir par paires, donc (1 + 2) est licite, mais 8) constitue une erreur de syntaxe.
S'il y a une erreur de syntaxe dans un programme, Julia affiche un message d'erreur et arrête l'exécution. Au cours des premières semaines d'étude, il est fréquent de passer du temps à rechercher les erreurs de syntaxe. Avec l'expérience, ce type d'erreur se manifestera plus rarement et leur détection sera de plus en plus rapide.

Erreur d'exécution Le deuxième type d'erreur concerne l'exécution. On dit « erreur d'exécution » parce qu'elle n'apparaît qu'après le démarrage du programme. Ces erreurs sont également appelées exceptions parce qu'elles indiquent généralement que quelque chose d'exceptionnel (et de malencontreux) s'est produit.
Les erreurs d'exécution sont rares dans les programmes simples associés aux premiers chapitres. Il s'écoulera un certain temps avant d'en rencontrer.

Erreur sémantique Le troisième type d'erreur concerne la « sémantique ». Il s'agit d'un problème de sens. Si un programme contient une erreur sémantique, il s'exécute sans émettre le moindre message d'erreur. Cependant, le programme produit un résultat autre que celui attendu, bien qu'il accomplisse exactement ce qu'il lui est demandé.
L'identification des erreurs sémantiques peut être délicate, car elle oblige à travailler à rebours en examinant la sortie d'un programme et en essayant de comprendre comment il procède.

variable nom qui fait référence à une valeur.

affectation déclaration qui attribue une valeur à une variable.

diagramme d'état représentation graphique d'un ensemble de variables et des valeurs auxquelles elles se réfèrent.

mot-clé mot réservé utilisé par un langage de programmation. Les mots-clés tels que if, function, while, etc., ne peuvent pas être employés comme noms de variables.

opérande une des valeurs sur lesquelles un opérateur exerce une action.

expression combinaison de variables, d'opérateurs et de valeurs qui représente un seul résultat.

évaluer simplifier une expression en effectuant les opérations afin d'obtenir une valeur unique.

déclaration section de code qui représente un ordre ou une action. Jusqu'à présent, les déclarations que nous avons vues opèrent des affectations (assignments en anglais) et des déclarations d'affichage.

exécuter lire une déclaration et faire ce qu'elle exprime.

mode interactif façon d'utiliser le REPL de Julia en saisissant un code à l'invite.

mode script façon d'utiliser Julia pour lire le code d'un script et l'exécuter.

script programme enregistré dans un fichier.

priorité d'un opérateur règles de préséance relative à l'ordre dans lequel les expressions impliquant des opérateurs mathématiques et des opérandes multiples sont évaluées.

concaténer joindre deux éléments bout à bout.

commentaire informations contenues dans un programme qui sont destinées à d'autres programmeurs (ou à toute personne lisant le code source) et qui n'ont aucun effet sur l'exécution de ce programme.

erreur de syntaxe erreur dans un programme qui rend impossible l'analyse (et donc l'interprétation).

erreur d'exécution (appelée également exception) erreur qui est détectée pendant que le programme est en cours d'exécution.

sémantique signification ou « sens » d'un programme.

erreur sémantique erreur dans un programme qui l'amène à faire autre chose que ce pourquoi il a été conçu.

2-10-1. Exercice 2-3▲

2-10-2. Exercice 2-3▲