🕖 🦗 ⚒️ Passez par les yeux d'un programmeur Rust: premières impressions 🚶🏼 🎅🏿 🎥

En prévision du début du cours, "Golang Developer" a préparé une traduction de matériel intéressant. Quelle a été votre première impression de Go?

Au cours des dernières semaines, j'ai pu utiliser Go dans mon travail. J'ai d'abord utilisé Go sur un projet plus ou moins important et sérieux. Avant cela, j'ai beaucoup lu sur Go et pratiqué sur des exemples et des petits programmes tout en étudiant les capacités de Rust , mais la vraie programmation est une tout autre affaire.

J'ai pensé que vous pourriez être intéressé à entendre mes impressions. J'essaierai de ne pas rester coincé dans les comparaisons avec Rust, mais comme c'est ma langue principale, ils ne peuvent pas être évités. Je dois vous avertir à l'avance d'un fort parti pris envers Rust, mais je ferai de mon mieux pour être objectif.

Impressions générales

La programmation de Go est sympa. Les bibliothèques avaient tout ce dont j'avais besoin sans trop de défauts. L'apprentissage a également été une expérience agréable - c'est une langue bien pensée et pratique. Par exemple, si vous apprenez la syntaxe, vous verrez que de nombreux idiomes d'autres langues sont migrés vers Go. Une fois que vous maîtrisez la partie Go, vous pouvez facilement prédire ses capacités. Avec une certaine expérience dans d'autres langues, j'ai pu lire et comprendre le code Go sans aucune aide spéciale de Google.

J'ai noté beaucoup moins de frustration et beaucoup plus de productivité qu'en utilisant C / C ++, Java, Python, etc. Cependant, Go est toujours ressenti comme faisant partie de cette génération de langages. Il a appris d'eux, et je pense que c'est probablement la meilleure langue de cette génération; mais il fait définitivement partie de cette génération. Il représente une amélioration incrémentielle plutôt que quelque chose de fondamentalement nouveau (il convient de noter qu'il ne s'agit pas d'un jugement de valeur - l'incrémentation est souvent bénéfique dans le monde du développement logiciel). Un bon exemple est nul: des langages comme Rust et Swift se débarrassent du paradigme nul, éliminant ainsi toute une classe d'erreurs. Go le rend moins dangereux: pas de valeurs nulles; délimitation de nil et de 0. Mais l'idée de base est toujours présente, ainsi que l'erreur généralisée d'exécution de déréférencer un pointeur nul.

Facilité de développement

Go est incroyablement facile à apprendre. Je sais que c'est un slogan publicitaire propagé, mais j'ai été très surpris de la rapidité avec laquelle j'ai pu atteindre le niveau de productivité. Grâce à la documentation, aux outils et au langage lui-même, en seulement deux jours, j'ai commencé à écrire du code informatif et convivial.

Plusieurs facteurs en faveur de l'apprentissage:

Allez petit. De nombreuses langues essaient d'être petites, alors que Go en est une. (C'est surtout bon, et je suis impressionné par la discipline requise pour cela).
La bibliothèque standard est bonne (et également petite). Trouver et utiliser des bibliothèques dans un écosystème est très simple.
La langue a très peu qui n'est pas dans d'autres langues. Go hérite de nombreux bits d'autres langues établies, les peaufine et les connecte parfaitement. Il évite soigneusement la nouveauté.

Routine de code

Le code Go devient répétitif très rapidement. Il manque tout mécanisme tel que des macros ou des génériques pour réduire la répétition (les interfaces sont bonnes pour les abstractions, mais pas si bonnes pour réduire la duplication de code). J'accumule souvent un grand nombre de fonctions identiques à l'exception des types.

La gestion des erreurs contribue également à la répétition. De nombreuses fonctionnalités ont plus de modèles if err != nil { return err }que le code d'origine.

L'utilisation de génériques ou de macros pour réduire la routine du code est parfois critiquée pour le compromis avec sa lisibilité. Mais dans le cas de Go, je ne serais pas d'accord avec eux. Copier et coller du code est rapide et facile, mais la lecture du code Go peut être frustrante car vous devez en ignorer la plupart ou rechercher des différences subtiles.

Ce que j'ai aimé

. ; Rust. , ( , C/C ++ , - ).
. Go — . , , , .
. , , .
if ...; ... { }syntaxe. La capacité de limiter la portée des variables au corps des instructions if est bonne. Cela s'apparente à si laissé dans Swift et Rust, mais à un usage plus général (Go n'a pas de motif correspondant comme Swift et Rust, il ne peut donc pas être utilisé s'il est laissé).
Les commentaires de test et d'ancrage sont faciles à utiliser.
L'outil Go est agréable - tout à la fois en un seul endroit sans avoir à connecter de nombreux outils via la ligne de commande
En stock collecteur d'ordures (GC)! Pas besoin de se soucier de la gestion de la mémoire qui facilite vraiment la programmation
Varargs.

Ce que je n'ai pas aimé

L'ordre n'a pas d'importance.

tranches nulles - zéro, les tranches nulles et les tranches vides sont toutes différentes. Je suis plus que sûr que vous n'en avez besoin que de deux, pas des trois.
Pas de classes primaires. L'utilisation de constantes est inhabituelle.
. , ( , , , , ).
switch
for ... range /. ( ), . -, , .
:
- .
- ( , , ); , , .
- , return.
- (type struct).
- public private. , .
. , , , , , , , .
Vous ne pouvez pas écrire de fonctions avec un récepteur dans un autre package, par conséquent, même si les interfaces sont typées implicitement, elles ne peuvent pas être implémentées pour les types supérieurs, ce qui les rend beaucoup moins utiles.

J'ai déjà mentionné le manque de génériques et de macros ci-dessus.

La cohérence

En tant que développeur et programmeur de langage, j'ai probablement été très surpris par le fait que Go rencontre souvent un décalage entre ce qui est intégré et ce qui est disponible pour les utilisateurs. La tâche de nombreuses langues est de dissiper autant de magie que possible et de rendre les fonctions intégrées disponibles pour les utilisateurs. La surcharge des opérateurs est un exemple simple mais controversé. Allez a beaucoup de magie! Et vous tombez très facilement sur un mur d'incapacité à faire ce que les choses intégrées peuvent faire.

Quelques points qui ressortent particulièrement:

, , .
for ... range , , .
, len append, , . . , Go !
. ==, , map, . .

Go est une langue simple, compacte et agréable. Il a quelques coins pointus, mais il est surtout bien conçu. Il est incroyablement rapide à apprendre et évite toutes les fonctionnalités qui ne sont pas connues dans d'autres langues.

Par rapport à Rust, Go est une langue complètement différente. Bien que les deux puissent être grossièrement décrits comme des langages système ou des «remplacements» pour C, ils ont des objectifs et des applications, des styles de conception de langage et des priorités différents. La collecte des ordures est vraiment une grande différence. Avoir GC in Go rend le langage beaucoup plus simple et plus petit, et plus facile à comprendre. L'absence de GC dans Rust le rend très rapide (surtout si vous avez besoin d'un délai clair, et pas seulement d'une bande passante élevée) et fournit des fonctionnalités et des schémas de programmation qui sont impossibles dans Go (au moins sans sacrifier les performances).

Go est un langage compilé avec un runtime bien implémenté. Il est rapide. Rust est également compilé, mais a un temps d'exécution beaucoup plus petit. Il est très rapide. En supposant qu'il n'y a pas d'autres restrictions, je pense que choisir entre utiliser Go et Rust est un compromis entre une courbe d'apprentissage beaucoup plus courte et des programmes plus simples (ce qui signifie un développement plus rapide) et, de la part de Rust, un système plus rapide et plus expressif types (ce qui rend vos programmes plus sûrs et accélère le débogage et le dépannage).

La traduction a pris fin et nous vous invitons à une leçon pratique en ligne gratuite où vous apprendrez à créer un service http entièrement testé à partir de zéro en 60 minutes sans dépendances tierces.