Cours de codage informatique

Leçon 1 • Langages et paradigmes de programmation

Présente les langages compilés et interprétés, et les styles procéduraux, orientés objet et fonctionnels. Aide les étudiants à choisir l'outil adapté à une tâche.

Leçon 2 • Pseudo-code et pensée algorithmique

Enseigne la décomposition structurée des problèmes avant d'écrire la syntaxe réelle. Relie la planification logique à chaque tâche de codage dans les chapitres suivants.

Leçon 3 • Comment les ordinateurs exécutent les instructions

Explique le cycle de fetch-décodage-exécution et la hiérarchie mémoire. Ancre tous les concepts de codage ultérieurs dans la réalité matérielle.

Leçon 1 • Sécurité des types et erreurs de type courantes

Identifie les bogues d'incompatibilité de type et les compromis entre typage statique et dynamique. Prépare les étudiants à écrire un code robuste et résistant aux erreurs.

Leçon 2 • Chaînes de caractères et entrées/sorties de base

Enseigne la création de chaînes, la concaténation, le formatage et les E/S console. Relie les types de données aux schémas d'interaction réels avec l'utilisateur.

Leçon 3 • Types de données primitifs

Examine les entiers, les flottants, les booléens, les caractères et les chaînes. Les étudiants sélectionnent les types appropriés pour éviter les erreurs de précision et de mémoire.

Leçon 4 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, de comparaison, logiques et d'affectation. Les étudiants construisent des expressions composées et comprennent la précédence des opérateurs.

Leçon 1 • Instructions conditionnelles

Couvre les constructions if, else-if et switch pour la logique de branchement. Les étudiants implémentent des arbres de décision qui répondent à différentes entrées.

Leçon 2 • Combinaison de conditions et de boucles

Intègre des conditionnels à l'intérieur de boucles pour résoudre des problèmes de filtrage et de recherche réels. Relie les compétences syntaxiques isolées à une logique de programme cohérente.

Leçon 3 • Instructions de contrôle de boucle

Explique break, continue et return dans les boucles. Les étudiants écrivent des boucles précises qui sortent ou sautent des itérations sous des conditions spécifiques.

Leçon 4 • Boucles et itération

Enseigne les boucles for, while et do-while avec des cas d'utilisation pratiques. Les étudiants automatisent des tâches répétitives et traitent des collections de données.

Leçon 1 • Définir et appeler des fonctions

Couvre la déclaration de fonction, les paramètres, les valeurs de retour et la syntaxe d'appel. Les étudiants remplacent les blocs de code répétés par des unités nommées et appelables.

Leçon 2 • Paramètres par défaut, optionnels et variadiques

Enseigne des signatures de fonction flexibles qui gèrent des nombres d'arguments variables. Les étudiants écrivent des API faciles à appeler avec un minimum d'entrées requises.

Leçon 3 • Portée et durée de vie des variables

Explique la portée locale, globale et de fermeture dans les fonctions. Les étudiants préviennent les effets de bord involontaires causés par une mauvaise utilisation de la portée.

Leçon 4 • Récursivité et pensée récursive

Introduit les appels de fonction récursifs avec les cas de base et le comportement de la pile. Les étudiants résolvent des problèmes de parcours d'arbre et de diviser pour régner de manière récursive.

Leçon 1 • Ensembles et collections uniques

Explique les opérations sur les ensembles, y compris l'union, l'intersection et la différence. Les étudiants dédoublonnent les données et effectuent des tests d'appartenance de manière efficace.

Leçon 2 • Tableaux et listes

Couvre le stockage indexé, le redimensionnement dynamique et les opérations courantes sur les listes. Les étudiants construisent et parcourent des collections ordonnées de tout type de données.

Leçon 3 • Piles, files d'attente et listes chaînées

Introduit les structures LIFO et FIFO et les listes chaînées basées sur des pointeurs. Les étudiants implémentent ces structures et reconnaissent leurs applications réelles.

Leçon 4 • Dictionnaires et tables de hachage

Enseigne le stockage clé-valeur, les concepts de hachage et l'efficacité de la recherche. Les étudiants modélisent des entités du monde réel et effectuent une récupération rapide des données.

Leçon 1 • Polymorphisme et interfaces

Couvre le polymorphisme d'exécution, les classes abstraites et les contrats d'interface. Les étudiants écrivent un code flexible qui fonctionne avec plusieurs types d'objets de manière uniforme.

Leçon 2 • Classes et objets

Couvre la définition de classe, l'instanciation, les attributs et les méthodes. Les étudiants traduisent des entités réelles en plans réutilisables de classes.

Leçon 3 • Héritage et réutilisation de code

Explique les relations de classe parent-enfant et la redéfinition de méthode. Les étudiants étendent des classes existantes sans dupliquer la logique.

Leçon 4 • Principes SOLID et conception POO

Applique les cinq principes SOLID pour évaluer et améliorer les conceptions de classes. Les étudiants refactorisent un code POO mal structuré en architectures maintenables.

Leçon 1 • Flux de travail du développement piloté par les tests

Applique le cycle rouge-vert-refactor pour construire des fonctionnalités en écrivant les tests en premier. Les étudiants internalisent le TDD comme une discipline qui améliore la conception et réduit les régressions.

Leçon 2 • Types d'erreurs et exceptions

Distingue les erreurs de syntaxe, d'exécution et de logique ainsi que leurs causes. Les étudiants identifient rapidement les catégories d'erreurs pour appliquer la stratégie de correction adaptée.

Leçon 3 • Fondamentaux des tests unitaires

Introduit les cas de test, les assertions et les exécuteurs de test pour le test isolé de fonctions. Les étudiants écrivent des tests qui vérifient que chaque fonction se comporte comme spécifié.

Leçon 4 • Techniques et outils de débogage

Enseigne les points d'arrêt, les expressions de surveillance, l'exécution pas à pas et la journalisation. Les étudiants localisent et corrigent les bogues de manière systématique plutôt qu'en devinant.

Leçon 1 • Architecture de projet et organisation des fichiers

Enseigne les structures de dossiers, la séparation des modules et la gestion de la configuration. Les étudiants organisent des projets multi-fichiers afin que les coéquipiers puissent les parcourir facilement.

Leçon 2 • Déploiement et partage de votre projet

Couvre le packaging, l'hébergement et le partage de code via des dépôts publics. Les étudiants rendent leur projet de fin d'études accessible et présentable aux employeurs.

Leçon 3 • Contrôle de version avec Git

Couvre les commits, les branches, les fusions et les pull requests dans un flux de travail d'équipe. Les étudiants gèrent l'historique du code et collaborent sans écraser le travail des autres.

Leçon 4 • Qualité du code et normes de style

Applique le linting, le formatage, les conventions de nommage et les listes de contrôle de revue de code. Les étudiants produisent un code lisible qui répond aux normes des équipes professionnelles.