Cours de programmation informatique

Leçon 1 • Choix et installation d'un langage

Compare les paradigmes de langage de programmation et guide l'installation d'un environnement d'exécution adapté aux débutants. Met en place une chaîne d'outils cohérente pour l'ensemble du cours.

Leçon 2 • Comment les ordinateurs exécutent les programmes

Explique le cycle de récupération-décodage-exécution, la mémoire et le rôle du système d'exploitation. Ancre tous les concepts de codage ultérieurs dans la réalité matérielle.

Leçon 3 • Gestion de versions avec les bases de Git

Présente Git comme un filet de sécurité pour les modifications de code et la collaboration. Les étudiants réalisent leur premier commit, établissant des habitudes utilisées dans tous les chapitres suivants.

Leçon 1 • Travailler avec les chaînes de caractères

Explore l'indexation, le découpage, la concaténation et les méthodes intégrées courantes des chaînes. La manipulation de chaînes est essentielle pour les entrées et sorties utilisateur dans les projets ultérieurs.

Leçon 2 • Variables et affectation

Couvre la déclaration de variables, les conventions de nommage et la liaison mémoire. La compréhension des variables est un prérequis pour tout concept de codage ultérieur.

Leçon 3 • Opérateurs et expressions

Enseigne les opérateurs arithmétiques, de comparaison, logiques et d'affectation avec les règles de précédence. Les expressions sont les éléments de base de tout contrôle de flux abordé ensuite.

Leçon 4 • Types de données primitifs

Examine les entiers, les flottants, les booléens et les chaînes avec leurs implications mémoire. Un choix de type correct prévient les bogues courants introduits dans les chapitres logiques ultérieurs.

Leçon 1 • Instructions conditionnelles

Couvre les branches if, else-if et else avec des conditions booléennes. Les conditionnels sont le mécanisme principal de la logique décisionnelle dans tous les programmes.

Leçon 2 • Débogage de la logique de contrôle de flux

Utilise des instructions d'affichage et un débogueur pour tracer l'exécution des conditionnels et des boucles. Des compétences de débogage systématiques réduisent le temps passé à corriger les erreurs de logique dans les projets ultérieurs.

Leçon 3 • Boucles et itération

Présente les boucles while et for pour répéter des opérations sur des données ou des comptes. L'itération sous-tend les collections, les algorithmes et le traitement de données abordés plus tard.

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

Explique break, continue et return dans les boucles pour modifier le flux d'itération. Un contrôle précis des boucles est essentiel pour écrire des algorithmes corrects et efficaces.

Leçon 1 • Organisation du code en modules

Montre comment répartir le code dans des fichiers et importer des fonctionnalités entre les modules. La conception modulaire est le fondement des projets plus importants des chapitres avancés.

Leçon 2 • Définition et appel de fonctions

Couvre la syntaxe des fonctions, les paramètres, les valeurs de retour et la mécanique d'appel. Les fonctions sont l'unité principale de réutilisation du code dans le reste du cours.

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

Introduit la pensée récursive avec des cas de base et des cas récursifs. La récursivité est fondamentale pour le parcours d'arbres et les algorithmes diviser-pour-régner présentés plus tard.

Leçon 4 • Arguments par défaut et arguments nommés

Démontre les paramètres optionnels, les valeurs par défaut et le passage d'arguments nommés. Des signatures de fonctions flexibles rendent les API plus faciles à utiliser et à étendre.

Leçon 1 • Choisir la bonne structure de données

Compare la complexité temporelle et spatiale des listes, dictionnaires et ensembles pour les opérations courantes. Un choix éclairé de structure est essentiel pour le chapitre sur les algorithmes à venir.

Leçon 2 • Ensembles et opérations d'unicité

Présente les ensembles pour la déduplication, les tests d'appartenance et l'algèbre des ensembles. Les opérations sur les ensembles offrent des solutions efficaces aux problèmes impliquant des éléments uniques.

Leçon 3 • Tuples et séquences immuables

Explique les tuples, leur immutabilité et leurs cas d'utilisation, comme les valeurs de retour multiples. Choisir des tuples plutôt que des listes signale l'intention et empêche les mutations accidentelles.

Leçon 4 • Listes et tableaux dynamiques

Couvre la création de listes, l'indexation, le découpage et les méthodes de mutation. Les listes sont le type de collection le plus courant et apparaissent dans tous les projets ultérieurs.

Leçon 1 • Classes et instances d'objets

Définit la syntaxe des classes, les constructeurs et la création d'instances. Les classes sont le mécanisme d'abstraction principal pour tous les patrons de conception orientés objet à venir.

Leçon 2 • Principes de conception orientée objet

Présente les principes SOLID et les patrons de conception courants à un niveau conceptuel. Ces principes guident les décisions architecturales prises dans le chapitre du projet final.

Leçon 3 • Polymorphisme et typage canard

Explique comment des objets de différentes classes partagent une interface commune via le polymorphisme. Une conception polymorphe rend les systèmes flexibles et plus faciles à étendre.

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

Démontre l'héritage simple et multi-niveaux avec la redéfinition de méthodes. L'héritage permet une modélisation hiérarchique et réduit la duplication de code entre des classes apparentées.

Leçon 1 • Journalisation et observabilité

Introduit la journalisation structurée comme remplacement du débogage par affichage. Les journaux fournissent une visibilité à l'exécution essentielle pour diagnostiquer les problèmes dans les applications déployées.

Leçon 2 • Comprendre les exceptions et les erreurs

Distingue les erreurs de syntaxe, les exceptions d'exécution et les erreurs logiques par catégorie. Une classification correcte accélère le diagnostic et éclaire la stratégie de gestion appropriée.

Leçon 3 • Validation des entrées et code défensif

Applique des motifs de validation pour protéger les fonctions contre les mauvaises entrées avant le traitement. Le code défensif réduit la surface de défaillance à l'exécution en production.

Leçon 4 • Levée et création d'exceptions personnalisées

Montre comment lever des exceptions intentionnellement et définir des classes d'exceptions spécifiques au domaine. Les exceptions personnalisées rendent les contrats d'erreur des bibliothèques et des API explicites.

Leçon 1 • Planification du projet et exigences

Traduit un énoncé de problème en récits utilisateur, critères d'acceptation et un plan de modules. Des exigences claires empêchent la dérive de la portée et guident toutes les décisions d'implémentation.

Leçon 2 • Documentation et commentaires de code

Enseigne les conventions des chaînes de documentation, les commentaires en ligne et la génération de documents de référence API. Une bonne documentation rend le code utilisable par les coéquipiers et les mainteneurs futurs.

Leçon 3 • Empaquetage et partage de votre projet

Guide la gestion des dépendances, l'empaquetage du projet et la publication dans un registre de paquets. Les paquets distribuables sont le livrable standard dans les équipes logicielles professionnelles.

Leçon 4 • Tests automatisés avec des tests unitaires

Couvre la conception de cas de test, les assertions et l'exécution d'une suite de tests avec un cadre standard. Les tests automatisés détectent les régressions et valident le comportement à mesure que le projet grandit.