Cours de programmeur 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. S'assure que chaque étudiant dispose d'un espace de travail identique et reproductible avant d'écrire du code.

Leçon 2 • Compétence en 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 validations, créent des branches et poussent du code à la fin de cette section.

Leçon 1 • Collections et motifs d'itération

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

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

Explique comment les données sont stockées, typées et transformées par des expressions. Fournit le vocabulaire nécessaire pour lire et écrire toute instruction de code.

Leçon 3 • Fonctions et code modulaire

Définit les fonctions comme des unités logiques réutilisables et testables. La conception modulaire réduit la duplication et constitue le fondement de tous les programmes plus volumineux 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 branchement et des boucles itératives à partir de zéro.

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

Oppose la composition à l'héritage et présente 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 possédant un état et un comportement. Relie la syntaxe POO aux fonctions modulaires présentées dans le chapitre précédent.

Leçon 3 • Héritage et polymorphisme

Modélise les relations « est un » à l'aide de hiérarchies de classes et de 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 de conception POO fondamentaux à des exemples de code réels. Les étudiants remanient des classes mal structurées en conceptions propres et maintenables.

Leçon 1 • Algorithmes de tri et de recherche

Implémente et compare les algorithmes de tri et de recherche classiques. Les étudiants effectuent des tests de performance des implémentations et justifient le choix de l'algorithme en fonction de la 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é

Présente la notation Grand O pour mesurer l'efficacité des algorithmes. Les étudiants évaluent le rendement du code avant de choisir entre des implémentations concurrentes.

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

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

Leçon 1 • Notions fondamentales 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é-relation avant d'écrire du SQL.

Leçon 2 • Intégration de bases de données dans le code d'application

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

Leçon 3 • Nosql et magasins de documents

Oppose les magasins de documents, clé-valeur et colonne-famille aux bases de données relationnelles. Les étudiants choisissent le modèle de persistance approprié 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 rédigent des requêtes qui répondent à des questions métier réelles sur un ensemble de données d'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 adossée à la couche de base de données du chapitre précédent.

Leçon 2 • Authentification et autorisation

Implémente l'authentification par jeton 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 vers des services tiers et gère les réponses. Les étudiants intègrent une API publique dans leur application en utilisant les meilleures pratiques.

Leçon 4 • HTTP et 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 cadriciels 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 repérer.

Leçon 2 • Test unitaire en pratique

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

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

Applique le cycle rouge-vert-refactorisation pour guider la conception par des tests échouants. Les étudiants découvrent comment le TDD produit un code plus simple et plus testable.

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

Présente la pyramide de test et les compromis coût-bénéfice de chaque niveau. 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 élégamment en cas de panne à l'aide de disjoncteurs et de tentatives. Les étudiants appliquent des motifs de résilience à l'API construite dans les chapitres précédents.

Leçon 2 • Conception de l'évolutivité et du rendement

Couvre la mise à l'échelle horizontale, les stratégies de mise en cache et la répartition de charge au stade de la conception. Les étudiants identifient les goulets d'étranglement avant d'écrire du code à l'aide de la planification de capacité.

Leçon 3 • Aperçu des motifs architecturaux

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

Leçon 4 • Pratique de la 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 d'évolutivité et de panne.