Full Circle Magazine FR

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
**Okay rustafarians, we head back to Rust development as @Daredevil14 and Ellin complained about where Lucas’ rust blog went. It looks like you guys want more rust and less ‘security nonsense’. Firstly, do not neglect to read the above book. If you are a complete beginner to rust or even to programming, we got you covered here at FCM. These articles are not to replace the book mentioned above, think of it more as helpers along the way.

Since we received no feedback on this – other than the initial complaint about Lucas’s blog – we have decided to retire this one.

From next issue onward, we will try something different.**

OK, bandes de RUST-iques, nous revenons au développement de Rust car @Daredevil14 et Ellin se sont plaints de la direction que prenait le blog de Lucas sur Rust. Il semblerait que vous aimeriez toujours plus de rust et moins de « non-sens sur la sécurité ». En premier lieu, ne négligez pas la lecture du livre indiqué précédemment. Si vous êtes complètement débutant dans Rust ou même en programmation, vous trouverez ce qu'il vous faut ici, dans le FCM. Ces articles n'ont pas l'intention de remplacer le livre déjà cité ; voyez-les plutôt comme une aide en parallèle.

Comme nous n'avons eu aucun retour de votre part - autre que les plaintes initiales à propos du blog de Lucas - nous avons décidé de ranger celui-ci au placard.

À partir du prochain numéro, nous essaierons quelque chose d'autre.

**When you need several instructions performed one after another, we put them into a function. You have seen functions from the start, as main() is a function. Functions take the form of: fn name(arguments), and, to call said function, you use it without the fn part. So far, we have used the main function only and no user-defined functions. Functions don’t have to just print something on the screen, like we have been doing, but functions can take arguments and return values. However, unlike C, or other older programming languages, you do not have to specify FIRST what you expect back, but you use an arrow to tell it what the output should be. It should look something like this: 

fn average(x: i32, y: i32, z: i32 ) -> i32

Note that the arrow is not ‘=>’ like we used before. But that is also not where the odd things end; if you want to return a value, you do not end the statement with a semicolon.**

Quand nous avons besoin d'exécuter plusieurs instructions à la suite, nous les mettons dans une fonction. Depuis le début, vous avez vu des fonctions, car main() est une fonction. Les fonctions prennent la forme : fn nom(arguments) et, pour appeler ladite fonction, vous l'utilisez sans la partie « fn ». Jusqu'ici, nous n'avons utilisé que la fonction main et aucune fonction définie par l'utilisateur. Les fonctions ne font pas qu'afficher quelque chose à l'écran, comme nous l'avons fait ; les fonctions peuvent recevoir des arguments et renvoyer des valeurs. Cependant, à l'inverse du C, ou d'autres anciens langages de programmation, vous n'avez pas à spécifier D'ABORD ce que vous attendez en retour, mais vous utilisez une flèche pour lui dire ce que devrait être la sortie. Elle ressemblerait à quelque chose comme ça :

fn average(x: i32, y: i32, z: i32 ) -> i32

Notez que la flèche n'est pas le « => » que nous avons utilisé précédemment. Mais ce n'est pas pour ça qu'il n'y a plus de choses bizarres ; si vous voulez retourner une valeur, vous ne devez pas terminer la déclaration avec un point-virgule.

**Those trip me up, though if you think about it, makes perfect sense. I know we are hopping back to 3.3 in the book, but I thought it was important to point it out, as it is mentioned, but often overlooked. Now we can move on to part 7.

In the beginning, when crates were mentioned, I thought of them as packages. But in Rust, we need to be clear: A package is one or more crates that provide a set of functionality. A package contains a ‘cargo.toml’ file that describes how to build those crates.**

Ces points m'ont posé un problème ; mais, si vous y réfléchissez bien, ça a tout son sens. Je sais que nous revenons à la section 3.3 du livre, mais je pense qu'il est important de le souligner, car il est indiqué, mais souvent négligé. Maintenant, nous pouvons passer à la partie 7.

Au début, quand les « crates » ont été citées, je les voyais comme des paquets. Mais, dans Rust, nous devons être clair : un « Package » (paquet) est un ou plusieurs « crates » (cagette) qui fournissent un ensemble de fonctionnalités. Un paquet contient un fichier « cargo.toml » qui décrit comment construire les crates.

**You will notice that the book refers us back to chapter 2, where we used the ‘rand’ crate, for random numbers. TL;DR we had to add a [dependencies] section and add rand. We also needed to build our file to reflect the changes with: ‘cargo build’. We used the random generator with ‘use rand::Rng’. However, as I understand it, it is better to add the crate right at the beginning. Simply add: ‘extern crate rand;’ before you use it as above. Now, obviously crates.io is not the be-all and end-all of crates, as you can roll your own. Noobs like me get tripped up on this one, as our [dependencies] section now needs to contain the path to our home-rolled crate. In Linux, we use ./ for the same directory and ../ for the directory above, so triple-check your paths before building! Because rust’s error output is so nice and verbose, we should catch this immediately, so build it without specifying the path, to see what the error looks like, and this will help you in the future when you are trying to figure out what went wrong. The great chess players do not only think about moves, but study patterns on the board, that is how they become great. You too will become a great programmer if you can spot an error and immediately recognise it and know how to remedy it.**

Vous remarquerez que le livre nous fait nous référer au chapitre 2, où nous avons utilisé le crate « rand », pour les nombres aléatoires. En bref : nous avons dû ajouter une section [dependencies] (dépendances) et ajouter rand. Pour refléter les modifications, nous avons dû aussi compiler notre propre fichier avec : « cargo build ». Nous avons utilisé le générateur de nombre aléatoire avec « use rand::Rng ». Cependant, comme je le comprends, c'est mieux d'ajouter le crate tout au début. Ajoutez simplement : « extern crate rand; » avant que vous l'utilisiez comme ci-dessus. Maintenant, évidemment, crates.io n'est pas l'alpha et l’oméga des crates, car vous pouvez empaqueter vos propres crates. Les débutants comme moi sont déroutés sur ce point, car notre section [dependencies] doit maintenant contenir le chemin vers le crate fait-maison. Dans Linux, nous utilisons ./ pour le même répertoire et ../pour le répertoire du niveau supérieur ; aussi, vérifiez bien vos chemins avant de compiler ! Comme la sortie d'erreur de rust est si belle et documentée, nous devons la découvrir tout de suite ; aussi, compilez sans spécifier le chemin, pour voir à quoi ressemble l'erreur ; ça vous aidera par la suite quand vous essaierez de trouver pourquoi ça ne marche pas. Les grands joueurs d’échecs ne pensent pas qu'aux prochains déplacements mais étudient aussi les dispositions sur l'échiquier ; c'est pour ça qu'ils deviennent excellents. Vous aussi, vous deviendrez un excellent programmeur si vous pouvez déceler une erreur, la reconnaître immédiatement et savez y remédier.

**Speaking of errors, do section 7.3, to catch that error. Now, when you head to section 7.4, you may be disgusted that they mention the ‘use’ keyword only now, after you have typed so many paths and double-colons you get nightmares about it. That is the reason I mention it now so you do not skip anything in section 7.4. On that note, the book does refer you to chapter 14, cargo workspaces. I suggest that if you are a noob, do not jump here, you need to have worked your way through at least chapter 12, before attempting chapter 14.**

À propos d'erreurs, faites la section 7.3, pour trouver cette erreur. Maintenant, si vous allez à la section 7.4, vous serez sans doute dégouté par le fait que le mot-clé « use » n'est mentionné que maintenant, après avoir tapé tant de chemins et de points-virgules que vous en avez fait des cauchemars. C'est pour cette raison que j'en parle maintenant de façon à ce que vous ne ratiez rien de la section 7.4. À ce propos, le livre vous fait vous référer au chapitre 14, les « workspaces » (espaces de travail) cargo. Je vous suggère, si vous êtes novice, de ne pas y passer directement ; vous avez besoin, avant, de travailler au moins jusqu'au chapitre 12 inclus.

**Let us quickly talk about ownership and borrowing. This is one of the legs that Rust stands on. Grasping this will help you a lot. Lots of programming of non-trivial programs will have you getting data, manipulating that data in some way, then outputting the result. This book in your web browser is a nice example. When you click on the link to chapter 14, it figures out where that page is stored, grabs the data and displays it in your browser. The speed of data is usually connected to where it is stored. If your data is on the internet, like a web page, it is slow as it needs to be lifted from long-term memory (disk) to short-term memory (ram), and then sent over the network. If your data is local, it just needs to do the first two steps and if it is in memory, that is only one step. Reading from disk is slower than reading from memory. Speed is not the only consideration here, space is another. Google has millions of gigabytes to store data on. Your hard drive may have only thousands of gigabytes and your memory in the tens column. So, as the speed increases, it becomes necessary to manage the space as you do not have an infinite amount. We can look into the concepts of ownership and borrowing if there is interest, but this is a good topic for you to read up on in your favourite browser as it is covered in section 4, but I suggest adding another source to get a different perspective. **

Parlons rapidement de propriété et d'emprunt. C'est un des piliers sur lesquels Rust prend appui. Comprendre ça vous aidera beaucoup. Beaucoup de programmation de programmes non-triviaux vous amèneront à obtenir des données, à les manipuler d'une façon ou d'une autre, puis à sortir le résultat. Ce livre dans le navigateur Web est un bon exemple. Quand vous cliquez sur le lien vers le chapitre 14, il trouve où cette page est stockée, récupère les données et les affiche dans votre navigateur. La vitesse des données est en général en relation avec l'endroit où elles sont stockées. Si vos données sont sur Internet, comme une page Web, c'est lent car il est nécessaire de les passer d'une mémoire à long terme (disque) à une mémoire à court terme (ram), puis de les envoyer sur le réseau. Si vos données sont en local, il est juste nécessaire de les lire dans la mémoire. La vitesse n'est pas la seule considération ici ; l'espace en est une autre. Google a des millions de gigaoctets pour le stockage des données. Votre disque dur n'a peut-être que des milliers de gigaoctets et votre mémoire en a une dizaine. Aussi, quand la vitesse augmente, il devient nécessaire de gérer l'espace car vous n'en avez pas une quantité infinie. Nous pouvons regarder les concepts de propriété et d'emprunt s'il y a de l'intérêt, mais c'est pour vous un bon sujet à lire dans votre navigateur favori car il est traité en section 4 ; mais je vous suggère d'ajouter une autre source pour disposer d'une perspective différente. 

**That’s it for now. Next issue we will look at other things.

As always, if you need to reach us: misc@fullcirclemagazine.org**

C'est tout pour aujourd'hui. La prochaine fois, nous regarderons d'autres choses.

Comme d'habitude, si vous avez besoin de nous joindre : misc@fullcirclemagazine.org**