Formation développeur logiciel

Leçon 1 • Configuration de votre environnement de développement

Installe et configure un éditeur de code, un environnement d'exécution et un gestionnaire de paquets. Garantit que chaque étudiant dispose d'un espace de travail identique et reproductible avant d'écrire du code.

Leçon 2 • Maîtrise de la ligne de commande

Enseigne la navigation, la manipulation de fichiers et la gestion des processus dans un terminal. La maîtrise de la ligne de commande accélère tous les flux de travail ultérieurs du cours.

Leçon 3 • Gestion de versions avec Git

Présente Git comme l'outil standard de l'industrie pour le suivi des modifications et la collaboration. Les étudiants effectuent des commits, créent des branches et poussent du code à la fin de cette section.

Leçon 1 • Collections et modèles d'itération

Présente les tableaux, les listes et les dictionnaires pour stocker des données groupées. Les étudiants appliquent des modèles d'itération pour traiter efficacement des ensembles de données réels.

Leçon 2 • Variables, types et opérateurs

Explique comment les données sont stockées, typées et transformées par le biais d'expressions. Fournit le vocabulaire nécessaire pour lire et écrire n'importe quelle instruction de code.

Leçon 3 • Fonctions et code modulaire

Définit les fonctions comme des unités de logique réutilisables et testables. La conception modulaire réduit la duplication et constitue la base de tous les programmes plus importants de ce cours.

Leçon 4 • Flux de contrôle et prise de décision

Couvre les conditionnelles et les boucles qui dirigent les chemins d'exécution du programme. Les étudiants implémentent des algorithmes de logique conditionnelle et itératifs à partir de zéro.

Leçon 1 • Composition et injection de dépendances

Compare la composition avec l'héritage et introduit l'injection de dépendances. Les étudiants apprennent quand préférer les relations a-un aux hiérarchies est-un.

Leçon 2 • Classes et objets

Définit les classes comme des modèles et les objets comme des instances avec état et comportement. Relie la syntaxe POO aux fonctions modulaires introduites dans le chapitre précédent.

Leçon 3 • Héritage et polymorphisme

Modélise les relations est-un à travers des hiérarchies de classes et la redéfinition de méthodes. Les étudiants écrivent du code polymorphe qui gère plusieurs types via une seule interface.

Leçon 4 • Principes de conception SOLID

Applique cinq principes fondamentaux de conception POO à des exemples de code réels. Les étudiants refactorisent des classes mal structurées en conceptions propres et maintenables.

Leçon 1 • Algorithmes de tri et de recherche

Implémente et compare des algorithmes de tri et de recherche classiques. Les étudiants évaluent les implémentations et justifient la sélection d'algorithmes par leur complexité.

Leçon 2 • Structures de données linéaires

Couvre les tableaux, les listes chaînées, les piles et les files d'attente avec leurs compromis. Les étudiants implémentent chaque structure et identifient les cas d'utilisation appropriés.

Leçon 3 • Analyse de complexité

Introduit la notation Grand-O pour mesurer l'efficacité des algorithmes. Les étudiants évaluent les performances du code avant de choisir entre des implémentations concurrentes.

Leçon 4 • Stratégies de conception d'algorithmes

Introduit les approches diviser-pour-régner, programmation dynamique et gloutonnes. Les étudiants décomposent des problèmes complexes en sous-problèmes résolubles.

Leçon 1 • Fondamentaux des bases de données relationnelles

Explique les tables, les clés et les relations comme fondement des bases de données relationnelles. Les étudiants modélisent un domaine à l'aide de diagrammes entité-association avant d'écrire du SQL.

Leçon 2 • Intégration de base de données dans le code applicatif

Connecte une application à une base de données en utilisant un ORM et des modèles de requêtes brutes. Les étudiants construisent une couche de dépôt qui abstrait la persistance de la logique métier.

Leçon 3 • NoSQL et magasins de documents

Compare les magasins de documents, clé-valeur et colonnes-familles avec les bases de données relationnelles. Les étudiants choisissent le bon modèle de persistance pour une forme de données donnée.

Leçon 4 • Langage de requête SQL

Couvre les opérations SELECT, INSERT, UPDATE, DELETE et JOIN. Les étudiants écrivent des requêtes qui répondent à des questions métier réelles sur un ensemble de données exemple.

Leçon 1 • Construction d'une API RESTful

Conçoit et implémente des points de terminaison REST suivant des conventions orientées ressources. Les étudiants créent une API CRUD soutenue par la couche de base de données du chapitre précédent.

Leçon 2 • Authentification et autorisation

Implémente l'authentification basée sur les jetons et le contrôle d'accès basé sur les rôles. Les étudiants sécurisent les points de terminaison afin que seuls les utilisateurs autorisés puissent accéder aux ressources protégées.

Leçon 3 • Consommation d'API externes

Effectue des requêtes HTTP authentifiées à des services tiers et gère les réponses. Les étudiants intègrent une API publique dans leur application en utilisant les bonnes pratiques.

Leçon 4 • HTTP et le cycle de requête web

Explique les méthodes HTTP, les codes d'état, les en-têtes et le modèle requête-réponse. Ce modèle mental sous-tend toutes les API et tous les frameworks web utilisés ultérieurement.

Leçon 1 • Tests d'intégration et d'API

Teste les interactions entre les composants et valide les contrats d'API de bout en bout. Les étudiants détectent les bogues d'intégration que les tests unitaires ne peuvent pas détecter.

Leçon 2 • Test unitaire en pratique

Écrit des tests unitaires isolés pour les fonctions et les classes à l'aide d'un framework de test. Les étudiants atteignent une couverture élevée sur les modules de logique métier de base.

Leçon 3 • Développement piloté par les tests

Applique le cycle rouge-vert-refactorisation pour guider la conception à travers des tests échoués. Les étudiants expérimentent comment le TDD produit un code plus simple et plus testable.

Leçon 4 • Fondamentaux et stratégie des tests

Introduit la pyramide de test et les compromis coût-bénéfice de chaque couche. Les étudiants planifient une stratégie de test avant d'écrire un seul cas de test.

Leçon 1 • Résilience et tolérance aux pannes

Conçoit des systèmes qui se dégradent gracieusement en cas de panne en utilisant des coupe-circuits et des nouvelles tentatives. Les étudiants appliquent des modèles de résilience à l'API construite dans les chapitres précédents.

Leçon 2 • Conception pour la scalabilité et la performance

Couvre la scalabilité horizontale, les stratégies de mise en cache et l'équilibrage de charge à l'étape de la conception. Les étudiants identifient les goulots d'étranglement avant d'écrire du code en utilisant la planification de capacité.

Leçon 3 • Aperçu des modèles architecturaux

Examine les architectures en couches, événementielles et en microservices avec leurs compromis. Les étudiants font correspondre un document de spécifications à un style architectural approprié.

Leçon 4 • Pratique de conception de systèmes

Applique tous les concepts architecturaux pour concevoir un système distribué réaliste de bout en bout. Les étudiants présentent et défendent leurs conceptions face à des scénarios de scalabilité et de panne.