Cours sur les bases de la programmation

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

Présente la décomposition, le pseudocode et les organigrammes comme outils de pré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 recherche-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ée. Permet aux apprenants d'effectuer des calculs essentiels à toutes les tâches de programmation.

Leçon 2 • Conversion et transtypage de types

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 types inattendues.

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

Explique comment les variables nomment les 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 prochain chapitre.

Leçon 1 • Instructions conditionnelles if-else

Couvre les structures if-else à une branche, deux branches et plusieurs branches. Forme l'outil de prise de décision principal utilisé dans tous les chapitres suivants.

Leçon 2 • Évaluation des valeurs vraies et fausses

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

Leçon 3 • Instructions switch et match

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

Leçon 1 • Boucles while et do-while

Présente les boucles pilotées par des conditions 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 sur le nombre d'itérations pour les tâches prévisibles.

Leçon 3 • Itération sur des collections

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

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 nommage et les effets secondaires non désirés dans les programmes plus volumineux.

Leçon 2 • Valeurs de retour et sortie

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

Leçon 3 • Notions fondamentales sur la récursivité

Présente les fonctions auto-appelantes 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 d'opérer 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 le mappage 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 grandissent et rétrécissent à l'exécution. Permet un stockage de données flexible 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 de code

Explique les relations parent-enfant entre 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 plans et les objets comme des instances à l'exécution. Présente le mécanisme d'abstraction principal pour organiser des programmes complexes.

Leçon 4 • Polymorphisme et interfaces

Présente la distribution 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 première pour les bogues complexes.

Leçon 2 • Rédaction et exécution de tests unitaires

Présente les fonctions de test, les assertions et les exécuteurs de test 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 le 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 contrôlée des erreurs. Prévient les plantages de programme et permet des messages d'erreur significatifs destinés à l'utilisateur.