Rust Odyssey

Leçons Le Book
Login
Rejoindre

Par Loïc Cavinato

Maitrise Rust rapidement !

La formation complète sur Rust.

Découvre le fonctionnement du bas niveau et plonge dans les profondeurs de Rust.

Rejoindre

95€

Un plan pour réussir

1. Introduction

1. Pourquoi Rust

Notions abordées :

  • Les avantages de Rust
  • Où trouve-t-on Rust ?
  • Un langage compilé
  • Les langages interprétés
  • Petite mise en garde
  • Un langage à typage statique
  • Gestion de la mémoire
  • 2. Binaire et autres bases

    Notions abordées :

  • Pourquoi la machine utilise le binaire ?
  • Notion de système numérique et de base
  • Comprendre notre base 10
  • Décoder un nombre en binaire
  • Décoder un nombre en octal
  • Décoder un nombre en hexadecimal
  • Encoder un nombre vers le binaire
  • Encoder un nombre vers l’octal
  • Encoder un nombre vers l’hexadecimal
  • 3. La Mémoire

    Notions abordées :

  • Notion de Bit et d’Octet
  • Notion de MSB
  • Notion de LSB
  • Adresse mémoire
  • Taille des nombres en mémoire
  • Entiers positifs en mémoire
  • Entiers positifs ou négatifs en mémoire
  • 4. Le tooling de Rust

    Notions abordées :

  • Installation de Rust
  • Compiler avec rustc
  • Premier projet avec cargo
  • Cargo.toml
  • Le fichier main.rs
  • Notion de toolchain
  • Gérer différentes versions de Rust avec rustup
  • Les branches stable, beta et nightly
  • Compiler vers un target spécifique
  • 5. Exercices Chapitre 1

    Notions abordées :

  • Exercice 1
  • Exercice 2
  • Exercice 3
  • Exercice 4
  • Exercice 5
  • Exercice 6
  • Exercice 7
  • Exercice 8
  • Exercice 9
  • Exercice 10
  • Exercice 11
  • 2. Fondamentaux

    1. Variables et constantes

    Notions abordées :

  • Déclaration et assignation
  • Commentaires
  • Modifier une variable
  • Shadowing
  • Portée
  • Inférence de type
  • Constantes
  • 2. Types primitifs

    Notions abordées :

  • Booléens
  • Entiers non signés
  • Entiers signés
  • Nombres décimaux
  • Caractère
  • 3. Casting

    Notions abordées :

  • Définition
  • Conversion vers un type plus grand
  • Conversion vers un type plus petit
  • Les différentes conversions possibles
  • 4. Types composés

    Notions abordées :

  • Définition
  • Les tuples
  • Destructuration des tuples
  • Les arrays
  • Initialisation des arrays
  • Destructuration des arrays
  • 5. Control flow

    Notions abordées :

  • Opérateurs mathématique
  • Opérateurs de comparaison
  • Opérateurs logiques
  • if, else if, else
  • Boucles while
  • Boucles loop
  • Boucles for
  • Boucles avec label
  • 6. Fonctions

    Notions abordées :

  • Signature de fonction
  • Appel de fonctions
  • Fonctions sans type de retour explicite
  • Expressions et déclarations
  • 7. Les modules

    Notions abordées :

  • Notion de crate
  • Notion de module
  • Utiliser un fichier comme module
  • Utiliser un dossier comme module
  • Utiliser des modules dans d’autres dossiers
  • 8. Exercices Chapitre 2

    Notions abordées :

  • Exercice 1
  • Exercice 2
  • Exercice 3
  • Exercice 4
  • Exercice 5
  • Exercice 6
  • 3. Gestion de la mémoire

    1. La Stack

    Notions abordées :

  • Fonctionnement de la Stack
  • Usage de la Stack
  • Un regard sur l’assembleur
  • Stack Overflow
  • 2. Les références

    Notions abordées :

  • Définition
  • Pourquoi utiliser des références ?
  • Rust copie les types primitifs
  • Éviter les copies avec les références
  • Références immutables
  • Références mutables
  • Règles de l’emprunt
  • Déréférencement
  • Slices
  • 3. La Heap

    Notions abordées :

  • Quand utiliser la Heap ?
  • Pourquoi la Stack ne suffit pas ?
  • Les vecteurs et la Heap
  • Notion d’allocateur
  • Données sur la Heap mais pointeur sur la Stack
  • L’allocateur optimise les allocations
  • Pas de copie pour la Heap
  • 4. Ownership

    Notions abordées :

  • Règles de propriété
  • Comment éviter un move ?
  • Savoir quand il y a copie ou move
  • 5. Vecteurs et String

    Notions abordées :

  • Utilité des vecteurs
  • Notion de capacité
  • Slices
  • Méthodes de base des vecteurs
  • 6. Exercices Chapitre 3

    Notions abordées :

  • Exercice 1
  • Exercice 2
  • Exercice 3
  • Exercice 4
  • Exercice 5
  • Exercice 6
  • 4. Abstractions de niveau 1

    1. Struct

    Notions abordées :

  • Découverte des structs
  • Instantiation
  • Les structs sont move par défaut
  • Tuple struct
  • Unit struct
  • Les méthodes
  • Les fonctions associées
  • 2. Traits

    Notions abordées :

  • Définition
  • Trait avec implémentation par défaut
  • Le trait Clone
  • Le trait Copy
  • Le trait Debug
  • 3. Enum

    Notions abordées :

  • Le concept d’enum
  • Variante avec données sans nom
  • Variante avec données nommées
  • Patterns avec les tuples
  • Patterns avec les structs
  • Patterns avec match
  • Extraire des données de variantes avec match
  • Extraire des données de variantes avec if let
  • Extraire des données de variantes avec let … else
  • 4. Lifetime

    Notions abordées :

  • Pourquoi a-t-on besoin des lifetimes ?
  • Comment Rust évite les dangling références ?
  • Lifetimes et fonctions
  • Une erreur courante
  • Les Lifetimes et les struct
  • Quand omettre les lifetimes ?
  • Le lifetime static
  • 5. Exercices Chapitre 4

    Notions abordées :

  • Exercice 1
  • Exercice 2
  • Exercice 3
  • Exercice 4
  • Exercice 5
  • Exercice 6
  • Exercice 7
  • Exercice 8
  • 5. Abstractions de niveau 2

    1. Génériques

    Notions abordées :

  • Utilité des génériques
  • Génériques dans les structs
  • Génériques dans les fonctions
  • Génériques dans les traits
  • Génériques dans les enum
  • 2. Options

    Notions abordées :

  • Utilité du type Option
  • Le type Option est un enum
  • Extraire la valeur d’un Option
  • Extraction forcée avec unwrap
  • Option comme paramètre optionnel de fonction
  • L’opérateur ? sur les Options
  • 3. Erreurs

    Notions abordées :

  • Les 2 types d’erreurs
  • Erreurs irrécupérables
  • Erreurs récupérables avec Result
  • L’opérateur ? sur un type Result
  • 4. Exercices Chapitre 5

    Notions abordées :

  • Exercice 1
  • Exercice 2
  • Exercice 3
  • Exercice 4
  • Exercice 5
  • Exercice 6
  • Exercice 7
  • Exercice 8
  • Exercice 9
  • 6. Closures itérateurs et asynchrone

    1. Closures

    Notions abordées :

  • Définition
  • Closures avec lecture de variables dans leur environnement
  • Closures avec écriture de variables dans leur environnement
  • Closures avec move de variables dans leur environnement
  • Forcer une closure à move
  • 2. Itérateurs

    Notions abordées :

  • Pourquoi s’intéresser aux itérateurs ?
  • Définition
  • L’intérêt des itérateurs
  • Méthodes qui consomment l’itérateur
  • Méthodes qui produisent d’autres itérateurs
  • Méthodes à connaitre
  • 3. Asynchrone

    Notions abordées :

  • Notion de Thread
  • Notion de concurrence
  • Notion de multi-threading
  • Notion de parallélisme
  • Runtime
  • L’Asynchrone pour ne pas bloquer le thread
  • Calculer en simultané avec le parallélisme
  • 4. Exercices Chapitre 6

    Notions abordées :

  • Partie 1 Exercice 1
  • Partie 1 Exercice 2
  • Partie 1 Exercice 3
  • Partie 1 Exercice 4
  • Partie 1 Exercice 5
  • Partie 1 Exercice 6
  • Partie 1 Exercice 7
  • Partie 1 Exercice 8
  • Partie 1 Exercice 9
  • Partie 1 Exercice 10
  • Partie 2 Exercice 1
  • Partie 2 Exercice 2
  • Partie 2 Exercice 3
  • Partie 2 Exercice 4
  • Maitrise Rust rapidement

    Je sais que ton temps est précieux, c'est pourquoi la formation va te permettre d'arriver très vite à un bon niveau en Rust.

    La chose la plus importante lorsqu'on apprend, c'est de tester ses connaissances. Tu trouveras à la fin de chaque chapitre des exercices pour t'entrainer et valider tes acquis.

    Une fois la théorie maitrisée, tu n'auras plus aucune limite et tu verras que Rust n'est pas si difficile.

    Bien plus que Rust...

    La plupart des devs qui veulent apprendre Rust viennent de langage "haut niveau" comme Python, TS, etc.

    Afin de t'expliquer Rust correctement, on va passer par une phase de mise à niveau concernant le binaire, les adresses mémoires, les pointeurs, etc.

    Cette phase va te débloquer énormément de notions qui pouvaient rester floues et qui te seront utiles partout en programmation !

    Apprends avec Loïc

    Je m'appelle Loïc et je suis passionné de programmation et surtout de Rust.

    J'ai toujours aimé transmettre mes connaissances à ceux qui voulaient devenir meilleurs et apprendre de nouvelles choses.

    Aujourd'hui, j'ai la chance de pouvoir transmettre avec passsion tout ce que j'ai appris concernant ce magnifique langage qu'est Rust.

    Ce qu'en pensent les devs...

    Bryan F. ⭐⭐⭐⭐⭐

    J’ai suivi la formation Rust de Loïc, et l’expérience a été excellente. Il maîtrise parfaitement le langage et le contenu de son cours est particulièrement bien structuré (introduction à l'ingénierie logicielle, assembleur, move, LSP, etc.).

    Grâce à la clarté de ses explications et à la qualité des réponses apportées aux questions que j’ai pu lui poser, la barrière à l'entrée inhérente à Rust est rapidement tombée.

    Je suis reparti avec toutes les bases nécessaires pour développer une application desktop complète en Rust avec Dioxus, un framework qui n’était pourtant même pas abordé durant la formation.

    En plus d’être très pédagogue, Loïc est aussi quelqu’un de très sympa :) Cela a vraiment contribué à créer une bonne ambiance tout au long de la formation.

    John ⭐⭐⭐⭐⭐

    Formation très pertinente qui fait exploser les mythes autour du langage Rust.

    L’expertise et l’approche unique de Loïc m’ont permis de comprendre les bases ainsi que des notions réputées complexes. Clarté inestimable.

    Kingsley T. ⭐⭐⭐⭐⭐

    La formation Rust de Loïc Cavinato est excellente.

    Le découpage des modules est particulièrement bien pensé, avec une progression fluide de la théorie vers la pratique.

    Chaque notion est expliquée avec précision, clarté et pédagogie, ce qui rend l’apprentissage très efficace.

    Colin ⭐⭐⭐⭐⭐

    Formation super top !

    Venant initialement d'une formation bootcamp, ça m'a permis de combler le fossé entre les langages bas niveau et haut niveau.

    Je comprend enfin comment le programme interagit avec les composants du PC.

    Ça ouvre la voie à une nouvelle façon de programmer, mieux maitrisée et plus efficiente.

    Très bon travail de vulgarisation de la part de Loïc , tout était simple et clair !

    Mehdi ⭐⭐⭐⭐⭐

    Super formation !

    Peut importe d'ou l'on vient c'est accessible les bases donné au début sont véritablement game changer pour comprendre rust et ne pas tomber dans les grands pièges du langage :)

    Le travail de vulgarisation est clairement réussi 💪

    Israël T. ⭐⭐⭐⭐⭐

    Formation Rust de qualité, que je recommande volontiers.

    Elle m'a permis de démystifier le langage et d'en comprendre les fondamentaux avec clarté. Le contenu est bien structuré, les slides sont soignées et accessibles et les exercices pratiques, conçus sur mesure, renforcent efficacement la compréhension.

    La disponibilité du formateur est appréciable: il prend le temps de répondre aux questions et adapte son rythme au groupe. On repart avec de vraies bases solides et l'envie d'aller plus loin.

    La partie TDD est à venir et je suis déjà impatient d'y participer.

    Des questions ?

    Quels sont les prérequis ?

    Tu dois simplement connaitre au moins un langage de programmation.

    Si tu n'as jamais vu de langage bas niveau, la mémoire, les pointeurs, etc aucun soucis !

    Cette formation est pensée pour être accessible au plus grand nombre, c'est pour ça que l'on va voir toutes ces notions ensemble !

    Est-ce que c'est difficile ?

    Rust est réputé pour être un langage difficile.

    Cependant, c'est souvent parce que les débutants codent trop tôt, au lieu de chercher à comprendre la théorie.

    En réalité Rust n'est pas difficile, il demande juste de comprendre des concepts bas niveau.

    C'est pourquoi on va voir les bases du langage pour tout éclaircir et éviter les bugs frustrants que tu peux rencontrer si tu évites les fondamentaux.

    Est-ce que je peux tester les leçons ?

    Absolument !

    J'ai même codé cette plateforme spécialement pour que tu puisses essayer la formation dans le but de te faire une idée avant d'acheter.

    Alors n'hésite pas à regarder le contenu gratuit si tu souhaites voir le contenu du cours ou ma façon d'enseigner.

    Que faire si j'ai besoin d'aide ?

    J'organise des lives de questions/réponses une fois par semaine.

    Si un point te bloque, c'est l'occasion d'en parler à ce moment-là :D !