Formations DevOps Programmation Système Formation Rust Langage Programmation Ultra-Rapide

Formation Rust

Noté 4.3 sur 5
Logo Formation Rust
Prix 2490€ HT / personne
Durée 4 jours (28 heures)

Paris | Classe Virtuelle

Il ne reste que quelques places
NewCafés et déjeuners offerts en interentreprises
Disponible en intra-entreprise pour former votre équipe
Je ne veux pas me déplacer ? Option classe virtuelle gratuite

Présentation

Rust est un nouveau langage de programmation Open Source créé par Mozilla Research, conçu pour aider les développeurs à concevoir des applications ultra-rapides et sécurisées, utilisant avantageusement la puissance offerte par les processeurs multi-core modernes. Il permet d’éviter les erreurs de segmentation et assure la sécurité des threads, le tout avec une syntaxe élégante. Il a de très bonnes performances via sa gestion de la mémoire faite au niveau du compilateur et une compilation native.

Rust offre un haut niveau d’abstractions, garanti la sécurité de la mémoire, des threads sans problème de concurrence, des templates : trait-based generics, du pattern matching, l’inférence de type, et un binding C efficace, le tout avec runtime minimal !

Rust est donc un langage de programmation axé sur la sécurité, la vitesse et la concurrence. Sa conception vous permet de créer des programmes qui ont la performance et le contrôle d’un langage de bas niveau tel que le C, mais avec les abstractions puissantes d’un langage de haut niveau (C#, Java…). Ces propriétés rendent Rust adapté aux programmeurs qui ont de l’expérience dans des langages comme C/C++ mais qui recherchent une alternative plus sûre, ainsi que ceux qui utilisent des langages tels que Python mais qui recherchent des moyens d’écrire un code qui fonctionne plus efficacement sans sacrifier l’expressivité.

La devise de Rust est :
Performance, Sécurité, Productivité, choisissez-en trois !

À travers cette formation, vous apprendrez à utiliser tous les concepts de Rust à savoir : borrowing, ownership, lifetimes, mutabilité, génériques et bien d’autres choses afin de développer efficacement vos prochains projets !

Comme dans toutes nos formations, celle-ci vous présentera la toute dernière version de Rust Programming Language, Rust 1.68.

 

Objectifs

  • Découvrir, comprendre et utiliser le langage Rust et son écosystème dans vos futurs projets
  • Utiliser la programmation concurrente et la bonne gestion d’erreur avec Rust
  • Migrer efficacement vos applications C ou C ++ vers un environnement Rust

 

Public visé

Développeurs, Architectes

 

Pré-requis

  • Connaissances de base d’un système Unix
  • Connaissance de programmation (C, C#, Java, C#)

 

POUR ALLER PLUS LOIN

Programme de la formation Rust

 

Introduction à Rust

  • Téléchargement et installation de l’environnement Rust
    • rustup, cargo, rustc, crates.io
  • Mon premier programme
  • Ecrire vos tests unitaires : unit tests
  • Command-line arguments
  • Ecrire son web-serveur

 

Types basique : Basic types

  • Machine types
    • Integer, Floating-point, bool, Characters types
  • Tuples
    • Pointer types
    • References
    • Boxes
    • Raw pointers
  • Arrays, Vectors, and Slices
  • String types

 

Ownership

  • Ownership
  • Moves : operations, control flow, indexed content
  • Copy types : exception
  • Rc & Arc: shared ownership

 

Les conditions

  • if, else if et else
  • Les loops (loop, for et while)

 

References

  • References as values
  • Rust references VS C++ references
  • Assignation, comparaison, Null
  • References to slices and trait objects
  • Passing & Returning
  • Structs
  • Lifetime parameters
  • Sharing VS mutation

 

Expressions

  • Blocks & semicolons
  • Declarations
  • if and match, if let
  • Loops
  • Return expressions
  • Function & method calls
  • Fields & elements
  • Reference operators
  • Arithmetic, bitwise, comparison, and logical operators
  • Assignment, Type casts, Closures
  • Precedence & Associativity

 

Gestion d’erreur

  • Panic
  • Aborting, Result, Catching, Ignoring
  • Result type aliases
  • Propagating errors
  • Manipuler plusieurs types d’erreurs
  • Custom error type

 

Tools : Crates and modules

  • Crates : Build profiles
  • Modules : separate files
  • Visibility
  • Paths & imports
  • The standard prelude
  • Items : building blocks
  • Library
  • Répertoire src/bin
  • Attributes
  • Tests & documentation
  • Integration tests & Unit test
  • Benchmarks, Fuzzing
  • Doc-tests
  • Specifying dependencies
  • Versions
  • Cargo.lock
  • Publication : crates.io
  • Workspaces

 

Structs

  • Named-field structs
  • Tuple-like, Unit-like structs
  • Struct layout
  • Définir : methods implémentation
  • Generic structs
  • Lifetime parameters
  • Héritage : Traits for struct types
  • Mutabilité interne

 

Enums & patterns

  • enums : Rich data structures using
  • Generic enums
  • Patterns
    • Literals, variables, wildcards
    • Reference, Tuple & struct patterns
      Matching multiple, guards, @ patterns
  • Remplir : binary tree

 

Traits & Generics

  • Trait objects, layout
  • Drop, Sized, Clone, Copy
  • Deref & DerefMut, Default
  • AsRef & AsMut
  • Borrow & BorrowMut
  • From & Into
  • Borrow & ToOwned
  • Self in traits
  • Subtraits
  • Static methods
  • Associated types (or, how iterators)
  • Generic traits (or, how operator overloading)
  • Buddy traits (or, how rand::random())
  • Reverse-engineering bounds

 

Surcharge d’opérateurs

  • Operator overloading
  • Arithmetic and bitwise operators
  • Unary, Binary operators
  • Affectation : Compound assignment operators
  • Egalité : Equality tests
  • Ordered comparisons
  • Index & IndexMut
  • Autre opérateurs

 

Closures

  • Capturing variables
  • Closures : Borrow, steal, function & types
  • Performance
  • Sécurité
  • FnOnce & FnMut
  • Callbacks

 

Iterateurs

  • Iterator & IntoIterator traits
    • iter & iter_mut methods
    • drain methods
  • Adapters
    • Map & filter
    • filter_map & flat_map
    • scan
    • take & take_while, skip & skip_while
    • peekable, fuse
    • Reversible iterators and rev
    • inspect, chain, enumerate, zip
    • by_ref, cloned, cycle
  • Consuming iterators
    • Accumulation : count, sum, product
    • max, min, max_by, min_by
    • max_by_key, min_by_key
    • Comparaison : item sequences
    • any & all
    • position, rposition, & ExactSizeIterator
    • fold, nth, last, find
    • collect & FromIterator
    • Extend trait, Partition
  • Implémenter son propre itérateur

 

Collections

  • Vec<T>
  • Accessing elements
  • Iteration
  • Growing & shrinking vectors
  • Joining, Splitting, Swapping
  • Sorting & searching
  • Comparing slices
  • Random elements
  • Règles : Rust rules out invalidation errors
  • VecDeque<T>, LinkedList<T>, BinaryHeap<T>
  • HashMap<K, V> and BTreeMap<K, V>
  • Entries
  • Map iteration
  • HashSet<T> and BTreeSet<T>
  • Set iteration
  • Hashing & custom hashing algorithm

 

Strings & Text

  • ASCII, Latin-1, Unicode , UTF-8
  • Conversions : characters, integers, digits
  • String and str
  • Inspection
  • Appending, inserting, Removing text
  • Conventions for searching and iterating
  • Patterns : Searching & replacing
  • Iterating over text, Trimming
  • Case conversion for strings
  • Parsing other types from strings
  • Converting other types to strings
  • Borrowing as other text-like types
  • Strings as generic collections
  • Formatting values, text, numbers, custom…
  • Debugging
  • Regular expressions
  • Basic Regex use & lazily
  • Normalization forms, unicode-normalization crate

 

Input & output

  • Readers & Writers : Files, Directories, Seeking
  • Binary data, compression, serialization
  • OsStr & Path
  • Path & PathBuf methods
  • Filesystem access functions
  • Platform-specific features
  • Pile réseau : Networking

 

Concurrency

  • Fork-join parallelism, spawn & join, Error
  • Sharing immutable data, Rayon, Mandelbrot
  • Channels, Sending, Receiving values
  • Pipeline, Channel features & performance
  • Thread safety: Send and Sync
  • Iterator channel
  • Partager : Shared mutable state
  • Mutex in Rust : mut & Mutex
  • Deadlock, Poisoned mutexes
  • Multi-producer channels
  • Read-write locks (RwLock)
  • Condition variables (Condvar)
  • Atomics, Global variables

 

Macros

  • Expansion, Repetition, Debugging, Error
  • Utilisation : Json, Fragment types, Recursion, Traits with macros
  • Bonnes pratiques : Scoping
  • Import and export

 

Module complémentaire (+1 jour) : Approfondissement

 

Les bases de la programmation concurrente

  • Définition : Mandelbrot
  • Parsing pair : command-line arguments
  • Mapping pixels :  complex numbers
  • Tracer : Plotting the set
  • Ecriture d’un fichier image
  • Mandelbrot : Concurrent program
  • Exécuter : Mandelbrot plotter
  • Sécurité

 

Unsafe code

  • Unsafe blocks
  • Exemple : ASCII string type
  • Unsafe functions, traits, Raw pointers
  • Exemple: RefWithFlag
  • Nullable pointers
  • Type sizes & alignments
  • Pointer arithmetic
  • Moving into and out of memory
  • Exemple : GapBuffer
  • Interop : Foreign functions, calling function lib C & C++
  • Common data representations
  • Déclaration : foreign functions & variables
  • Raw interface libgit2, Safe interface libgit2

Langues et Lieux disponibles

Langues

  • Français
  • Anglais / English

Lieux

  • France entière
    • Paris
    • Lille
    • Reims
    • Lyon
    • Toulouse
    • Bordeaux
    • Montpellier
    • Nice
    • Sophia Antipolis
    • Marseille
    • Aix-en-Provence
    • Nantes
    • Rennes
    • Strasbourg
    • Grenoble
    • Dijon
    • Tours
    • Saint-Étienne
    • Toulon
    • Angers
  • Belgique
    • Bruxelles
    • Liège
  • Suisse
    • Genève
    • Zurich
    • Lausanne
  • Luxembourg

Nos Formateurs Référents

Laurent

Laurent

Je pratique Rust depuis quelques années dans un contexte industriel comme langage de programmation pour le backend d’applications web. Je contribue également à la communauté Rust par la publication de paquets open source. Pour moi, Rust fournit une expérience de développement système performante, moderne et surtout sûre.

Bastien

Bastien

Utilisateur depuis la bêta en 2015, depuis j’ai créé des projets personnels (sur GitHub) et après cela, j’ai fait un serveur web en Rust dans une start-up (backend avec gestion des templates). J’ai écrit un filesystem en Rust pour la plateforme Android pour la startup Moore.

Témoignages

Noté 4 sur 5
14 décembre 2022

Les – : Trop court pour aborder tous les points liés au Rust.

Clément M. de chez BODET TIME & SPORT

Afficher tous les témoignages

Noté 4 sur 5
14 décembre 2022

Les – : Trop court pour aborder tous les points liés au Rust.

Clément M. de chez BODET TIME & SPORT
Noté 3 sur 5
14 décembre 2022

Les + : Les compétences techniques du formateur, son expertise et sa disponibilité pour répondre aux questions.

Les – : J’ai trouvé la formation trop courte par rapport au volume du contenu. J’aurais souhaité avoir plus de temps pour appréhender certaines notions, et faire plus de TP.

En synthèse : La formation gagnerait à avoir un découpage théorie / TP mieux agencé. L’outil goto.com fonctionne très mal, nous avons dû subir plusieurs déconnexions intempestives du formateur ou des participants, ce qui casse le rythme du cours, c’est dommage.

Thomas C. de chez IMSA
Noté 4 sur 5
14 décembre 2022

Les + : Formateur très compétent, pédagogique et à l’écoute.

Les – : Formation trop courte => nécessiterait 4 voire 5 jours sans forcer.

Pas assez de pratique => beaucoup de choses à voir, et donc peu de TP.

Insister également sur les points forts du langage, pourquoi c’est l’avenir, ses points forts, pour ensuite nous donner des billes pour insister la hiérarchie et les autres devs à basculer vers ce langage.

Quentin A. de chez KELIO SAS
Noté 5 sur 5
14 décembre 2022

Brice G. de chez IMSA
Noté 4 sur 5
14 décembre 2022

Les – : Problème technique avec le système de visioconférence

Je souhaite suivre : Kotlin

En synthèse : Le cours n’a pas forcément été abordé dans le bon ordre par rapport au niveau de difficulté.

Frédéric G. de chez SFR
Noté 2 sur 5
14 décembre 2022

Les + : Formateur très (trop) compétant.

Les – : Inadaptée à un publique débutant. Je pense qu’il faudrait 70% de théorie et 30% de pratique. En exagérant, nous n’avons eu ni l’un ni l’autre. Michael nous à montré énormément de choses en programmant sous nos yeux dans une tentative d’apprentissage par l’exemple. Cela n’a pas fonctionné pour moi. J’aurai eu besoin d’une première couche explicative de toutes les notions propres au rust (traits, timeline, closure…) avant de lire des lignes de code. D’autre part, le temps prévu (3 jours) est beaucoup trop faible en regard du nombre de choses prévu dans ce cours.

En synthèse : NB : Je serai susceptible de recommander cette formation à des personnes ayant déjà une bonne pratique de RUST, et qui souhaiteraient approfondir ou clarifier certains sujets. Ou voir, en pratique, comment un professionnel propose de résoudre certaines difficultés concrètes ou limitations du langage. Mais vraiment, la durée, le contenu, (en fait tout) est à revoir pour une initiation destinée à des débutants complets en RUST.

Stéphane D. de chez NIIT (Ireland) Limited - France Branch
Noté 4 sur 5
12 octobre 2022

Les points forts : Adaptabilité du formateur. Formation axée sur les points clés du langage.

Les points faibles :

Manque un peu de structure et de rodage pour gagner en efficacité.

L’outil de viso www.gotomeet.me est peu pratique. Il y a mieux (Teams, …).

Il y a des outils permettant de faire du live sharing sur des IDE (VSCode, …) qui permettent de suivre en parallèle ou de voir ce que l’apprenant fait. C’est plus pratique que le partage d’écran.

Manque 1 journée. 3 jours, c’est trop court.

Bertrand P. de chez La Poste DSI BSCC
Noté 5 sur 5
12 octobre 2022

Je recommande la formation Rust

Les – : En distanciel, la latence en visioconférence (communications parfois non-fluide, micro-interruptions dans la prise de parole entre formateur et participants), rend les interactions parfois un peu pénibles. Ce point devrait pourtant être une commodité ; tout devrait être fluide pour faire passer des notions et des concepts complexes. Les formations en présentiel devraient être privilégiées.

Jean-Marie D. de chez MODIS FRANCE
Noté 4 sur 5
6 juillet 2022

Le nombre de personnes réduit à permis d’avoir un retour rapide et efficace sur notre problème.

L’hétérogénéité du public ne serait pas possible avec le format proposé par le formateur (slides)

Je tiens a souligner que ma satisfaction est lié au nombre réduit de participant.

Rémi G. de chez SFR
Noté 4 sur 5
6 juillet 2022

les qualités du formateur

la durée, le temps laissé à la pratique au début qui ne permet de démarrer progressivement

François B. de chez EDF Direction Commerce DSIN La Défense Ouest
Noté 4 sur 5
9 juin 2022

La pratique

ça va un peu trop loin dans les détails

Il f

Eline T. de chez TUFFIGO RAPIDEX
Noté 4 sur 5
9 juin 2022

Cours interactif, solutions accessibles facilement pour ne pas perdre le train en route.

code en ligne (sans complétion automatique et aide en ligne des fonctions). Dur pour un débutant, on se sent jeté dans la cage aux lions.

Revoir peut être l’ordre des cours. Il y a beaucoup de fois ou on avait besoin d’éléments dans des exercices vu plus tard.

Le rust est un langage très difficile a appréhender. Mais mon objectif premier n’était pas d’apprendre le rust, mais plutot de voir les possibilité que peut donner le rust, en comparaison avec d’autres langages. Pour le coup, le cours de 3 jours me va très bien. Par contre je pense que quelqu’un qui voudrait apprendre a utiliser le langage. 3 jours de formation de cette cadence,

Arnaud G. de chez TUFFIGO RAPIDEX
Noté 4 sur 5
9 juin 2022

Avoir la possibilité de consulter les solutions aux exercices car cela évite de saisir les corrections au fur et à mesure des explications du formateur.

Plutôt complexe pour un débutant mais cela permet d’avoir un bon aperçu.

Norbert . de chez TUFFIGO RAPIDEX
Noté 3 sur 5
9 juin 2022

– Découverte des nombreuses possibilités du langage

– concepts amenés dans le désordre :

* commencer par créer le projet sous VS afin d’avoir un IDE pendant la formation

* amener les fermetures plus tôt afin de comprendre

* utiliser des exemples ezrt des exercices beaucoup plus simples que des algorithmes de géométrie déjà complexes par nature

Cette formation demandait de grandes connaissances en programmation ainsi qu’une agilité cérébrale afin d’acquérir rapidement beaucoup de nouveaux concepts. Peut-être revoir soit la durée, soit la difficulté de la formation.

En tout cas, le langage offre des perspectives intéressantes.

Patrick R. de chez TUFFIGO RAPIDEX
Noté 4 sur 5
9 juin 2022

Bon aperçu des possibilités du langage, de sa mise en oeuvre et de sa complexité.

Non adapté à un niveau débutant.

Adrien H. de chez TUFFIGO RAPIDEX
Noté 4 sur 5
21 avril 2022

Nombreux exercices pratiques, Formateur très disponible et compétent.

Rust plus avancé

Lucas S. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

Semble assez complet (pour découvrir RUST)

Assez intense, parfois difficile à suivre (en fin de journée, quand on commence à montrer des signes de fatigues)

Kyohei O. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

ratio théorie/pratique

usage de jupyter très adapaté

Sébastien B. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

Une très bonne introduction, qui donne une ouverture générale tout en insistant sur des fondamentaux.

Rust est vaste, trop pour une formation de 3 jours.

Philippe M. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

La pratique bien équilibrée avec les aspects théoriques

Pierre L. de chez SOFTBANK ROBOTICS EUROPE
Noté 4 sur 5
21 avril 2022

Les travaux pratiques sont bien faits et pédagogiques.

Le début peut être un peu rapide et déstabilisant pour des débutants peut être.

RAS

Vincent P. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

Je recommande la formation

Kenzo F. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

Je recommande la formation

Grégory V. de chez SOFTBANK ROBOTICS EUROPE
Noté 4 sur 5
21 avril 2022

Je recommande la formation

Tony R. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
21 avril 2022

Riche en informations avec beaucoup d’exercices pratiques

Justine L. de chez SOFTBANK ROBOTICS EUROPE
Noté 5 sur 5
14 avril 2022

La parfaite connaissance du langage par le formateur a permis de bien approfondir les différents concepts abordés, ce qui est un challenge étant donnée la complexité du langage étudié.

Une journée de plus aurait permis de couvrir tous les modules prévus au départ de la formation.

Joël E. de chez Leroy-Automation
Noté 4 sur 5
14 avril 2022

Compétences du formateur + contenu jouable -> alternance théorie/pratique (jupyter)

La durée, beaucoup de notions nouvelles à appréhender

Ne sais pas

Brian D. de chez Leroy-Automation
Noté 5 sur 5
14 avril 2022

Mix entre théorie et pratique

Un peu court pour aborder tous les thèmes

Nicolas C. de chez Leroy-Automation
Noté 5 sur 5
14 avril 2022

Adaptation a nos besoin

Très dense, épuisant intellectuellement.

Georges P. de chez Leroy-Automation
Noté 4 sur 5
14 avril 2022

Je recommande la formation

Thomas N. de chez Leroy-Automation
Noté 4 sur 5
14 avril 2022

Bien pour débuter dans rust avec ses mécanismes

Un peu rapide. Points parfois très techniques car API rust grande

William C. de chez Leroy-Automation
Noté 5 sur 5
14 avril 2022

Formateur très compétent

Jérémy R. de chez Leroy-Automation
Noté 5 sur 5
30 mars 2022

Support cours/exercices Jupyter très ratique

Le formateur

Aucune idéee

Alexandre D. de chez Inetum
Noté 5 sur 5
30 mars 2022

On va droit à l’essentiel, pas de digressions inutiles, on démarre à l’heure. Beaucoup de travaux pratiques. Formateur compétent et pédagogique.

Benjamin L. de chez Inetum
Noté 4 sur 5
30 mars 2022

Très complet, adapté aux débutants en rust

Un peu rapide

SALMON L. de chez IT LINK FRANCE
Noté 4 sur 5
15 décembre 2021

Qualité des supports et de l’animateur

Un peu trop rapide à mon gout.

1 jour ou 2 de plus avec le même contenu n’auraient pas été de trop.

Loic D. de chez MBDA France
Noté 5 sur 5
15 décembre 2021

Compétence de l’intervenant.

François C. de chez EVOLIS
Noté 5 sur 5
2 juin 2021

Le formateur !

Certains exemples sont un peu trop simples, d’autres un peu trop complexes…

Plutôt « bas-niveau », j’aurai aimé voir un peu de client/server REST par exemple.

Rust/Golang

Merci beaucoup Laurent !

Sébastien B. de chez SQLI
Noté 4 sur 5
2 juin 2021

présentations claires, utilisation intéressante des notebooks. bonne interactivité.

Pas le programme prévu, couverture moins avancée des sujets que celle attendue.

Même si le programme n’est pas celui qui était prévu, cela reste une bonne introduction a rust. une formation avancée aurait peut-être plus correspondu a mes attentes.

Pascal B. de chez CGG SERVICES SAS
Noté 5 sur 5
2 juin 2021

Compétence du formateur

Contenu

Interactivité

Aborder certains points plus tôt rapidement (par exemple crate, on peut le comprendre assez vite)

Excellente formation

Philippe D. de chez SFR
Noté 5 sur 5
2 juin 2021

Je recommande la formation

Nidhal L. de chez
Noté 3 sur 5
2 juin 2021

Bonne introduction au language. Les notebook sont pratiques

Les points étudiés ne correspondent pas au programme prévu (https://www.ambient-it.net/formation/formation-rust/).

Quand je regarde le programme prévu, la formation est beaucoup moins complète. Mais elle balaye bien pas mal d’aspects du langage.

Mais elle est moins avancée que ne laissait supposer le programme.

Olivier D. de chez CGG SERVICES SAS
Noté 4 sur 5
2 juin 2021

Formateur compétent et disponible

Outil Jupyter performant

Trop riche pour la durée

Franz G. de chez SFR
Noté 5 sur 5
24 mai 2021

Bonne formation.

Est ce que vous pouvez rajouter la partie async dans la formation ?

Nidhal

Noter la formation

Prix 2490€ HT / personne
Durée 4 jours (28 heures)

Paris | Classe Virtuelle

Il ne reste que quelques places
NewCafés et déjeuners offerts en interentreprises
Disponible en intra-entreprise pour former votre équipe
Je ne veux pas me déplacer ? Option classe virtuelle gratuite

UNE QUESTION ? UN PROJET ? UN AUDIT DE CODE / D'INFRASTRUCTURE ?

Pour vos besoins d’expertise que vous ne trouvez nulle part ailleurs, n’hésitez pas à nous contacter.

ILS SE SONT FORMÉS CHEZ NOUS

partenaire sncf
partenaire hp
partenaire allianz
partenaire sfr
partenaire engie
partenaire boursorama
partenaire invivo
partenaire orange
partenaire psa
partenaire bnp
partenaire sncf
partenaire hp
partenaire allianz
partenaire sfr
partenaire engie
partenaire boursorama
partenaire invivo
partenaire orange
partenaire psa
partenaire bnp