Questions d'entretien pour développeur Full Stack Senior : Guide complet

Introduction

Le développement full stack est devenu une discipline complète qui exige une expertise en frontend, backend, bases de données et infrastructure. On attend des développeurs full stack seniors qu'ils conçoivent des systèmes évolutifs, qu'ils prennent des décisions technologiques éclairées et qu'ils comblent le fossé entre les différentes couches des applications modernes.

Ce guide couvre les questions d'entretien essentielles pour les développeurs Full Stack Seniors, allant des frameworks frontend à l'architecture backend, en passant par la conception de systèmes, les bases de données et les pratiques DevOps. Chaque question comprend des réponses détaillées, une évaluation de la rareté et des niveaux de difficulté pour vous aider à vous préparer efficacement.

Développement Frontend (6 Questions)

1. Expliquez le DOM virtuel de React et l'algorithme de réconciliation.

Réponse : Le DOM virtuel est une représentation JavaScript légère du DOM réel. React l'utilise pour optimiser les mises à jour.

• Processus : Lorsque l'état change, React crée un nouvel arbre DOM virtuel et le compare avec le précédent (différenciation).
• Réconciliation : L'algorithme de React identifie l'ensemble minimal de changements nécessaires et met à jour uniquement ces parties du DOM réel.
• Optimisation clé : L'utilisation de la propriété key aide React à identifier les éléments qui ont changé, ont été ajoutés ou supprimés dans les listes, ce qui rend la réconciliation plus efficace.
• Architecture Fiber : React moderne utilise Fiber, ce qui permet de diviser le travail de rendu en morceaux et de hiérarchiser les mises à jour.

Rareté : Très courant Difficulté : Moyenne

2. Que sont les Hooks React et pourquoi ont-ils été introduits ?

Réponse : Les Hooks sont des fonctions qui vous permettent d'utiliser l'état et d'autres fonctionnalités de React dans des composants fonctionnels.

• Motivation : Avant les Hooks, la logique avec état nécessitait des composants de classe. Les Hooks permettent de réutiliser la logique avec état sans modifier la hiérarchie des composants.
• Hooks courants :
  • useState : Gère l'état local
  • useEffect : Gère les effets secondaires (extraction de données, abonnements)
  • useContext : Accède aux valeurs de contexte
  • useMemo/useCallback : Optimisation des performances
• Hooks personnalisés : Vous pouvez créer des hooks personnalisés pour extraire et réutiliser la logique des composants.

Rareté : Très courant Difficulté : Facile

3. Comment optimiser les performances d'une application React ?

Réponse : Plusieurs stratégies peuvent améliorer les performances de React :

1. Code Splitting : Utilisez React.lazy() et Suspense pour charger les composants à la demande.
2. Mémoïsation : Utilisez React.memo() pour les composants, useMemo() pour les calculs coûteux, useCallback() pour les références de fonctions.
3. Listes virtuelles : Pour les longues listes, utilisez des bibliothèques comme react-window ou react-virtualized.
4. Évitez les fonctions en ligne : Dans les méthodes de rendu, car elles créent de nouvelles références à chaque rendu.
5. Profiler : Utilisez React DevTools Profiler pour identifier les goulots d'étranglement.
6. Gestion de l'état : Gardez l'état aussi local que possible, utilisez le contexte avec sagesse.

Rareté : Courant Difficulté : Moyenne

4. Expliquez la différence entre le rendu côté serveur (SSR) et le rendu côté client (CSR).

Réponse :

• CSR : JavaScript s'exécute dans le navigateur pour rendre la page. Le HTML initial est minimal. Navigation ultérieure rapide, mais chargement initial plus lent et mauvais référencement.
• SSR : Le serveur génère du HTML complet pour chaque requête. Meilleur référencement et premier affichage plus rapide, mais navigation ultérieure plus lente et charge serveur plus élevée.
• Approches hybrides :
  • Génération de site statique (SSG) : Pré-rendu des pages au moment de la construction (Next.js, Gatsby).
  • Régénération statique incrémentale (ISR) : Mise à jour des pages statiques après le déploiement sans reconstruction complète.

Rareté : Courant Difficulté : Moyenne

5. Quelle est la différence entre localStorage, sessionStorage et les Cookies ?

Réponse :

• localStorage : Conserve les données sans expiration. Limite d'environ 5 à 10 Mo. N'est pas envoyé au serveur automatiquement.
• sessionStorage : Identique à localStorage, mais effacé lorsque l'onglet/navigateur se ferme.
• Cookies : Petites données (environ 4 Ko) envoyées avec chaque requête HTTP. Peut définir une expiration. Utilisé pour les jetons d'authentification.
• Sécurité : Les cookies peuvent être HttpOnly (non accessibles via JS) et Secure (HTTPS uniquement). Utilisez-les pour les données sensibles.

Rareté : Courant Difficulté : Facile

6. Comment fonctionne CSS-in-JS et quels sont ses compromis ?

Réponse : Les bibliothèques CSS-in-JS (styled-components, Emotion) permettent d'écrire du CSS directement en JavaScript.

• Avantages :
  • Styles délimités (pas de pollution de l'espace de noms global)
  • Style dynamique basé sur les propriétés
  • Préfixage automatique des fournisseurs
  • Élimination du code mort
• Compromis :
  • Surcharge d'exécution (styles générés au moment de l'exécution)
  • Taille de bundle plus importante
  • Courbe d'apprentissage
• Alternatives : CSS Modules, Tailwind CSS, CSS traditionnel avec la méthodologie BEM.

Rareté : Moyenne Difficulté : Moyenne

Développement Backend (6 Questions)

7. Expliquez la boucle d'événements dans Node.js.

Réponse : Node.js est monothread, mais gère la concurrence grâce à la boucle d'événements.

• Phases :
  1. Timers : Exécute les rappels setTimeout et setInterval
  2. Rappels en attente : Rappels d'E/S différés à l'itération suivante
  3. Poll : Récupère de nouveaux événements d'E/S, exécute les rappels d'E/S
  4. Check : Rappels setImmediate
  5. Rappels de fermeture : Événements de fermeture de socket
• E/S non bloquantes : Lorsque des opérations d'E/S sont lancées, Node.js les délègue au noyau du système et continue d'exécuter d'autres codes.

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');
// Output: 1, 4, 3, 2

Rareté : Très courant Difficulté : Difficile

8. Qu'est-ce qu'un Middleware dans Express.js ?

Réponse : Les fonctions de middleware ont accès à la requête, à la réponse et à la fonction middleware suivante dans le cycle requête-réponse de l'application.

• Types :
  • Niveau application : app.use()
  • Niveau routeur : router.use()
  • Gestion des erreurs : A 4 paramètres (err, req, res, next)
  • Intégré : express.json(), express.static()
  • Tiers : cors, helmet, morgan
• L'ordre est important : Le middleware s'exécute dans l'ordre où il est défini.

app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

Rareté : Très courant Difficulté : Facile

9. Comment gérez-vous l'authentification dans une API REST ?

Réponse : Plusieurs approches existent :

• JWT (Sans état) :
  • Le serveur génère un jeton signé contenant les informations de l'utilisateur
  • Le client stocke le jeton (localStorage/cookie) et l'envoie avec chaque requête
  • Le serveur vérifie la signature
  • Avantages : Évolutif, pas de stockage de session côté serveur
  • Inconvénients : Difficile à révoquer, charge utile plus importante
• Basé sur une session (Avec état) :
  • Le serveur crée une session, la stocke dans DB/Redis
  • Le client reçoit l'ID de session dans un cookie
  • Avantages : Facile à révoquer
  • Inconvénients : Nécessite un stockage côté serveur
• OAuth 2.0 : Pour l'authentification tierce
• Bonne pratique : Utilisez des jetons de rafraîchissement pour un accès à long terme, des jetons d'accès à court terme.

Rareté : Très courant Difficulté : Moyenne

10. Expliquez les transactions de base de données et les propriétés ACID.

Réponse : Une transaction est une séquence d'opérations effectuées comme une seule unité de travail logique.

• ACID :
  • Atomicité : Toutes les opérations réussissent ou toutes échouent (tout ou rien)
  • Cohérence : La base de données passe d'un état valide à un autre
  • Isolation : Les transactions simultanées n'interfèrent pas entre elles
  • Durabilité : Les transactions validées persistent même après une panne du système
• Niveaux d'isolation : Lecture non validée, Lecture validée, Lecture répétable, Sérialisable (compromis entre cohérence et performance).

Rareté : Courant Difficulté : Moyenne

11. Quelle est la différence entre les bases de données SQL et NoSQL ?

Réponse :

• SQL (Relationnel) :
  • Schéma structuré, tables avec lignes/colonnes
  • Conforme à ACID
  • Mise à l'échelle verticale (serveur plus grand)
  • Exemples : PostgreSQL, MySQL
  • Cas d'utilisation : Requêtes complexes, transactions, données structurées
• NoSQL :
  • Schéma flexible, document/clé-valeur/graphe/famille de colonnes
  • BASE (Cohérence éventuelle)
  • Mise à l'échelle horizontale (plus de serveurs)
  • Exemples : MongoDB, Redis, Cassandra
  • Cas d'utilisation : Développement rapide, échelle massive, données non structurées

Rareté : Courant Difficulté : Facile

12. Comment empêcher les attaques par injection SQL ?

Réponse : L'injection SQL se produit lorsque l'entrée de l'utilisateur est directement concaténée dans les requêtes SQL.

• Prévention :
  1. Requêtes paramétrées/Instructions préparées : Utilisez des espaces réservés pour l'entrée de l'utilisateur
  2. ORM : Les bibliothèques comme Sequelize, TypeORM gèrent l'échappement automatiquement
  3. Validation de l'entrée : Liste blanche des caractères autorisés
  4. Privilège minimal : L'utilisateur de la base de données doit avoir des autorisations minimales
  5. Procédures stockées : Peuvent fournir une couche supplémentaire

// Bad
const query = `SELECT * FROM users WHERE id = ${userId}`;

// Good
const query = 'SELECT * FROM users WHERE id = ?';
db.execute(query, [userId]);

Rareté : Très courant Difficulté : Facile

Conception de systèmes et architecture (6 Questions)

13. Comment concevriez-vous un système de notification évolutif ?

Réponse : Un système de notification doit gérer plusieurs canaux (e-mail, SMS, push) à grande échelle.

• Composants :
  • Service API : Reçoit les demandes de notification
  • File d'attente de messages : RabbitMQ/Kafka pour le traitement asynchrone
  • Workers : Services distincts pour chaque canal
  • Base de données : Stocker l'historique des notifications, les préférences de l'utilisateur
  • Limitation du débit : Empêcher le spam
• Considérations :
  • Logique de nouvelle tentative en cas d'échec
  • Files d'attente prioritaires pour les notifications urgentes
  • Gestion des modèles
  • Préférences de l'utilisateur (désinscription)

Rareté : Courant Difficulté : Difficile

14. Expliquez l'architecture des microservices et ses défis.

Réponse : Les microservices décomposent une application en petits services indépendants.

• Avantages :
  • Déploiement et mise à l'échelle indépendants
  • Diversité technologique
  • Isolation des défauts
  • Autonomie de l'équipe
• Défis :
  • Transactions distribuées : Difficile de maintenir la cohérence entre les services
  • Latence du réseau : Surcharge de la communication inter-services
  • Surveillance : Nécessite un traçage distribué (Jaeger, Zipkin)
  • Gestion des données : Chaque service possède sa base de données
  • Tests : Les tests d'intégration sont complexes
• Modèles : Passerelle API, Service Mesh, Coupe-circuit, Modèle Saga pour les transactions.

Rareté : Très courant Difficulté : Difficile

15. Qu'est-ce que la mise en cache et quelles sont les stratégies de mise en cache courantes ?

Réponse : La mise en cache stocke les données fréquemment consultées dans un stockage rapide pour réduire la latence.

• Couches :
  • Cache du navigateur
  • CDN (CloudFlare, Akamai)
  • Cache de l'application (Redis, Memcached)
  • Cache de la requête de base de données
• Stratégies :
  • Cache-Aside : L'application vérifie d'abord le cache, charge à partir de la base de données en cas d'échec
  • Write-Through : Écrit simultanément dans le cache et la base de données
  • Write-Behind : Écrit dans le cache, écriture asynchrone dans la base de données
  • Read-Through : Le cache charge automatiquement les données à partir de la base de données
• Politiques d'éviction : LRU (Least Recently Used), LFU (Least Frequently Used), TTL (Time To Live).

Rareté : Très courant Difficulté : Moyenne

16. Comment assurez-vous la gestion des versions de l'API ?

Réponse : La gestion des versions de l'API permet la compatibilité descendante lors des modifications.

• Stratégies :
  • Gestion des versions URI : /api/v1/users, /api/v2/users
  • Gestion des versions d'en-tête : Accept: application/vnd.api.v1+json
  • Paramètre de requête : /api/users?version=1
• Bonnes pratiques :
  • Avertissements de dépréciation
  • Maintenir au moins 2 versions
  • Guides de migration clairs
  • Gestion sémantique des versions
• Alternative GraphQL : Évolution du schéma sans gestion des versions (champs obsolètes).

Rareté : Courant Difficulté : Moyenne

17. Expliquez le théorème CAP.

Réponse : Dans les systèmes distribués, vous ne pouvez garantir que 2 des 3 éléments suivants :

• Cohérence : Tous les nœuds voient les mêmes données en même temps
• Disponibilité : Chaque requête reçoit une réponse (succès/échec)
• Tolérance au partitionnement : Le système continue de fonctionner malgré les pannes de réseau
• Réalité : Les partitions de réseau se produiront, vous devez donc choisir entre CP (Cohérence) ou AP (Disponibilité).
• Exemples :
  • CP : MongoDB, HBase (sacrifient la disponibilité pendant le partitionnement)
  • AP : Cassandra, DynamoDB (cohérence éventuelle)

Rareté : Courant Difficulté : Difficile

18. Qu'est-ce que l'équilibrage de charge et quels algorithmes sont utilisés ?

Réponse : L'équilibrage de charge distribue le trafic sur plusieurs serveurs.

• Algorithmes :
  • Round Robin : Distribution séquentielle
  • Moins de connexions : Envoyer au serveur avec le moins de connexions actives
  • Hachage IP : Hacher l'IP du client pour déterminer le serveur (persistance de session)
  • Round Robin pondéré : Les serveurs avec une capacité plus élevée reçoivent plus de requêtes
• Types :
  • Couche 4 (Transport) : Basé sur IP/Port, plus rapide
  • Couche 7 (Application) : Basé sur le contenu (URL, en-têtes), plus intelligent
• Outils : Nginx, HAProxy, AWS ELB, Google Cloud Load Balancer.

Rareté : Courant Difficulté : Moyenne

DevOps et Cloud (4 Questions)

19. Expliquez Docker et les avantages de la conteneurisation.

Réponse : Docker regroupe les applications avec leurs dépendances dans des conteneurs.

• Avantages :
  • Cohérence : Même environnement en dev/staging/prod
  • Isolation : Chaque conteneur est isolé
  • Léger : Partage le noyau du système d'exploitation hôte (vs VMs)
  • Démarrage rapide : Secondes vs minutes pour les VMs
  • Portabilité : S'exécute partout où Docker est installé
• Composants :
  • Image : Modèle en lecture seule
  • Conteneur : Instance en cours d'exécution d'une image
  • Dockerfile : Instructions pour construire une image
  • Registre : Docker Hub, registres privés

Rareté : Très courant Difficulté : Facile

20. Qu'est-ce que CI/CD et pourquoi est-ce important ?

Réponse :

• Intégration continue : Les développeurs fusionnent le code fréquemment, les tests automatisés s'exécutent à chaque commit
• Déploiement continu : Déployer automatiquement en production après avoir passé les tests
• Avantages :
  • Retour d'information plus rapide
  • Problèmes d'intégration réduits
  • Code de meilleure qualité
  • Délai de commercialisation plus rapide
• Outils : Jenkins, GitLab CI, GitHub Actions, CircleCI
• Étapes du pipeline : Build → Test → Deploy
• Bonnes pratiques : Tests automatisés, Feature flags, Mécanismes de rollback.

Rareté : Très courant Difficulté : Facile

21. Comment surveillez-vous et déboguez-vous les applications de production ?

Réponse : Une surveillance complète est essentielle pour les systèmes de production.

• Journalisation :
  • Journalisation structurée (format JSON)
  • Journalisation centralisée (ELK Stack, Splunk)
  • Niveaux de journalisation (ERROR, WARN, INFO, DEBUG)
• Métriques :
  • Métriques de l'application (temps de réponse, débit)
  • Métriques de l'infrastructure (CPU, mémoire, disque)
  • Outils : Prometheus, Grafana, DataDog
• Traçage :
  • Traçage distribué pour les microservices
  • Outils : Jaeger, Zipkin, AWS X-Ray
• Alertes : PagerDuty, Opsgenie pour les problèmes critiques
• Suivi des erreurs : Sentry, Rollbar pour la surveillance des exceptions.

Rareté : Courant Difficulté : Moyenne

22. Qu'est-ce que l'Infrastructure as Code (IaC) ?

Réponse : IaC gère l'infrastructure par le code plutôt que par des processus manuels.

• Avantages :
  • Contrôle de version pour l'infrastructure
  • Environnements reproductibles
  • Provisionnement plus rapide
  • Réduction des erreurs humaines
• Outils :
  • Terraform : Indépendant du cloud, déclaratif
  • CloudFormation : Spécifique à AWS
  • Ansible : Gestion de la configuration
  • Pulumi : Utiliser des langages de programmation
• Bonnes pratiques :
  • Stocker dans le contrôle de version
  • Composants modulaires et réutilisables
  • Environnements séparés (dev/staging/prod)
  • Tests automatisés de l'infrastructure.

Rareté : Moyenne Difficulté : Moyenne

Tests et bonnes pratiques (3 Questions)

23. Expliquez la pyramide des tests.

Réponse : La pyramide des tests représente la répartition idéale des différents types de tests.

• Tests unitaires : Tester des fonctions/composants individuels de manière isolée. Rapide, beaucoup d'entre eux.
• Tests d'intégration : Tester la façon dont les composants fonctionnent ensemble. Vitesse moyenne, nombre modéré.
• Tests E2E : Tester les flux d'utilisateurs entiers. Lents, coûteux, peu d'entre eux.
• Justification : Plus de tests unitaires car ils sont rapides et détectent les bogues tôt. Moins de tests E2E car ils sont lents et fragiles.

Rareté : Courant Difficulté : Facile

24. Quels sont les principes SOLID ?

Réponse : SOLID est un acronyme pour cinq principes de conception :

• S - Single Responsibility : Une classe ne doit avoir qu'une seule raison de changer
• O - Open/Closed : Ouvert à l'extension, fermé à la modification
• L - Liskov Substitution : Les sous-types doivent être substituables à leurs types de base
• I - Interface Segregation : De nombreuses interfaces spécifiques valent mieux qu'une seule interface générale
• D - Dependency Inversion : Dépendre des abstractions, pas des concrétions
• Avantages : Code plus maintenable, testable et flexible.

Rareté : Courant Difficulté : Moyenne

25. Comment gérez-vous les erreurs dans JavaScript asynchrone ?

Réponse : Plusieurs modèles existent pour la gestion des erreurs asynchrones :

• Promises :

fetch('/api/data')
  .then(response => response.json())
  .catch(error => console.error('Error:', error));

• Async/Await :

try {
  const response = await fetch('/api/data');
  const data = await response.json();
} catch (error) {
  console.error('Error:', error);
}

• Gestionnaires d'erreurs globaux :
  • window.addEventListener('unhandledrejection', ...) pour les rejets de promesses non gérés
  • Middleware d'erreur Express pour le backend
• Bonne pratique : Toujours gérer les erreurs, utiliser une gestion centralisée des erreurs, consigner correctement les erreurs.

Rareté : Très courant Difficulté : Facile