Développer en Go

Tout le monde se secoue ! 

J’ai commencé (mardi 14 janvier 2020 à 11h09) la rédaction d’un tutoriel au doux nom de « Développer des applications distribuées en Go » et j’ai pour objectif de proposer en validation un texte aux petits oignons. Je fais donc appel à votre bonté sans limites pour dénicher le moindre pépin, que ce soit à propos du fond ou de la forme. Vous pourrez consulter la bêta à votre guise à l’adresse suivante :

Merci !

Le but de ce tutoriel est très différent de ceux que j’ai l’habitude de croiser : à la fin de celui-ci, je souhaite que le lecteur ait un réel aperçu d’un métier, et pas seulement d’une activité (comme la programmation).

Pour cette raison, ce tutoriel fait des choix forts en termes de pré-requis, car il demande :

• De savoir programmer (dans n’importe quel langage impératif) : l’apprentissage du langage en lui-même se fera dans la première partie, un petit peu "sur le tas" puisque les chapitres s’articulent autour de programmes complets.
• De savoir se débrouiller sous Linux : parce qu’on va utiliser git et probablement aussi une technologie de conteneurisation (d’ailleurs j’envisage de parler de podman plutôt que Docker…), et plus globalement parce que tous les outils que l’on utilise sont disponibles en ligne de commande, donc scriptables.
• De savoir se débrouiller avec les docs en anglais.

En contrepartie, cela va me permettre de brosser un spectre beaucoup plus large de thèmes :

• La conteneurisation d’une application,
• La création d’architectures distribuées qui maximisent la disponibilité d’une application et lui permettent de passer à l’échelle,
• L’écriture de tests et de benchmarks,
• La gestion des logs et le monitoring d’une application (eh oui, même ça on n’en parle jamais d’habitude !),

Bref, le but est d’écrire un tutoriel dans lequel on ne passe pas le monde réel sous silence.

Le début est intéressant, j’ai juste 2 remarques :

1. Attention à tes phrases, y’en a quelques-unes où tu as tendance à te perdre (« Ce n’est pas un hasard si le langage Go, créé originellement chez Google et open-source depuis une dixaine d’années, se retrouve un petit peu partout dans ces trois révolutions, puisqu’il en partage l’ambition première : celle de réaliser des applications qui passent à l’échelle, tant techniquement (pour accomoder des charges de travail massives) qu’humainement (car celles-ci devront être maintenues par de nombreux développeurs, sur de nombreuses années). ») dans l’intro, par exemple.
2. Tu as parfois des incohérences entre ce que tu expliques et les prérequis. Par exemple, vus tes prérequis, tu n’as pas besoin de donner des lignes de commande pour « télécharger et décompresser un fichier dans un dossier ». D’autant plus que c’est probable que les utilisateurs vont utiliser leur méthode habituelle pour ça, et que la ligne de téléchargement de l’archive sera périmée dès la publication de la prochaine version.

Attention à tes phrases

Tu as tout à fait raison. En fait je me contente pour l’instant de taper les idées au fil de l’eau, mais le passage que tu cites est clairement pathologique. Ça manque de points !

Tu as parfois des incohérences entre ce que tu expliques et les prérequis.

C’est vrai pour ce début. Cela dit, j’ai choisi d’adopter un style dans lequel les propos sont illustrés par mes sessions en console, et je ne compte pas expliquer en détail ce que fait l’option -p de mkdir, par exemple. En ce qui concerne l’installation, je suppose que tu as raison. Je pourrais très bien virer ces quelques lignes et considérer que "téléchargez et dépaquetez cette archive où bon vous semble" est une explication siffisante.

Bonjour les agrumes !

La bêta a été mise à jour et décante sa pulpe à l’adresse suivante :

Merci d’avance pour vos commentaires.

Je viens de prendre en compte les deux remarques plus haut.

Par ailleurs, j’ai également inséré une énumération rapide des types scalaires de Go, de manière à ce que le lecteur ait le plus tôt possible en tête que ces types sont plus ou moins "les mêmes qu’en C, mais avec des noms plus logiques", et ait un second indice sur le support d’Unicode (je veux dire, en plus de l’emoji dans le "Hello World") en apprenant qu’il existe un type rune.

Le premier chapitre n’est pas encore complet. Notamment la partie où j’énumère les divers outils ne contient pour l’instant que les outils que j’ai mentionnés pour l’instant dans le reste du texte. Je compte bien sûr la compléter au fur et à mesure que je tomberai sur d’autres outils de ce style que je devrai évoquer.

Bonjour les agrumes !

La bêta a été mise à jour et décante sa pulpe à l’adresse suivante :

Merci d’avance pour vos commentaires.

Le second chapitre est maintenant terminé. Je suis en train de réfléchir à une idée de programme sympa à proposer pour le troisième.

Bonjour les agrumes !

La bêta a été mise à jour et décante sa pulpe à l’adresse suivante :

Merci d’avance pour vos commentaires.

Juste une toute petite update avec un "brouillon" (les programmes clés) pour le troisième chapitre.

À l’origine je pensais aborder les arrays, slices et maps dans le même chapitre, mais je pense qu’il y a suffisamment de choses à dire sur les arrays et les slices pour meubler un seul chapitre. Ça ne sert à rien d’aller trop vite : autant faire de plus petits chapitres.

Salut,

J’ai quelques remarques sur la forme qui peut selon moi être amélioré.

Je te conseille d’améliorer ton introduction, je pense que tu devrais juste présenter en quelques phrases les principes du language Go, le contenu du tutoriel et les prérequis afin que ce soit plus clair et tu devrais déplacer le reste dans ton premier chapitre.

Je pense également que certains détails de la partie "installation et configuration" peuvent être traité plus tard afin d’aller plus vite vers la pratique et de rendre plus attraillant le tuto. (Une longue long début sans pratique à tendance à lasser les gens).

Bon courage pour le suite !

Salut,

Je ne suis pas d’accord pour l’introduction. J’avoue que je suis un petit peu lassé par les tutoriels (et j’en ai croisé — et même validé — une palanquée ces dernières années), qui commencent comme ça :

• Titre: Apprenez à développer en [LANGAGE]
• Intro: Dans ce tutoriel on va développer en [LANGAGE], vous allez voir c’est génial et très bien pour les débutants
• Premier chapitre : Insérer ici tout un historique sur la création de [LANGAGE]
• Au bout de 15 chapitres et trois parties : on ne sait toujours pas dans quels contextes et domaines ce langage est vraiment utile.

Vu la cible du tutoriel, il me semble absolument vital que dès les premières lignes de l’intro, les gens sachent dans quel contexte ce langage est principalement utilisé, et Go vient du monde Cloud Native que je décris ici en 5 lignes sans le nommer spécifiquement, sauf qu’on peut pas s’attendre à ce que les gens comprennent ça si je dis en une seule phrase « go est très utilisé dans le cloud » : ça sonnerait comme du gros bullshit commercial et du name dropping. Si j’entamme un tutoriel qui va m’apprendre à utiliser un langage, je ne veux pas attendre 3 heures avant de déterminer où ce langage est utilisé, et s’il correspond à ce que je veux faire : c’est quelque chose que je veux savoir avant même de déterminer si je suis la cible du tutoriel.

Pour les infos du premier chapitre, ça peut s’envisager. Par exemple on peut imaginer déplacer la partie configurer son espace de travail pour la caler juste avant d’utiliser des dépendances externes ou d’écrire des programmes qui tiennent en plusieurs packages. Je verrai quand le contenu existera.

(Une longue long début sans pratique à tendance à lasser les gens).

Ça aussi, je préfère le déterminer en étudiant les statistiques de lecture du tuto lorsqu’une première fournée sera déjà publiée. Si j’observe réellement un drop de 10% entre le chapitre où on installe Go et le suivant, alors ça vaudra le coup d’y faire quelque chose, mais en attendant je préfère me concentrer sur le contenu. Comme disait Knuth : premature optimization is the root of all evil.

Bonjour les agrumes !

La bêta a été mise à jour et décante sa pulpe à l’adresse suivante :

Merci d’avance pour vos commentaires.

GROS CHANGEMENT DE CAP

Après avoir relu ce que j’avais écrit jusqu’à maintenant dans ce tutoriel, je me suis aperçu que celui-ci ne me plaisait pas du tout, et que sa seule valeur ajoutée, au final, serait d’être en français.

J’ai donc décidé de remettre l’ouvrage complètement à plat et de repartir sur une base, certes plus ambitieuse, mais aussi plus saine : ce tutoriel pourra s’adresser à des débutants

Pour l’instant j’envisage les parties suivantes:

Partie 1 : Les bases du langage

Comme n’importe quel tuto de programmation, on y verra les notions de variables, de types de données, de fonctions, de structures, d’interfaces… bref, toutes les constructions natives du langage

Partie 2 : Du programme au projet

Ici, on va apprendre à développer. Il s’agira donc d’apprendre à organiser son espace de travail, à utiliser git, à écrire des tests, à utiliser la bibliothèque standard ainsi que des packages tiers.

Partie 3 : Concurrence et applications distribuées

Ici on va apprendre à écrire des applications… concurrentes et distribuées, donc utiliser des goroutines, prendre de bons réflexes pour écrire des programmes concurrents et safe, mais aussi communiquer sur le réseau en utilisant plusieurs protocoles courants (donc pas seulement des sockets TCP… je compte par exemple parler de HTTP et de gRPC), et également à utiliser docker et docker-compose, qui sont incontournables dans ce cas.

Partie 4 : Notions avancées

Ici, on arrive aux fonctionnalités moins couramment utilisées du langage, comme la génération de code, ou encore l’écriture de code unsafe, ou l’interfaçage avec d’autres langages de programmation…

Bonjour les agrumes !

La bêta a été mise à jour et décante sa pulpe à l’adresse suivante :

Merci d’avance pour vos commentaires.

Les quatre premiers chapitres sont maintenant terminés et prets à accueillir vos critiques.

Souhaitons au passage la bienvenue à @pyoroalb dans l’équipe de rédaction du tutoriel.