Think Julia

Nous avons déjà rencontré un appel de fonction :

julia> println("Hello, World!")
Hello, World!

Le nom de la fonction (interne(5) à Julia) est println. L'expression entre parenthèses s'appelle l'argument de la fonction.

Il est courant de dire qu'une fonction « prend » un argument et « retourne » un résultat. Le résultat est également appelé valeur de retour.

Julia fournit des fonctions qui convertissent des valeurs d'un type à un autre. La fonction parse prend une chaîne de caractères et la convertit en n'importe quel type de nombre, si elle le peut. Sinon, Julia retourne un message d'erreur :

julia> parse(Int64, "32")
32
julia> parse(Float64, "3.14159")
3.14159
julia> parse(Int64, "Hello")
ERROR: ArgumentError: invalid base 10 digit 'H' in "Hello"

La fonction trunc peut convertir des nombres à virgule flottante en entiers, mais sans arrondi :

julia> trunc(Int64, 3.9999)
3
julia> trunc(Int64, -2.3)
-2

La fonction float convertit les nombres entiers en nombres à virgule flottante :

julia> float(32)
32.0

La fonction string convertit son argument en chaîne de caractères :

julia> string(32)
"32"
julia> string(3.14159)
"3.14159"

Naturellement, avec Julia, la plupart des fonctions mathématiques usuelles sont directement disponibles :

ratio = signal_power / noise_power 
decibels = 10 * log10(ratio)

Ce premier exemple utilise log10 pour calculer un rapport signal/bruit en décibels (en supposant que la puissance du signal et la puissance du bruit soient définies).

La fonction log calcule les logarithmes naturels (ou népériens, aussi appelés hyperboliques — kitxmlcodeinlinelatexdvp\lnfinkitxmlcodeinlinelatexdvp).

À présent, voyons un autre exemple :

radians = 0.7
height = sin(radians)

Ce deuxième cas avec la fonction sin illustre la manière de procéder pour le sinus d'un angle exprimé en radians. Un argument passé tel quel aux fonctions trigonométriques (sin, cos, tan, etc.) s'exprime en radians.

Pour convertir des degrés en radians, il faut diviser par 180 et multiplier par π :

julia> degrees = 45
45
julia> radians = (degrees / 180) * π
0.7853981633974483
julia> sin(radians)
0.7071067811865475

La valeur de la variable π est une approximation en virgule flottante du nombre kitxmlcodeinlinelatexdvp\pifinkitxmlcodeinlinelatexdvp, avec une précision à 16 chiffres.

En recourant à la trigonométrie, on vérifie que le résultat précédent correspond à la racine carrée de 2 divisée par 2 :

julia> sqrt(2) / 2
0.7071067811865475

Jusqu'à présent, nous avons examiné les éléments d'un programme — variables, expressions et déclarations — isolément, sans évoquer la manière de les combiner.

Une caractéristique des plus utiles des langages de programmation provient de leur capacité à prendre de petits blocs de construction et à les combiner (les associer). Par exemple, l'argument d'une fonction peut être tout type d'expression, dont des opérateurs arithmétiques :

x = sin((degrees / 360) * 2 * π)

Cela fonctionne également avec des appels de fonction :

x = exp(log(x+1))

Presque partout où une valeur peut être injectée, il est possible de poser une expression arbitraire, à une contrainte près : le membre de gauche d'une déclaration d'affectation doit être un nom de variable. Toute autre expression à gauche conduit une erreur de syntaxe (nous verrons les exceptions à cette règle plus tard).

julia> minutes = heures * 60     # licite
45
julia> heures * 60 = minutes      # illicite!
ERROR: syntax: "60" is not a valid function argument name

Jusqu'à présent, nous avons uniquement employé des fonctions internes à Julia. Cependant, ajouter de nouvelles fonctions est une des bases de la programmation. Une définition de fonction spécifie le nom d'une nouvelle fonction et la séquence d'instructions qui s'exécutent lorsque la fonction est appelée. Voici un exemple :

function printlyrics()
    println("Ses fluctuat nec mergitur,") 
    println("C'était pas d'la littérature") 
end

Le terme function est un mot-clé qui indique qu'une nouvelle fonction est définie. Le nom de la fonction est printlyrics. Les règles pour les noms de fonctions sont les mêmes que pour les noms de variables : ils peuvent contenir presque tous les caractères Unicode (voir la section 8.1Caractères), si ce n'est que le premier caractère ne peut pas être un chiffre. Par ailleurs, il n'est pas permis d'utiliser un mot-clé comme nom de fonction. En outre, il faut éviter qu'une variable et une fonction portent le même nom. Les parenthèses vides après le nom indiquent que cette fonction ne prend pas d'arguments.

La première ligne s'appelle l'en-tête ; le reste s'appelle le corps. Le corps se termine par le mot-clé end et peut contenir un nombre quelconque d'instructions. Pour une meilleure lisibilité, le corps de la fonction devrait être indenté.

Les guillemets doivent être des "guillemets droits" (idem pour les 'guillemets' simples). Les guillemets de ce type “ ” ou ‘ ’ ne sont pas admis en Julia.

Si une définition de fonction est saisie en mode interactif, le REPL s'indente automatiquement pour indiquer que la définition n'est pas complète :

julia> function printlyrics() 
               println("Ses fluctuat nec mergitur,")

La terminaison d'une fonction est indiquée par le mot-clé end.

La syntaxe pour appeler la nouvelle fonction est la même que pour les fonctions internes à Julia :

julia> printlyrics()
Ses fluctuat nec mergitur, 
C’était pas d’la littérature

Dès qu'une fonction est définie, elle peut être utilisée au sein d'une autre fonction. Par exemple, pour répéter les vers précédents, nous pouvons écrire une fonction appelée repeatlyrics :

function repeatlyrics()
    printlyrics()
    printlyrics()
end

Lorsque repeatlyrics est appelée, nous obtenons :

julia> repeatlyrics()
Ses fluctuat nec mergitur, 
C’était pas d’la littérature
Ses fluctuat nec mergitur, 
C’était pas d’la littérature

En rassemblant les fragments de code, l'ensemble du programme ressemble à ceci :

function printlyrics()
    println("Ses fluctuat nec mergitur,")
    println("C'était pas d'la littérature")
end

function repeatlyrics()
    printlyrics()
    printlyrics()
end

repeatlyrics()

Ce programme contient deux définitions de fonctions : printlyrics et repeatlyrics. Les définitions de fonction sont exécutées comme les autres instructions, mais elles ont pour effet de créer des objets de fonction. Les instructions à l'intérieur de la fonction ne s'exécutent pas avant que la fonction soit appelée. La définition de la fonction ne produit aucune sortie.

Comme on peut s'y attendre, il faut créer une fonction avant de pouvoir l'exécuter. En d'autres termes, la définition de la fonction doit être exécutée avant que la fonction ne soit appelée.

3-5-1. Exercice 3-1▲

Pour s'assurer qu'une fonction est définie avant sa première utilisation, il faut connaître le flux d'exécution.

L'exécution commence toujours à la première instruction d'un programme. Les instructions sont exécutées séquentiellement, dans l'ordre, de haut en bas. Les définitions de fonction ne modifient pas le flux d'exécution du programme, mais il faut se rappeler que les instructions à l'intérieur de la fonction ne s'exécutent pas avant que la fonction soit appelée. Un appel de fonction équivaut à un détour dans le flux d'exécution. Au lieu de passer à l'instruction suivante, le flux effectue un saut jusqu'au corps de la fonction appelée, y exécute les instructions, puis revient pour reprendre là où il s'était arrêté.

Cela semble assez simple, jusqu'à ce qu'on se souvienne qu'une fonction peut en appeler une autre. Au milieu d'une fonction, un programme peut être conduit à exécuter les instructions se trouvant dans une autre fonction. Puis, pendant l'exécution de cette nouvelle fonction, le programme peut à nouveau devoir exécuter une autre fonction. Heureusement, Julia est doué pour conserver la trace de l'endroit où reprendre. Ainsi, chaque fois qu'une fonction se termine, le programme reprend où il s'était arrêté au sein de la fonction qu'il a appelée.

En résumé, la lecture d'un programme ne se fait pas toujours linéairement de haut en bas. Généralement, pour la compréhension d'un programme, il s'avère préférable de suivre le déroulement de l'exécution.

Certaines des fonctions que nous avons vues nécessitent des arguments. C'est le cas de la fonction sin, qui requiert un nombre en argument. D'autres fonctions en nécessitent plusieurs. Par exemple, parse en prend deux : un type de nombre et une chaîne de caractères.

À l'intérieur d'une fonction, les arguments sont affectés à des variables appelées paramètres. Le petit programme suivant décrit une fonction qui prend un argument pour calculer son carré (ceci à titre d'exemple numérique) :

julia> function élève_au_carré(t)
           carré = t * t
           println(carré)
       end

julia> élève_au_carré(5)
25

En l'occurrence, l'appel de la fonction [c'est-à-dire l'instruction élève_au_carré(5)] passe son argument (5) à t [de la function élève_au_carré(t)]. t est ensuite transféré comme paramètre à l'intérieur de la fonction élève_au_carré(t). Le résultat de la multiplication (t * t) est affecté à la variable carré. Celle-ci est passée en argument à la fonction println et affichée.

L'intérêt de ce type de pratique est de pouvoir réutiliser la fonction ultérieurement. Par exemple, en vertu de ce qui a été discuté en section 2.6Opérations sur les chaînes de caractères, élève_au_carré("lu") permet d'obtenir le mot lulu.

Il est également possible d'utiliser une variable en tant qu'argument :

julia> nom = "lu"
"lu"
julia> élève_au_carré(nom)
lulu

Le nom de la variable que nous passons en argument (nom) n'a rien à voir avec le nom du paramètre (t). Peu importe comment la valeur a été nommée dans l'appel. Nous appelons t tout qui arrive en argument dans la fonction élève_au_carré.

Voici un autre exemple de fonction simple :

function printtwice(eluard)
    println(eluard)
    println(eluard)
end

Avec cet appel :

printtwice(π)

Julia retourne :

π
π

Une variable créée à l'intérieur d'une fonction est locale. Ceci signifie qu'elle n'existe qu'à l'intérieur de la fonction. Par exemple :

function cattwice(part1, part2)
    concat = part1 * part2
    printtwice(concat)
end

Cette fonction prend deux arguments, les concatène et affiche le résultat. Voici un exemple d'utilisation :

julia> line1 = "Facile est beau "
"Facile est beau "
julia> line2 = "sous tes paupières"
"sous tes paupières"
julia> cattwice(line1, line2)
Facile est beau sous tes paupières
Facile est beau sous tes paupières

Lorsque cattwice se termine, la variable concat est détruite. Si nous essayons de l'afficher, nous obtenons une exception :

julia> println(concat)
ERROR: UndefVarError: concat not defined

Ceci illustre le fait que les paramètres sont locaux. Par exemple (voir la section 3.7Paramètres et arguments), hors de la fonction élève_au_carré, t n'existe pas.

Pour savoir quelles variables utiliser et à quel endroit, il est parfois utile de dessiner un diagramme de pile. Comme les diagrammes d'état, les diagrammes de pile montrent la valeur de chaque variable. En outre, ils montrent la fonction à laquelle chaque variable appartient. Chaque fonction est représentée par un cadre. Un cadre est un espace fermé avec le nom d'une fonction en vis-à-vis et les paramètres et variables de la fonction à l'intérieur.

Le diagramme de pile de l'exemple précédent (avec cattwice) est présenté dans la figure 3.9.1.

Les cadres sont disposés dans une pile qui indique quelle fonction est appelée. Dans cet exemple, la fonction printtwice a été appelée par cattwice et cattwice l'a été par Main. Main est un nom spécial désignant le cadre supérieur. Lorsqu'une variable est créée en dehors de toute fonction, elle appartient à Main. Chaque paramètre fait référence à la même valeur que son argument correspondant. Ainsi, part1 a la même valeur que line1, part2 a la même valeur que line2 et eluard a la même valeur que concat.

Si une erreur se produit pendant un appel de fonction, Julia imprime le nom de la fonction, le nom de la fonction qui l'a appelée et le nom de la fonction qui a appelé tout cela jusqu'à Main.

Par exemple, si nous essayions d'accéder à concat à partir de printtwice, nous obtiendrions une erreur UndefVarError :

ERROR: UndefVarError: concat not defined
Stacktrace: 
[1] printtwice at ./REPL[1]:2 [inlined]
[2] cattwice (::String, ::String) at ./REPL[2::]

Cette liste de fonctions est appelée trace de pile ou stacktrace. Elle indique dans quel fichier du programme l'erreur s'est produite ainsi que sur quelle ligne. Elle indique quelles fonctions étaient en cours d'exécution à ce moment-là et, également, la ligne de code qui a causé l'erreur.

L'ordre des fonctions dans la trace de pile est l'inverse de celui des cadres dans le diagramme de pile. La fonction en cours d'exécution se trouve au sommet de la pile.

Certaines des fonctions que nous avons utilisées, comme les fonctions mathématiques, retournent des résultats. Appelons-les « fonctions avec retour ». D'autres fonctions effectuent une action, mais ne retournent pas de valeur. On les appelle des fonctions nulles ou vides (void functions). Dans l'exemple suivant :

function printtwice(brassens)
    println(brassens)
    println(brassens)
end

la fonction printtwice vue précédemment (section 3.7Paramètres et arguments) ne retourne aucune valeur, bien qu'elle effectue deux actions.

En appelant une fonction avec retour, l'intention est d'exploiter le résultat obtenu. Par exemple, il est tout à fait possible d'affecter le résultat à une variable ou de l'utiliser comme partie d'une expression :

x = cos(radians)
golden = (sqrt(5) + 1) / 2

Lorsqu'une fonction est appelée en mode interactif, Julia affiche le résultat :

sqrt(5)
2.23606797749979

Cependant, dans un script contenant une instruction telle que :

sqrt(5)

si une fonction avec retour est appelée seule, la valeur de retour est définitivement perdue. Ce script calcule bien la racine carrée de 5, mais, comme il n'enregistre ni n'affiche le résultat, il n'est guère utile.

Les fonctions vides ou nulles peuvent afficher un message à l'écran ou avoir quelque autre effet, mais elles n'ont pas de valeur de retour. Si le résultat est attribué à une variable, nous obtenons une valeur spéciale appelée nothing.

julia> resultat = élève_au_carré(5)
25
julia> show(resultat)
nothing

Pour imprimer la valeur nothing, nous devons utiliser la fonction show qui agit comme println, mais en gérant la valeur nothing.

La valeur nothing n'est pas de la même nature que la chaîne « nothing ». C'est une valeur spéciale qui est caractérisée par son propre type :

julia> typeof(nothing)
Nothing

Nous commencerons à rédiger des fonctions avec retour au chapitre 6Fonctions avec retour et suivants.

Il ne semble peut-être pas évident de comprendre pourquoi il est astucieux de diviser un programme en fonctions. Il existe plusieurs raisons à cela :

• la création d'une nouvelle fonction offre la possibilité de nommer un groupe d'instructions, ce qui rend tout programme plus facile à lire et à déboguer ;
• les fonctions rendent un programme plus concis en éliminant le code répétitif. Plus tard, s'il apporte une modification, le programmeur ne doit l'introduire qu'à un seul endroit ;
• diviser un programme de grande taille en fonctions permet de déboguer chaque partie une à une et les assembler ensuite en un tout opérationnel ;
• des fonctions bien conçues sont souvent utiles pour de nombreux programmes. Une fois écrite et déboguée, une fonction peut être réutilisée ;
• en Julia, les fonctions améliorent considérablement la performance.

Le débogage est une des compétences les plus importantes qu'un programmeur doit absolument acquérir. Bien qu'il puisse être frustrant, le débogage est une des parties les plus riches intellectuellement, les plus stimulantes et les plus intéressantes de la programmation. D'une certaine manière, le débogage ressemble au travail de détective. Confronté à des indices, le programmeur doit déduire les processus et les événements qui ont conduit aux résultats erronés observés.

Le débogage s'avère également similaire à une science expérimentale. Lorsque se présente une idée de ce qui coince, il convient de modifier le programme et l'essayer à nouveau. Si l'hypothèse est correcte, le résultat de la modification peut être prédit et, graduellement, on s'approche d'un programme opérationnel. Si l'hypothèse est fausse, il faut en formuler une nouvelle. Comme l'a fait remarquer Sherlock Holmes :

When you have eliminated the impossible, whatever remains, however improbable, must be the truth. (A. Conan Doyle — The Sign of Four.)
Lorsque vous avez éliminé l'impossible, ce qui reste, si improbable soit-il, est nécessairement la vérité. (Traduction de Jeanne de Polignac.)

Pour certains, la programmation et le débogage sont une seule et même notion : la programmation est le processus qui consiste à déboguer progressivement un programme jusqu'à ce qu'il exécute ce à quoi il est destiné. L'idée est de commencer avec un programme qui fonctionne et d'y apporter de petites modifications, en les déboguant au fur et à mesure.

Par exemple, Linux est un système d'exploitation qui contient des millions de lignes de code. Pourtant, il a commencé comme un simple programme que Linus Torvalds a utilisé pour explorer la puce Intel 80386. Selon Larry Greenfield dans The Linux User's Guide : « Un des premiers projets de Linus était un programme qui permettait de passer de l'impression "AAAA" à "BBBB". Ce programme a ensuite évolué vers le noyau Linux ».

fonction séquence nommée d'instructions qui effectue une opération utile. Les fonctions peuvent ou non prendre des arguments et peuvent ou non produire un résultat.

définition de fonction déclaration qui crée une nouvelle fonction, en précisant son nom, ses paramètres et les instructions qu'elle contient.

objet de fonction valeur créée par la définition d'une fonction. Le nom de la fonction est une variable qui fait référence à un objet de la fonction.

en-tête première ligne de la définition d'une fonction.

corps séquence d'instructions à l'intérieur d'une fonction.

paramètre nom utilisé à l'intérieur d'une fonction pour désigner la valeur passée en argument.

appel de fonction déclaration qui dirige l'exécution vers une fonction. Elle se compose du nom de la fonction suivi d'une liste d'arguments entre parenthèses.

argument valeur fournie à une fonction lorsque celle-ci est appelée. Cette valeur est attribuée au paramètre correspondant dans la fonction.

variable locale variable définie à l'intérieur d'une fonction. Une variable locale ne peut être utilisée qu'à l'intérieur de la fonction où elle est déclarée.

valeur de retour résultat du traitement d'une fonction. Si un appel de fonction est utilisé comme une expression, la valeur de retour est la valeur de l'expression.

fonction avec retour fonction qui retourne une valeur à l'appelant.

fonction void (fonction nulle ou vide) fonction qui retourne toujours nothing.

nothing valeur spéciale renvoyée par les fonctions vides (dites nulles).

composition (ou combinaison) utilisation d'une expression (ou d'une déclaration) dans le cadre d'une expression (ou d'une déclaration) plus large.

flux d'exécution ordre d'exécution des instructions.

diagramme de pile représentation graphique d'une pile de fonctions, de leurs variables et des valeurs auxquelles elles se réfèrent.

cadre rectangle dans un diagramme de pile qui représente un appel de fonction. Un cadre contient les variables locales et les paramètres de la fonction.

trace d'appel (ou stacktrace) liste des fonctions qui sont en cours d'exécution, imprimée lorsqu'une exception se produit. Ce terme a pour synonyme trace de pile, stack trace, stack backtrace ou encore stack traceback.

3-14-1. Exercice 3-2▲

julia> rightjustify("Julieta")
                                                                     Julieta

3-14-2. Exercice 3-3▲

function dotwice(f) 
    f()
    f() 
end

function printspam()
    println("spam")
end

dotwice(printspam)

3-14-3. Exercice 3-4▲

println("+", "-")

print("+")
println("-")