Questions d'entretien pour développeur Backend (Go) : Guide complet

Introduction

Go (Golang) est devenu un langage dominant pour la construction de systèmes backend évolutifs, de microservices et d'applications natives du cloud. Sa simplicité, son modèle de concurrence robuste et ses performances en font un choix de premier ordre pour les équipes d'ingénierie modernes.

Ce guide couvre les questions d'entretien essentielles pour les développeurs Backend spécialisés en Go. Nous explorons les concepts fondamentaux du langage, les modèles de concurrence, la gestion des erreurs et la conception de systèmes pour vous aider à réussir votre prochain entretien.

Concepts fondamentaux de Go

1. Qu'est-ce qui différencie Go des autres langages comme Java ou Python ?

Réponse : Go a été conçu par Google pour répondre aux défis du développement de logiciels à grande échelle. Les principales différences sont les suivantes :

• Simplicité : Go possède un petit ensemble de mots-clés et manque de fonctionnalités complexes comme l'héritage ou la surcharge de méthodes, privilégiant la lisibilité.
• Concurrence : Prise en charge native de la concurrence via les Goroutines et les Channels, ce qui facilite l'écriture de programmes concurrents évolutifs.
• Compilation : Go compile directement en code machine (binaires liés statiquement), offrant des vitesses de démarrage et d'exécution rapides sans machine virtuelle (JVM).
• Collecte des déchets : Collecte des déchets efficace optimisée pour une faible latence.

Rareté : Courant Difficulté : Facile

2. Expliquez la différence entre les Arrays et les Slices.

Réponse :

• Arrays : Séquences de taille fixe d'éléments du même type. La taille fait partie du type (par exemple, [5]int est différent de [10]int). Ce sont des types de valeur ; l'attribution d'un tableau à un autre copie tous les éléments.
• Slices : Vues dynamiques et flexibles d'un tableau sous-jacent. Ils se composent d'un pointeur vers le tableau, d'une longueur et d'une capacité. Les slices sont de type référence ; le passage d'un slice à une fonction permet de modifier les éléments sous-jacents sans copier toutes les données.

Rareté : Courant Difficulté : Facile

3. Comment fonctionnent les Interfaces en Go ? Qu'est-ce que l'implémentation implicite ?

Réponse : Les interfaces en Go sont des collections de signatures de méthodes.

• Implémentation implicite : Contrairement à Java ou C#, un type ne déclare pas explicitement qu'il implémente une interface (pas de mot-clé implements). Si un type définit toutes les méthodes déclarées dans une interface, il implémente automatiquement cette interface.
• Duck Typing : "Si ça marche comme un canard et que ça cancane comme un canard, c'est un canard." Cela découple la définition de l'implémentation, rendant le code plus flexible et plus facile à simuler pour les tests.

Rareté : Courant Difficulté : Moyen

4. Qu'est-ce que le mot-clé defer et comment fonctionne-t-il ?

Réponse : defer planifie un appel de fonction à exécuter immédiatement avant le retour de la fonction. Il est couramment utilisé pour le nettoyage des ressources, comme la fermeture de fichiers, le déverrouillage de mutex ou la fermeture de connexions de base de données.

• Ordre LIFO : Les appels différés sont exécutés dans l'ordre Last-In-First-Out (dernier entré, premier sorti).
• Évaluation des arguments : Les arguments des fonctions différées sont évalués lors de l'exécution de l'instruction defer, et non lors de l'exécution de l'appel.

Exemple :

func readFile(filename string) {
    f, err := os.Open(filename)
    if err != nil {
        return
    }
    defer f.Close() // Garantit que le fichier est fermé lorsque la fonction se termine
    // ... traiter le fichier
}

Rareté : Courant Difficulté : Facile

Concurrence

5. Expliquez les Goroutines et en quoi elles diffèrent des threads du système d'exploitation.

Réponse :

• Goroutines : Threads légers gérés par le runtime Go. Ils commencent avec une petite pile (par exemple, 2 Ko) qui grandit et rétrécit dynamiquement. Des milliers de goroutines peuvent s'exécuter sur un seul thread du système d'exploitation.
• Threads du système d'exploitation : Gérés par le noyau, ont des piles fixes de grande taille (par exemple, 1 Mo) et la commutation de contexte est coûteuse.
• Planification M:N : Le runtime Go multiplexe M goroutines sur N threads du système d'exploitation, gérant efficacement la planification dans l'espace utilisateur.

Rareté : Très courant Difficulté : Moyen

6. Que sont les Channels ? Mis en mémoire tampon ou non mis en mémoire tampon ?

Réponse : Les channels sont des conduits typés qui permettent aux goroutines de communiquer et de synchroniser l'exécution.

• Channels non mis en mémoire tampon : N'ont pas de capacité. Une opération d'envoi se bloque jusqu'à ce qu'un récepteur soit prêt, et vice versa. Ils fournissent une forte synchronisation.
• Channels mis en mémoire tampon : Ont une capacité. Une opération d'envoi ne se bloque que si la mémoire tampon est pleine. Une opération de réception ne se bloque que si la mémoire tampon est vide. Ils découplent dans une certaine mesure l'expéditeur et le récepteur.

Rareté : Courant Difficulté : Moyen

7. Comment gérez-vous les conditions de concurrence (Race Conditions) en Go ?

Réponse : Une condition de concurrence se produit lorsque plusieurs goroutines accèdent simultanément à une mémoire partagée, et qu'au moins un accès est une écriture.

• Détection : Utilisez le détecteur de concurrence intégré : go run -race ou go test -race.
• Prévention :
  • Channels : "Ne communiquez pas en partageant la mémoire ; partagez plutôt la mémoire en communiquant."
  • Package Sync : Utilisez sync.Mutex ou sync.RWMutex pour verrouiller les sections critiques.
  • Opérations atomiques : Utilisez sync/atomic pour les compteurs ou les drapeaux simples.

Rareté : Courant Difficulté : Difficile

8. À quoi sert l'instruction select ?

Réponse : L'instruction select permet à une goroutine d'attendre plusieurs opérations de communication. Elle se bloque jusqu'à ce que l'un de ses cas puisse s'exécuter, puis elle exécute ce cas. Si plusieurs sont prêts, elle en choisit un au hasard.

• Délais d'attente : Peuvent être implémentés à l'aide de time.After.
• Opérations non bloquantes : Un cas default rend la sélection non bloquante si aucun autre cas n'est prêt.

Exemple :

select {
case msg := <-ch1:
    fmt.Println("Reçu", msg)
case ch2 <- "hello":
    fmt.Println("Envoyé hello")
case <-time.After(1 * time.Second):
    fmt.Println("Délai d'attente")
}

Rareté : Moyen Difficulté : Moyen

Gestion des erreurs et robustesse

9. Comment fonctionne la gestion des erreurs en Go ?

Réponse : Go traite les erreurs comme des valeurs. Les fonctions renvoient un type error (généralement comme dernière valeur de retour) au lieu de lever des exceptions.

• Vérifier les erreurs : Les appelants doivent explicitement vérifier si l'erreur est nil.
• Erreurs personnalisées : Vous pouvez créer des types d'erreur personnalisés en implémentant l'interface error (qui a une seule méthode Error() string).
• Wrapping : Go 1.13 a introduit le wrapping d'erreur (fmt.Errorf("%w", err)) pour ajouter du contexte tout en préservant l'erreur d'origine pour l'inspection (à l'aide de errors.Is et errors.As).

Rareté : Courant Difficulté : Facile

10. Que sont Panic et Recover ? Quand devez-vous les utiliser ?

Réponse :

• Panic : Arrête le flux de contrôle ordinaire et commence à paniquer. C'est similaire à une exception, mais doit être réservé aux erreurs irrécupérables (par exemple, déréférencement de pointeur nul, index hors limites).
• Recover : Une fonction intégrée qui reprend le contrôle d'une goroutine en panique. Elle n'est utile qu'à l'intérieur d'une fonction defer.
• Utilisation : Généralement déconseillé pour le flux de contrôle normal. Utilisez des valeurs error pour les conditions d'erreur attendues. Panic/recover est principalement utilisé pour les situations vraiment exceptionnelles ou à l'intérieur de bibliothèques/frameworks pour empêcher un crash de faire tomber l'ensemble du serveur.

Rareté : Moyen Difficulté : Moyen

Conception de systèmes et Backend

11. Comment structureriez-vous une application web Go ?

Réponse : Bien que Go n'impose pas de structure, une norme courante est la "Standard Go Project Layout" :

• /cmd : Applications principales (points d'entrée).
• /pkg : Code de bibliothèque qui peut être utilisé par des applications externes.
• /internal : Code d'application et de bibliothèque privé (appliqué par le compilateur Go).
• /api : Spécifications OpenAPI/Swagger, définitions de protocoles.
• /configs : Fichiers de configuration.
• Architecture propre : Séparation des préoccupations en couches (Delivery/Handler, Usecase/Service, Repository/Data) pour rendre l'application testable et maintenable.

Rareté : Courant Difficulté : Moyen

12. Comment fonctionne le package context et pourquoi est-il important ?

Réponse : Le package context est essentiel pour gérer les valeurs à portée de requête, les signaux d'annulation et les délais sur les limites d'API et les goroutines.

• Annulation : Si un utilisateur annule une requête, le contexte est annulé et toutes les goroutines générées effectuant un travail pour cette requête doivent s'arrêter pour économiser des ressources.
• Délais d'attente : context.WithTimeout garantit que les requêtes de base de données ou les appels d'API externes ne restent pas bloqués indéfiniment.
• Valeurs : Peut transporter des données spécifiques à la requête comme l'ID utilisateur ou les jetons d'authentification (à utiliser avec parcimonie).

Rareté : Très courant Difficulté : Difficile

13. Qu'est-ce que l'injection de dépendances et comment se fait-elle en Go ?

Réponse : L'injection de dépendances (DI) est un modèle de conception où un objet reçoit d'autres objets dont il dépend.

• En Go : Généralement implémenté en passant les dépendances (comme une connexion de base de données ou un enregistreur) dans le constructeur d'une struct ou une fonction de fabrique, souvent via des interfaces.
• Avantages : Rend le code plus modulaire et testable (facile d'échanger une vraie base de données avec une simulation).
• Frameworks : Bien que la DI manuelle soit préférée pour la simplicité, des bibliothèques comme google/wire ou uber-go/dig existent pour les graphes complexes.

Rareté : Moyen Difficulté : Moyen

Base de données et outils

14. Comment gérez-vous JSON en Go ?

Réponse : Go utilise le package encoding/json.

• Balises Struct : Utilisez des balises comme `json:"field_name"` pour mapper les champs struct aux clés JSON.
• Marshal : Convertit une struct Go en une chaîne JSON (slice d'octets).
• Unmarshal : Analyse les données JSON en une struct Go.
• Streaming : json.Decoder et json.Encoder sont meilleurs pour les grandes charges utiles car ils traitent des flux de données.

Rareté : Courant Difficulté : Facile

15. Quels sont les outils Go courants que vous utilisez ?

Réponse :

• go mod : Gestion des dépendances.
• go fmt : Formate le code selon le style standard.
• go vet : Examine le code à la recherche de constructions suspectes.
• go test : Exécute les tests et les benchmarks.
• pprof : Outil de profilage pour analyser l'utilisation du CPU et de la mémoire.
• delve : Débogueur pour Go.

Rareté : Courant Difficulté : Facile

Sujets avancés et meilleures pratiques

16. Que sont les génériques en Go et quand devez-vous les utiliser ?

Réponse : Les génériques (introduits dans Go 1.18) vous permettent d'écrire des fonctions et des structures de données qui fonctionnent avec n'importe quel ensemble de types, plutôt qu'un type spécifique.

• Paramètres de type : Définis à l'aide de crochets []. par exemple, func Map[K comparable, V any](m map[K]V) ...
• Contraintes : Interfaces qui définissent l'ensemble des types autorisés (par exemple, any, comparable).
• Utilisation : Utilisez-les pour réduire la duplication de code pour les algorithmes qui s'appliquent à plusieurs types (comme le tri, le filtrage ou les structures de données comme les ensembles/arbres). Évitez la surutilisation ; si une interface suffit, utilisez-la.

Rareté : Courant Difficulté : Moyen

17. Expliquez les tests basés sur des tableaux (Table-Driven Tests) en Go.

Réponse : Les tests basés sur des tableaux sont un modèle préféré en Go où les cas de test sont définis comme une slice de structs (le "tableau"). Chaque struct contient les arguments d'entrée et la sortie attendue.

• Avantages :
  • Séparation claire de la logique de test et des données de test.
  • Facile d'ajouter de nouveaux cas de test (il suffit d'ajouter une ligne au tableau).
  • Messages d'échec clairs indiquant exactement quelle entrée a échoué.
• Exemple :

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 1, 2},
        {2, -2, 0},
    }
    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d): expected %d, got %d", tt.a, tt.b, tt.expected, result)
        }
    }
}

Rareté : Courant Difficulté : Facile

18. Qu'est-ce que le modèle Middleware dans les serveurs HTTP Go ?

Réponse : Un middleware est une fonction qui enveloppe un http.Handler pour effectuer une logique de prétraitement ou de post-traitement avant de passer le contrôle au gestionnaire suivant.

• Signature : func(next http.Handler) http.Handler
• Cas d'utilisation : Journalisation, Authentification, Récupération de panique, Limitation du débit, CORS.
• Chaînage : Les middlewares peuvent être chaînés ensemble (par exemple, Log(Auth(Handler))).

Exemple :

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Rareté : Très courant Difficulté : Moyen

19. Comment implémentez-vous l'arrêt progressif (Graceful Shutdown) dans un serveur Go ?

Réponse : L'arrêt progressif garantit qu'un serveur cesse d'accepter de nouvelles requêtes, mais termine le traitement des requêtes actives avant de quitter.

• Mécanisme :
  1. Écoutez les signaux du système d'exploitation (SIGINT, SIGTERM) à l'aide de os/signal.
  2. Créez un context.WithTimeout pour autoriser une fenêtre de nettoyage (par exemple, 5 à 10 secondes).
  3. Appelez server.Shutdown(ctx) sur le http.Server.
  4. Fermez les connexions DB et les autres ressources.
• Importance : Empêche la perte de données et les erreurs client lors des déploiements.

Rareté : Courant Difficulté : Difficile

20. Quand devez-vous utiliser sync.Map au lieu d'une map régulière avec un Mutex ?

Réponse : sync.Map est une implémentation de map thread-safe dans la bibliothèque standard.

• Cas d'utilisation :
  1. Contention de cache : Lorsque l'entrée pour une clé donnée n'est jamais écrite qu'une seule fois, mais lue plusieurs fois (par exemple, caches à chargement différé).
  2. Clés disjointes : Lorsque plusieurs goroutines lisent, écrivent et écrasent des entrées pour des ensembles de clés disjoints.
• Compromis : Pour les cas d'utilisation généraux (mises à jour fréquentes en lecture/écriture), une map régulière protégée par un sync.RWMutex est souvent plus rapide et offre une meilleure sécurité de type (car sync.Map utilise any).

Rareté : Rare Difficulté : Difficile