Pourquoi tout réécrire dans Rust ne résoudra pas tous vos problèmes

Rust est l'équivalent dans le monde de la technologie du petit nouveau du quartier qui est doué en sport, obtient les meilleures notes et sait même jouer de la guitare. C’est sûr, rapide et promet de débarrasser votre base de code des fameux bugs de mémoire qui ont hanté vos cauchemars. Mais cela signifie-t-il que vous devriez réécrire tous vos projets dans Rust ? Pas tout à fait. ?

La réécriture dans Rust peut être intéressante dans certains scénarios, mais ce n'est pas un remède universel à tous vos problèmes de développement logiciel. Voyons pourquoi, avec quelques extraits de code, des analogies et, espérons-le, quelques rires en cours de route. ?

Les points forts de Rust : pourquoi ce battage médiatique ?

Avant de critiquer Rust, rendons-lui les éloges qui lui sont dus : ?

1. Sécurité de la mémoire : le vérificateur d'emprunt de Rust élimine des classes entières de bugs comme le déréférencement de pointeur nul et les courses de données. Incroyable! ✅

2. Performances : Rust s'exécute presque aussi vite que C ou C mais avec beaucoup moins de plantages. Si vous construisez des systèmes hautes performances, Rust est votre ami. ?

3. Outillage moderne : Avec Cargo, le gestionnaire de paquets et l'outil de build de Rust, la gestion des dépendances est un jeu d'enfant par rapport à certains autres langages (en vous regardant, JavaScript). ?

Le mantra de Rust est la sécurité, la vitesse et la stabilité. Qui ne voudrait pas de cela ? Voyons maintenant pourquoi cela ne signifie pas que vous devriez prendre un marteau et démolir votre base de code actuelle. ?️

1. Le « sophisme de réécriture »

Imaginez que vous possédez un bateau qui fuit légèrement. Au lieu de le réparer, vous décidez d’en créer un entièrement nouveau à partir de zéro. Bien sûr, le nouveau bateau est peut-être plus robuste, mais le processus prendra des mois, coûtera une fortune et il est possible qu’il ne flotte pas du tout. ⛵

La réécriture du code est similaire. Le billet de blog classique de Joel Spolsky "Les choses que vous ne devriez jamais faire" met en garde contre le fait de jeter du code fonctionnel. Pourquoi? Parce que la réécriture introduit des bugs, gaspille des années de connaissances en débogage et ralentit la progression. La réécriture dans Rust amplifie ces risques car la courbe d’apprentissage de Rust est abrupte.

Exemple : refactoring ou réécriture

Disons que vous avez cette fonction Python :

# Python: Calculate factorial

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Simple, non ? Mais vous voulez la vitesse et la sécurité de Rust. Voici à quoi cela pourrait ressembler :

// Rust: Calculate factorial

fn factorial(n: u64) -> u64 {
    match n {
        0 => 1,
        _ => n * factorial(n - 1),
    }
}

Cool, mais la réécriture en valait-elle la peine ? Pour un petit extrait comme celui-ci, probablement pas. Le code Python fonctionne bien et est plus facile à lire et à maintenir pour les nouveaux développeurs. Si les performances deviennent un problème, vous auriez pu optimiser uniquement cette fonction spécifique avec une bibliothèque Rust en utilisant des outils comme PyO3, au lieu de tout réécrire.

2. Courbe d'apprentissage : tout le monde ne parle pas le rustacé

La syntaxe de Rust peut sembler étrangère aux développeurs habitués aux langages plus traditionnels. Des concepts tels que l’emprunt, la durée de vie et la propriété sont puissants mais aussi intimidants. Si votre équipe n'est pas déjà familiarisée avec Rust, attendez-vous à des retards et à de la confusion.

Une histoire de malheurs d’emprunt

Considérez cette tâche simple : modifier un vecteur dans Rust.

# Python: Calculate factorial

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Ça a l'air bien, mais si vous oubliez d'utiliser &mut ou de déréférencer avec *, le vérificateur d'emprunt vous grondera. Les développeurs venant, par exemple, de JavaScript ou de Python peuvent avoir l'impression d'être bizutés.

En attendant, voici l'équivalent en Python :

// Rust: Calculate factorial

fn factorial(n: u64) -> u64 {
    match n {
        0 => 1,
        _ => n * factorial(n - 1),
    }
}

Beaucoup plus simple, non ? Rust vous oblige à travailler plus dur dès le départ pour garantir la sécurité, ce qui est fantastique pour la programmation système mais excessif pour les projets plus petits et moins sujets aux erreurs.

3. Tous les codes n'ont pas besoin des fonctionnalités de Rust

Réécrire votre application de liste de tâches personnelle dans Rust parce que "Rust is cool", c'est comme construire un nichoir avec des poutres en acier de qualité industrielle. La sur-ingénierie n’aide personne.

Quand la rouille est excessive

Disons que vous écrivez un script pour renommer certains fichiers :

Python:

fn main() {
    let mut numbers = vec![1, 2, 3];

    for num in &mut numbers {
        *num += 1;
    }

    println!("{:?}", numbers);
}

Rouiller:

numbers = [1, 2, 3]

for i in range(len(numbers)):
    numbers[i] += 1

print(numbers)

La solution de Rust est plus robuste, mais si votre script ne s'exécute qu'une seule fois, la complexité supplémentaire en vaut-elle la peine ? Pour des tâches rapides et ponctuelles, les langages de script de haut niveau comme Python constituent souvent un meilleur choix. ?

4. Productivité des développeurs : le compromis

Rust vous fait écrire plus de code pour obtenir le même résultat que les autres langages. Ce compromis en vaut la peine pour les systèmes critiques en matière de sécurité, mais vous ralentit dans les environnements où la vitesse de développement compte plus que les performances d'exécution.

Vitesse de démarrage et évolutivité

Si vous créez un MVP ou faites du prototypage, utilisez un langage qui vous permet d'itérer rapidement. Une fois que vous avez validé votre idée et que vous devez évoluer, vous pouvez envisager de réécrire les parties critiques en termes de performances dans Rust. ?

5. L'erreur de « l'outil parfait »

Aucune langue n’est parfaite. La rouille brille pour :

• Programmation de systèmes (par exemple, systèmes d'exploitation, moteurs de jeu).
• Applications critiques en termes de performances.
• Programmes multithread où la sécurité compte.

Mais c’est moins idéal pour :

• Prototypage rapide.
• Scripts et automatisation.
• Équipes avec une expérience Rust limitée.

Conclusion : utilisez Rust, mais utilisez-le à bon escient

Rust est un langage phénoménal doté de fonctionnalités révolutionnaires. Cela mérite tout le battage médiatique, mais son adoption nécessite également beaucoup de temps et d’efforts. Réécrire vos projets dans Rust n’est peut-être pas la solution miracle que vous recherchez.

Considérez plutôt Rust là où cela a du sens : goulots d'étranglement critiques en matière de performances, API sécurisées en mémoire ou projets à long terme où la stabilité est primordiale. Pour tout le reste, tenez-vous-en à ce qui fonctionne. N'oubliez pas que le meilleur outil est celui qui fait le travail, même s'il s'agit d'un bateau qui fuit et qui est réparé avec du ruban adhésif.

Alors, ne jetez pas encore votre base de code Python, JavaScript ou Go à la poubelle. Rust est peut-être le héros dont vous avez besoin, mais pas pour toutes les batailles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!