Cours sur les bases de la programmation

Leçon 1 • Résolution de problèmes avant le codage

Présente la décomposition, le pseudo-code et les organigrammes comme outils précédant le codage. Entraîne une pensée systématique qui réduit les erreurs dans les chapitres suivants.

Leçon 2 • Configuration d'un environnement de développement

Guide l'installation d'un éditeur de code, d'un environnement d'exécution et d'un terminal. Établit un espace de travail fonctionnel utilisé tout au long du cours.

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

Couvre le cycle de récupération-décodage-exécution et le rôle du matériel dans l'exécution des programmes. Ancre tous les concepts de codage ultérieurs dans le comportement physique de la machine.

Leçon 1 • Opérateurs arithmétiques et d'affectation

Enseigne l'addition, la soustraction, le modulo et les opérateurs d'affectation composés. Permet aux apprenants d'effectuer des calculs centraux pour toutes les tâches de programmation.

Leçon 2 • Conversion de type et transtypage

Explique la coercition implicite et le transtypage explicite entre les types de données. Prévient les bogues courants causés par des incompatibilités de type inattendues.

Leçon 3 • Variables et stockage en mémoire

Explique comment les variables nomment des emplacements mémoire et contiennent des valeurs. Relie le stockage de données abstrait au comportement concret du programme.

Leçon 4 • Opérateurs de comparaison et logiques

Présente les opérateurs relationnels et la logique booléenne pour la prise de décision. Soutient directement les instructions conditionnelles enseignées dans le chapitre suivant.

Leçon 1 • Instructions conditionnelles If-Else

Couvre les structures if-else à branche unique, à deux branches et à branches multiples. Forme l'outil de prise de décision principal utilisé dans chaque chapitre suivant.

Leçon 2 • Évaluation des valeurs truthy et falsy

Examine comment les valeurs non booléennes sont évaluées dans des contextes conditionnels. Prévient les bogues logiques subtils courants dans les langages typés dynamiquement.

Leçon 3 • Instructions Switch et Match

Présente le branchement multi-cas comme une alternative plus propre aux longues chaînes else-if. Améliore la lisibilité du code lors du traitement d'ensembles de valeurs discrets.

Leçon 1 • Boucles While et Do-While

Présente les boucles pilotées par condition qui se répètent jusqu'à ce qu'une expression booléenne soit fausse. Établit le concept de gardes de boucle et de conditions de terminaison.

Leçon 2 • Boucles For et modèles de comptage

Couvre l'itération basée sur un compteur avec initialisation, condition et incrément. Permet un contrôle précis du nombre d'itérations pour les tâches prévisibles.

Leçon 3 • Itération sur les collections

Applique les boucles for-each et basées sur un index aux tableaux et aux listes. Fait le pont entre les fondamentaux des boucles et les structures de données introduites dans le chapitre suivant.

Leçon 4 • Contrôle de boucle avec Break et Continue

Enseigne la sortie anticipée et le saut d'itération pour affiner le comportement de la boucle. Donne aux apprenants un contrôle précis sur les scénarios de répétition complexes.

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

Distingue la portée locale, englobante et globale et leur effet sur l'accès aux variables. Prévient les conflits de noms et les effets secondaires indésirables dans les programmes plus volumineux.

Leçon 2 • Valeurs de retour et sortie

Enseigne comment les fonctions produisent une sortie via des instructions return. Relie la sortie de la fonction à l'affectation de variables et à l'évaluation d'expressions.

Leçon 3 • Fondamentaux de la récursivité

Présente les fonctions s'appelant elles-mêmes avec des cas de base et des étapes récursives. Prépare les apprenants pour le parcours d'arbres et les algorithmes diviser-pour-régner ultérieurs.

Leçon 4 • Paramètres et arguments

Explique comment les données sont transmises aux fonctions via les paramètres et les arguments. Permet aux fonctions de fonctionner sur des entrées variables sans duplication de code.

Leçon 1 • Dictionnaires et paires clé-valeur

Enseigne les structures de type table de hachage qui associent des clés à des valeurs. Permet des recherches rapides et une représentation structurée des données dans les programmes.

Leçon 2 • Opérations courantes sur les collections

Applique le tri, la recherche, le filtrage et la transformation (mapping) aux collections. Consolide tous les types de collections en modèles de programmation pratiques et réutilisables.

Leçon 3 • Listes dynamiques et redimensionnement

Présente les structures de liste redimensionnables qui augmentent et diminuent à l'exécution. Permet un stockage flexible des données sans contraintes de taille prédéfinies.

Leçon 4 • Ensembles et contraintes d'unicité

Explique les ensembles comme des collections non ordonnées qui imposent l'unicité des éléments. Utile pour la déduplication et les tests d'appartenance dans les programmes réels.

Leçon 1 • Méthodes et comportement

Couvre les méthodes d'instance, les méthodes statiques et la référence self/this. Permet aux objets d'encapsuler à la fois les données et les opérations qui agissent sur elles.

Leçon 2 • Héritage et réutilisation du code

Explique les relations parent-enfant entre les classes et l'héritage de méthodes. Réduit la duplication en partageant le comportement entre des hiérarchies de classes apparentées.

Leçon 3 • Classes et instanciation d'objets

Définit les classes comme des modèles (blueprints) et les objets comme des instances à l'exécution. Présente le principal mécanisme d'abstraction pour organiser des programmes complexes.

Leçon 4 • Polymorphisme et interfaces

Présente la répartition (dispatch) de méthode à l'exécution et les contrats d'interface pour une conception flexible. Permet d'écrire du code qui fonctionne avec tout objet conforme à une interface partagée.

Leçon 1 • Outils et techniques de débogage

Enseigne les points d'arrêt, les expressions de surveillance et l'exécution pas à pas dans un débogueur. Accélère l'identification de la cause racine des bogues complexes.

Leçon 2 • Écrire et exécuter des tests unitaires

Présente les fonctions de test, les assertions et les exécuteurs de tests pour la vérification automatisée. Garantit que les fonctions individuelles se comportent correctement avant l'intégration.

Leçon 3 • Types d'erreurs dans les programmes

Distingue les erreurs de syntaxe, d'exécution et de logique par leur cause et leur méthode de détection. Construit un vocabulaire de diagnostic utilisé dans toutes les activités de débogage.

Leçon 4 • Mécanismes de gestion des exceptions

Couvre les blocs try-catch-finally et les types d'exceptions personnalisés pour une récupération d'erreur contrôlée. Empêche les plantages du programme et permet d'afficher des messages d'erreur pertinents pour l'utilisateur.