Comment réussir un entretien Rust : les questions les plus fréquentes

Introduction : Pourquoi Rust est-il si exigeant lors des entretiens ?

Rust est un langage de programmation système réputé pour sa sécurité mémoire et ses hautes performances. Le compilateur Rust est strict, mais juste : il ne laissera pas passer une erreur de possession (ownership) ou une référence pendante (dangling reference). C'est pourquoi, lors des entretiens Rust, on demande rarement la syntaxe "par cœur". Au lieu de cela, les recruteurs testent une compréhension approfondie du modèle mémoire, de la gestion des ressources et du code idiomatique.

Dans cet article, nous allons décortiquer les 10 questions les plus fréquentes posées lors des entretiens pour les développeurs Rust Junior et Middle. Chaque question est accompagnée d'une explication et d'un exemple de code. Si vous préparez un entretien, cet article sera votre checklist.

1. Possession (Ownership) et emprunt (Borrowing)

C'est le fondement de Rust. Sans comprendre la possession, vous ne réussirez pas l'entretien. Le recruteur peut vous demander d'expliquer la différence entre String et &str ou pourquoi un code ne compile pas.

Question : Expliquez ce qu'est la possession et comment fonctionne le transfert de données dans les fonctions.

Réponse : En Rust, chaque valeur a exactement un propriétaire. Lorsqu'une variable sort de la portée, la valeur est supprimée (drop). Passer une valeur à une fonction signifie un déplacement (move) de la possession, si le type n'implémente pas le trait Copy.

fn main() {    let s1 = String::from("hello");    let s2 = s1; // s1 est déplacé dans s2    // println!("{}", s1); // Erreur ! s1 ne possède plus la chaîne    println!("{}", s2);}

Si vous voulez passer des données sans perdre la possession, utilisez des références (&) :

fn main() {    let s1 = String::from("hello");    let len = calculate_length(&s1); // emprunt    println!("La longueur de '{}' est {}.", s1, len);}

fn calculate_length(s: &String) -> usize {    s.len()}

Question : Qu'est-ce qu'un emprunt mutable et pourquoi ne peut-il y en avoir qu'un seul ?

Réponse : L'emprunt mutable (&mut) permet de modifier la valeur via une référence. Le compilateur garantit qu'il n'existe qu'une seule référence mutable dans la portée, afin d'empêcher les courses de données (data races).

fn main() {    let mut s = String::from("hello");    let r1 = &mut s;    // let r2 = &mut s; // Erreur ! Impossible d'avoir deux références mutables    r1.push_str(", world");    println!("{}", r1);}

2. Durées de vie (Lifetimes)

Les durées de vie sont ce qui effraie les débutants. Lors de l'entretien, on vous demandera d'expliquer à quoi servent les annotations 'a et comment le compilateur déduit les lifetimes.

Question : Quand faut-il indiquer explicitement les durées de vie ?

Réponse : Lorsqu'une fonction retourne une référence et que le compilateur ne peut pas déterminer seul combien de temps elle va vivre. L'exemple classique est une fonction qui retourne la chaîne la plus longue parmi deux :

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {    if x.len() > y.len() { x } else { y }}

fn main() {    let string1 = String::from("longue chaîne");    let result;    {        let string2 = String::from("courte");        result = longest(&string1, &string2);    }    // println!("{}", result); // Erreur ! string2 est supprimée, référence pendante}

L'annotation 'a signifie : "la durée de vie de la référence retournée est égale à la plus petite des durées de vie des références d'entrée".

Question : Qu'est-ce que l'élision (règles d'omission des lifetimes) ?

Réponse : Le compilateur insère automatiquement les lifetimes dans les cas simples. Si une fonction prend une référence et retourne une référence, la lifetime est déduite. S'il y a plusieurs références d'entrée, il faut l'indiquer explicitement.

3. Enum, Pattern Matching et Option/Result

Rust utilise activement les types algébriques