Formation développeur informatique

Leçon 1 • Comment les Ordinateurs Exécutent le Code

Couvre la représentation binaire, les cycles d'instructions du CPU et la hiérarchie mémoire. Ancre tous les concepts de codage ultérieurs dans la réalité matérielle.

Leçon 2 • Stratégies de Débogage et de Résolution de Problèmes

Enseigne le diagnostic systématique des erreurs à l'aide d'instructions d'affichage et d'un débogueur. Développe les habitudes analytiques nécessaires pour tout travail de codage ultérieur.

Leçon 3 • Concepts Fondamentaux de la Programmation

Présente les variables, les types de données, les opérateurs et le flux de contrôle. Ces éléments de base sous-tendent chaque programme écrit dans les chapitres suivants.

Leçon 1 • Fondamentaux de Git

Couvre l'arbre de travail, la zone de préparation et le modèle d'historique des commits. Établit le modèle mental nécessaire pour toute opération de branche à venir.

Leçon 2 • Dépôts Distants et Pull Requests

Pousse les branches vers un hôte distant et ouvre des pull requests pour révision. Présente la procédure de révision de code qui régit toutes les contributions d'équipe.

Leçon 3 • Flux de Travail d'Équipe et Hygiène du Dépôt

Établit les conventions de message de commit, de nommage des branches et les règles de branches protégées. Prépare les étudiants à contribuer à des dépôts open-source et d'entreprise réels.

Leçon 1 • Tableaux et Listes Chaînées

Met en contraste le stockage contigu et celui basé sur des pointeurs avec des compromis de performance réels. Fournit la base pour comprendre toutes les autres structures.

Leçon 2 • Algorithmes de Tri et de Recherche

Implémente et évalue les performances des stratégies courantes de tri et de recherche. Développe l'intuition pour le choix d'algorithmes en fonction de la taille et de la forme des données.

Leçon 3 • Piles, Files d'Attente et Tables de Hachage

Couvre les abstractions LIFO et FIFO ainsi que le stockage clé-valeur basé sur le hachage. Ces structures apparaissent dans les analyseurs, les planificateurs et les caches tout au long du cours.

Leçon 4 • Récursivité et Programmation Dynamique

Résout des problèmes en les décomposant en sous-problèmes avec mémorisation. Étend la portée algorithmique au-delà des solutions itératives présentées précédemment.

Leçon 1 • Principes de Conception SOLID

Applique cinq règles de conception OOP pour évaluer et refactoriser les conceptions de classes. Fournit le vocabulaire utilisé dans les révisions de code dans tous les chapitres restants.

Leçon 2 • Polymorphisme et Typage Canard

Permet à une seule interface de fonctionner sur plusieurs types au moment de l'exécution. Réduit le couplage entre les composants construits tout au long du projet du chapitre.

Leçon 3 • Héritage et Réutilisation de Code

Modélise les relations est-un via des hiérarchies de classes pour éliminer la duplication. Se connecte directement au polymorphisme couvert dans la section suivante.

Leçon 4 • Construction d'un Projet Multi-Classes

Intègre tous les concepts de la POO dans une mini-application cohérente avec plusieurs classes en interaction. Valide les décisions de conception par une révision de code par les pairs.

Leçon 1 • Connexion d'une Base de Données à une Application

Intègre un pilote de base de données et un ORM dans le code de l'application avec un pool de connexions. Achève la couche de persistance du projet en cours.

Leçon 2 • Principes Essentiels des Requêtes SQL

Écrit des instructions SELECT, INSERT, UPDATE et DELETE avec filtrage et tri. Ces requêtes forment la couche d'accès aux données du projet du chapitre.

Leçon 3 • Index, Transactions et Contraintes

Ajoute des index pour la performance des requêtes et enveloppe les mutations dans des transactions ACID. Garantit l'intégrité des données dans des scénarios d'accès concurrent.

Leçon 4 • Concepts de Base de Données Relationnelle

Explique les tables, les clés primaires, les clés étrangères et la normalisation jusqu'à la troisième forme normale. Fournit le vocabulaire de conception de schéma utilisé tout au long du chapitre.

Leçon 1 • HTTP et le Cycle des Requêtes Web

Trace une requête navigateur à travers DNS, TCP et HTTP jusqu'à une réponse serveur. Établit la connaissance des protocoles requise pour concevoir des points de terminaison d'API corrects.

Leçon 2 • Authentification et Autorisation

Implémente l'authentification basée sur des jetons et le contrôle d'accès basé sur les rôles sur les routes de l'API. Sécurise l'API du projet avant qu'elle ne soit exposée à des consommateurs externes.

Leçon 3 • Validation des Entrées et Gestion des Erreurs

Valide les corps de requête avec des schémas et mappe les erreurs de domaine vers des codes HTTP. Empêche les données malformées de corrompre la couche de base de données.

Leçon 4 • Documentation et Test d'API

Génère une documentation d'API interactive et écrit des tests de point de terminaison automatisés. Garantit que le contrat de l'API est vérifiable et consommable par d'autres développeurs.

Leçon 1 • Fondamentaux des Tests et Pyramide de Tests

Définit les trois couches de test et leurs compromis coût/retour d'information. Encadre la stratégie de test appliquée dans toutes les sections restantes.

Leçon 2 • Tests Unitaires avec Mocks et Stubs

Isole les unités testées en remplaçant les dépendances par des doubles de test. Permet des tests rapides et déterministes pour la logique métier écrite dans les chapitres précédents.

Leçon 3 • Couverture de Code et Qualité Continue

Mesure la couverture, impose des seuils et intègre les tests dans un pipeline CI. Connecte la pratique des tests au flux de travail de déploiement présenté ensuite.

Leçon 4 • Tests d'Intégration et de Base de Données

Teste les interactions entre composants contre une base de données réelle ou en mémoire. Valide que l'ORM et la logique de requête du chapitre sur les bases de données fonctionnent correctement.

Leçon 1 • Livraison Continue et Déploiement

Étend le pipeline CI pour pousser les artefacts vérifiés vers les environnements de préproduction et de production. Présente les stratégies de déploiement qui minimisent les temps d'arrêt et les risques.

Leçon 2 • Surveillance et Observabilité

Instrumente l'application avec des journaux, des métriques et des traces pour détecter les problèmes de production. Ferme la boucle de retour d'information entre le déploiement et la qualité du code.

Leçon 3 • Conteneurisation avec Docker

Empaquète une application et ses dépendances dans une image de conteneur portable. Élimine les incohérences d'environnement rencontrées dans les chapitres précédents.

Leçon 4 • Pipelines d'Intégration Continue

Configure des jobs automatisés de linting, de test et de construction déclenchés à chaque push de code. Applique les seuils de qualité établis dans le chapitre sur les tests.