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 à 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 contrôle de flux. Ces primitives sous-tendent chaque programme écrit dans les chapitres suivants.

Leçon 1 • Principes 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 requis pour toute opération de branchement à 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. Introduit la porte de revue de code qui régit toutes les contributions en équipe.

Leçon 3 • Flux de travail en équipe et hygiène du dépôt

Établit les conventions de message de commit, le nommage des branches et les règles de protection des branches. 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

Contraste entre le stockage contigu et le stockage basé sur les 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 la sélection d'algorithmes en fonction de la taille et de la forme des données.

Leçon 3 • Piles, files et tables de hachage

Couvre les abstractions LIFO et FIFO ainsi que le stockage clé-valeur par 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 qui se chevauchent avec mémorisation. Étend la gamme 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 POO pour évaluer et refactoriser les conceptions de classes. Fournit le vocabulaire utilisé dans les revues de code de tous les chapitres restants.

Leçon 2 • Polymorphisme et duck typing

Permet à une seule interface d'opérer 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 du code

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

Leçon 4 • Construction d'un projet multi-classes

Intègre tous les concepts POO dans une mini-application cohérente avec plusieurs classes en interaction. Valide les décisions de conception par la revue 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 regroupement 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 les performances des requêtes et enveloppe les mutations dans des transactions ACID. Assure l'intégrité des données dans des scénarios d'accès concurrent.

Leçon 4 • Concepts des bases de données relationnelles

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 de requête web

Trace une requête navigateur via DNS, TCP et HTTP jusqu'à une réponse serveur. Établit la connaissance des protocoles nécessaire pour concevoir des points d'accès API corrects.

Leçon 2 • Authentification et autorisation

Implémente l'authentification par jeton 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 aux consommateurs externes.

Leçon 3 • Validation des entrées et gestion des erreurs

Valide les charges utiles des requêtes avec des schémas et mappe les erreurs métier sur 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 d'accès 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 des tests

Définit les trois couches de test et leurs compromis coût-retour d'information. Établit 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, applique des seuils et intègre les tests dans un pipeline CI. Relie la pratique du test au flux de travail de déploiement introduit ensuite.

Leçon 4 • Tests d'intégration et de base de données

Teste les interactions des composants contre une base de données réelle ou en mémoire. Valide le bon fonctionnement de la logique ORM et de requête du chapitre sur les bases de données.

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. Introduit des 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 entre le déploiement et la qualité du code.

Leçon 3 • Conteneurisation avec Docker

Empaquette une application et ses dépendances dans une image 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 lint, de test et de construction déclenchés à chaque push de code. Applique les contrôles de qualité établis dans le chapitre sur les tests.