Outils pour utilisateurs

Outils du site


issue159:c_c

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Prochaine révision
Révision précédente
Dernière révisionLes deux révisions suivantes
issue159:c_c [2020/08/02 07:46] – créée d52frissue159:c_c [2020/08/07 09:31] andre_domenech
Ligne 1: Ligne 1:
-Traduction en coursailleurs !+**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 programming, we’ve got you covered here at FCM. 
 + 
 +These articles are not to replace the book mentioned above, think of them more as helpers along the way.** 
 + 
 +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é le mois dernier. Si vous êtes complètement débutant dans Rust ou même en programmationvous trouverez ce qu'il vous faut ici, dans le FCM.  
 + 
 +Ces articles n'ont pas l'intention de remplacer le livre cité plus haut ; voyez-les plutôt comme une aide en parallèle. 
 + 
 +**At the moment, we are just taking a high-level view of things. We can drill down into each of these topics we have covered in more detail. If you have been following Greg’s excellent tutorials, you would be familiar with local and global variables. (The scope of the variables). The thing in Rust is, every variable has an owner, which is a variable too. Sounds confusing? Come read chapter 4.1 with us! 
 + 
 +This will be chapter four in the book above. This is the direct link: https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html** 
 + 
 +Pour le moment, nous ne faisons qu'avoir une vision générale des choses. Nous pouvons rentrer dans le détail de chacun des sujets dont nous avons parlé. Si vous suivez les excellents tutoriels de Greg, vous êtes à l'aise avec les variables locales et globales (l'étendue d'application des variables). Le point, c'est que dans Rust chaque variable a son propriétaire, qui est aussi une variable. Ça vous paraît confus ? Venez lire le chapitre 4.1 avec nous. 
 + 
 +Ce serait le chapitre 4 dans le livre cité au-dessus. Voici le lien direct : https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html 
 + 
 +**What does it mean to own data? Why would you need to own data? Is there a tax to be paid for owning data? Well, from what I can tell, there is no performance hit, but you take a hit in file size. When you compile a tiny ‘hello world’ console application, you end up with 2MB instead of 2KB. Let me try to break it down. Each piece of data has an owner, which is obviously a variable. That owner is responsible for cleaning up after that data. The owner decides if the data can be changed (is it mutable?) This “cleanup” happens when the owner goes out of scope. What do we mean by this? When you create a function, you have starting and ending curly braces. Any variable within those curly braces has scope only there, so when your program steps out of the last curly brace, the magic happens. Just for those a bit more curious, that “magic” is called “drop”. ** 
 + 
 +Qu'est-ce que ça signifie d'être propriétaire des données ? Pourquoi j'ai besoin de posséder des données ? Y a-t-il une taxe à payer quand on possède des données ? Eh bien, pour ce que je peux en dire, il n'y a pas de gain en performance, mais vous atteignez des sommets en taille des fichiers. Quand vous compilez une maigre application « hello word » à la console, vous vous retrouvez avec 2 Mo au lieu de 2 Ko. Laissez-moi vous détailler ça. Chaque élément de donnée a un propriétaire, qui est évidemment une variable. Ce propriétaire est responsable du nettoyage de cette donnée. Le propriétaire décide si elle peut être modifiée (est-elle mutable ?) Ce « toilettage » arrive quand le propriétaire sort du champ d'application. Que voulons-nous dire par là ? Quand vous créez une fonction, vous commencez et finissez par des accolades courbes. Toute variable dans ces accolades courbes n'existe que sur ce domaine ; aussi, quand votre programme ressort après la dernière accolade courbe, la magie opère. Juste pour ceux qui sont un peu plus curieux, cette « magie » s'appelle un « drop » (laisser tomber). 
 + 
 +**How about we use a real world allegory: your friend Tammy has a games night. You bring your favourite card game, Exploding Kittens. Everyone else brings their favourite game too. When you are done playing Exploding Kittens, you, as the owner, pick up all the cards on the table and pack them back into the container and take it home with you when you leave. If you leave the cards lying on the table, it would make it difficult to play the next card game. You also won’t be invited back if you expect someone else to pack up your cards after every game. You may have heard that some programming languages have “garbage collection”. This is great, but there is a performance hit as this program needs memory and CPU cycles to clean up automatically after your mess.** 
 + 
 +Pour cela, utilisons une allégorie du monde réel : votre ami Tammy organise un nuit de jeux. Vous apportez votre jeu favori, Exploding Kittens. Les autres apportent aussi leurs jeux favoris. Quand vous avez fini de jouer à Exploding Kittens, vous, en tant que propriétaire, vous ramassez toutes les cartes sur la table et vous les rangez dans la boîte pour les ramener chez vous quand vous rentrerez. Si vous laissez des cartes sur la table, ça sera difficile de jouer au jeu de cartes la prochaine fois. Vous ne serez plus invité si vous comptez sur quelqu'un d'autre pour ranger vos cartes en fin de jeu. Vous avez peut-être entendu parler de certains langages de programmation qui ont un « ramassage des ordures ». C'est superbe, mais il y a un impact sur la performance car ce programme a besoin de mémoire et du CPU pour nettoyer automatiquement tout votre bazar. 
 + 
 +**Remember when we declare a variable in Rust, we have the option to use the “mut” keyword. Now obviously, when you change a variable, its size in memory changes too, imagine changing a string “FCM” to this whole article, three characters vs three thousand. So the memory allocation can change. And that extra may need to be cleaned up. In the example in the Rust book, you may have noticed: “ let mut s = String::from("hello"); ” I am going to oversimplify this, but hear me out. This now creates data, say five bytes, each containing one character from that string “hello”. So you have the first byte being an “h”, the next an “e”, and so on. The “ :: “ notation is new to me too, so don’t feel left out. For now, simply do it that way and memorise how it is used. Don’t worry, if you don’t understand the references in the examples in the book, they refer to other programming language syntax, to help programmers who are familiar with those other programming languages transition to Rust more smoothly. ** 
 + 
 +Souvenez-vous que quand vous déclarez une variable dans Rust, vous avez la possibilité d'utiliser le mot-clé « mut ». Maintenant, évidemment, quand vous modifiez une variable, sa taille en mémoire change aussi ; imaginez la modification de la chaîne « FCM » dans tout l'article, 3 caractères contre 3 mille. Aussi, l'allocation de la mémoire peut être modifiée aussi. Et ce supplément nécessite aussi un nettoyage. Dans l'exemple du livre sur Rust, vous avez peut-être noté : « let mut s = String::from("hello"); ». Je vais le simplifier à l'extrême, mais écoutez-moi. Ceci crée immédiatement les données, disons 5 octets, chacun contenant un caractère de la chaîne « hello ». Aussi, vous avez le premier octet qui est un « h », ensuite un « e », et ainsi de suite. La notation « :: » est nouvelle aussi pour moi ; ne vous sentez donc pas hors jeu. Pour le moment, faites-le comme ça et souvenez-vous de comment il est utilisé. Ne vous inquiétez pas si vous ne comprenez pas les références des exemples du livre, il font référence à des syntaxes d'autres langages de programmation, pour aider les programmeurs qui sont à l'aise avec ceux-ci à passer en douceur à Rust. 
 + 
 +**Because the owner of the data is a variable, that too, can change. Consider declaring a variable a, then assigning a to b (let a = “FCM” then let b = a). You have now transferred ownership from a to b. But, Aber, Pero, Ale. What if you want to keep using your original declaration? Well, then Rust has cloning. This allows you to keep ownership of your data, but also give ownership to another piece of your code. If you see an error: “value used here after move”, you probably need to clone. By the way, that error is really descriptive, it tells you that you tried to use a variable’s value after it was moved to another owner (like in the example above). Now cloning takes up that same amount of memory again, so be careful when cloning. Don’t just clone willy-nilly. To clone a variable, you add the “.clone” to your variable when you use it. So a.clone() will let you clone the “FCM” value in our example above. If you need to, re-read this section in the book, I certainly did!** 
 + 
 +Comme le propriétaire des données est une variable, elle peut changer, elle aussi. Supposez que vous déclarez une variable a, puis assignez a à b (let a = "FCM" puis let b = a). Vous avez maintenant transféré la propriété à b. Mais Aber, Pero, Ale. Que ce passe-t-il si vous voulez garder la déclaration initiale ? Eh bien, dans Rust, il y a le clonage. Cela vous permet de garder la propriété de vos données, mais de donner aussi la propriété à un autre élément de votre code. Si vous voyez le message d'erreur : « value used here after move » (Valeur utilisée ici après déplacement), vous aurez probablement besoin de cloner. Pendant que j'y suis, cette erreur est réellement descriptive ; elle vous dit que vous avez essayé d'utiliser la valeur d'une variable après qu'elle ait été transférée à un autre propriétaire (comme dans l'exemple du dessus). Pour ce qui est du clonage, il prend à nouveau la même quantité de mémoire ; soyez donc prudent en clonant. Ne clonez pas au petit bonheur. Pour cloner une variable, vous ajoutez « .clone » à votre variable quand vous l'utilisez. Ainsi, a.clone vous permet de cloner la valeur « FCM » de l'exemple ci-dessus. Si vous en sentez le besoin, relisez cette section du livre ; je l'ai vraiment fait ! 
 + 
 +**Now that you have an idea of ownership, next time we can talk about things like borrowing. As with anything, practice makes perfect. Try out the examples in the book, make mistakes, learn what the error messages mean. I know how frustrated I was when all I kept getting was “syntax error” after “syntax error”. At least Rust is a lot friendlier. Don’t be shy to try something, the worst that can happen is that you can die. Wait, that is not correct? Syntax error... :)** 
 + 
 +Maintenant que nous avons une idée de la propriété, la prochaine fois nous pourrons parler de choses comme la location. Comme en toute chose, la pratique rend parfait. Testez les exemples du livre, faites des erreurs, apprenez ce que signifie le message d'erreur. Je sais combien j'étais frustré quand tout ce que j'arrivais à obtenir c'était d'aller d'« erreur de syntaxe » en « erreur de syntaxe ». Au moins Rust est largement plus convivial. N'ayez pas peur d'essayer quelque chose, le pire qui puisse arriver c'est que vous puissiez mourir. Heu ! Attendez ! Ce n'est pas correct ? Erreur de syntaxe... :) 
 + 
 +**I urge you to go through the whole section above, right down to part 4.4. We can delve into this later, but for now I want you to get to grips with why this is important and why this sets Rust apart from other programming languages. Now, I don’t know Rust inside out, nor do I know all the nuances of programming, but as a newbie myself, I can give some newbie insights and things I have figured out for myself. Remember the book above is written for programmers, by programmers. As a newbie to Rust or programming, you may not always get what they are trying to bring across. This is where your friendly FCM team comes in, as we try to help you bridge that gap. If I made any mistakes, or if you have some insights to add that may aid new programmers and rustafarians alike, please drop us an email at: misc@fullcirclemagazine.org 
 + 
 +We welcome the feedback, as it helps us too.** 
 + 
 +Je vous invite avec insistance à parcourir toute la section du dessus, jusqu'à la partie 4.4. Nous pourrons nous plonger dedans plus tard, mais, pour le moment, je veux que vous compreniez pourquoi c'est important et pourquoi Rust est différent des autres langages de programmation. Maintenant, je ne connais pas parfaitement Rust de l'intérieur, et je ne connais pas non plus toutes les finesses de programmation ; mais, comme moi-même je débute, je peux donner quelques éléments de compréhension pour débutant et les choses que j'ai découvertes pour moi. Souvenez-vous que le livre ci-dessus a été écrit pour des programmeurs, par des programmeurs. En tant que nouveau dans Rust ou la programmation, vous ne pouvez pas toujours obtenir ce qu'ils sont en train de faire passer. C'est là qu'intervient votre sympathique équipe du FCM, car nous essayons de vous aider à combler le trou. Si je fais des erreurs, ou si vous avez des renseignements à ajouter qui peuvent aussi aider des nouveaux programmeurs et des RUST-iques, merci de nous envoyer un mail à : misc@fullcirclemagazine.org 
 + 
 +Nous vous remercions de votre retour, car il nous aide aussi. 
issue159/c_c.txt · Dernière modification : 2020/08/07 12:16 de auntiee