Points clés
Saisissez vous-même le code; exercez votre œil à repérer les petites différences.
La répétition a un but. La « méthode difficile » du livre consiste en une suite de petits exercices contrôlés. Les apprenants saisissent chaque exemple, l’exécutent, comparent le résultat et corrigent leurs erreurs. L’objectif n’est pas seulement de mémoriser la syntaxe de Python. Il s’agit de développer trois habitudes pratiques: lire du code, manipuler les détails de symboles peu familiers et remarquer les différences entre des lignes semblables. Un guillemet manquant peut interrompre un programme; une variable mal orthographiée peut fausser un calcul.
S’exercer avant de gagner en aisance. Shaw compare la pratique de la programmation à l’apprentissage de la guitare et du dessin: les gestes élémentaires peuvent sembler fastidieux avant de devenir naturels. Les exercices commencent par l’affichage de texte, puis introduisent progressivement les variables, les fichiers, les fonctions, la logique et les projets. La progression vise à rendre chaque nouvelle difficulté moins étrangère que la précédente.
Le livre présente la saisie comme une forme d’attention délibérée, et non comme un travail de secrétariat. Reproduire du code donne aux débutants un retour immédiat et concret sur la ponctuation et la structure, tout comme la pratique des gammes rend les gestes d’un musicien plus fiables. Mais l’imitation seule a ses limites : on peut copier avec exactitude sans comprendre pourquoi le programme fonctionne. Le livre s’attaque à ce risque au moyen d’exercices qui demandent aux lecteurs de modifier, de casser, d’expliquer et de reconstruire des exemples. Le principe utile consiste à passer de la copie à la prédiction et à la variation, afin que l’aisance devienne un tremplin vers la résolution autonome de problèmes plutôt qu’une démonstration de transcription soignée.
Apprenez à utiliser le terminal pour que fichiers, scripts et erreurs cessent d’être mystérieux.
Commencez par le cycle de travail. Avant d’écrire beaucoup de code Python, le livre fait installer aux lecteurs un éditeur de texte, un terminal et l’interpréteur. Ils créent un répertoire, y enregistrent un script, se placent dans ce répertoire, exécutent le script et vérifient le résultat. Ces étapes rendent visible le cycle fondamental: écrire un fichier, l’exécuter, examiner ce qui s’est passé et apporter une correction.
Les chemins font partie de la programmation. L’annexe enseigne des commandes pour parcourir les répertoires, lister les fichiers, les copier ou les afficher. Savoir où se trouve un script permet de comprendre pourquoi une commande peut indiquer qu’elle ne trouve pas le fichier. Les éditeurs et la version de Python cités dans le livre reflètent l’époque de sa publication, mais la compétence fondamentale est l’autonomie vis-à-vis des outils: apprendre à utiliser suffisamment le terminal pour travailler sans qu’une interface graphique fasse chaque opération à votre place.
Le terminal peut sembler être une porte d’entrée obscure, mais il révèle des mécanismes que les outils graphiques dissimulent souvent : l’emplacement actuel, les noms de fichiers, les arguments et la sortie du programme. Comprendre ces mécanismes facilite la localisation des erreurs et fournit un modèle mental transposable d’une plateforme à l’autre. L’insistance du livre à éviter les environnements de développement intégrés est plus discutable. Un éditeur simple peut réduire les distractions lors des premières leçons, mais les environnements modernes affichent aussi les valeurs des variables, la documentation et les erreurs. La leçon plus profonde n’est pas de rejeter les outils, mais de comprendre suffisamment le processus pour qu’un outil reste une aide et ne se substitue pas à la compréhension.
Déboguez en recueillant des indices, pas en fixant le code plus intensément.
Les erreurs contiennent des indices. Une erreur Python indique souvent un fichier et une ligne, affiche le code problématique et pointe vers l’endroit où se situe le problème. Par exemple, une chaîne de caractères laissée inachevée peut provoquer une erreur de syntaxe parce que Python ne trouve jamais le guillemet fermant. Le message peut être obscur, mais son emplacement et le curseur qu’il affiche réduisent le champ de recherche. La méthode proposée par le livre consiste à comparer le programme saisi à celui attendu, à vérifier les noms et la ponctuation, et, si nécessaire, à relire les lignes à l’envers ou à voix haute.
Rendez le programme observable. Lorsque la cause n’est pas claire, affichez les valeurs des variables à des endroits stratégiques, simplifiez le code ou cassez délibérément un exemple qui fonctionne pour observer ce qui change. On passe ainsi des suppositions à des questions ciblées: quelle valeur est arrivée ici, et qu’en a fait le programme?
Il s’agit d’une forme pratique de mise à l’épreuve d’hypothèses. On ne résout pas un bogue en scrutant plus intensément les mêmes éléments, mais en produisant des éléments qui permettent de distinguer les causes possibles. Afficher une variable, isoler une fonction ou ne modifier qu’une ligne à la fois transforme un échec opaque en une série d’affirmations vérifiables. Le rejet des débogueurs par le livre est trop catégorique : les outils de progression pas à pas peuvent être précieux lorsque l’apprenant sait quelle question poser. Mais l’avertissement central reste valable. Un débogueur qui affiche tout sans hypothèse directrice peut dérouter au lieu d’éclaircir.
Considérez le texte et les octets comme des représentations distinctes qu’il faut convertir.
Le texte possède un encodage. Les caractères visibles d’un programme ne sont pas stockés comme des lettres dans un ordinateur. Ils sont représentés selon des conventions communes qui associent des caractères à des nombres, et des nombres à des octets. ASCII couvre un ensemble limité de caractères; Unicode offre un répertoire bien plus vaste, et UTF-8 est un moyen courant d’encoder le texte Unicode en octets.
Convertissez délibérément. Python distingue les chaînes de texte des séquences brutes d’octets. L’encodage transforme une chaîne en octets pour le stockage ou la transmission; le décodage transforme les octets en texte selon un encodage choisi. Le livre utilise le moyen mnémotechnique DBES, qui signifie « Decode Bytes, Encode Strings » (« décoder les octets, encoder les chaînes »), et demande aux lecteurs de comparer UTF-8, UTF-16 et Big5, y compris dans les cas où un caractère ne peut pas être représenté. Une option de gestion des erreurs permet de remplacer les caractères que l’encodage choisi ne peut pas exprimer.
Cette distinction est importante, car des données peuvent traverser un programme sans que leur sens survive. Un fichier d’octets interprété avec le mauvais encodage peut afficher des caractères corrompus, même si aucun octet n’a disparu. Cet exercice illustre aussi une habitude d’ingénierie plus générale : nommer la représentation à chaque frontière au lieu de traiter toutes les données comme interchangeables. Une simplification du livre mérite d’être nuancée. Les chaînes de texte Python sont des valeurs Unicode, et non simplement des séquences d’octets UTF-8 stockées en interne. Le conseil pratique de l’exercice reste valable : expliciter l’encodage et le décodage lorsqu’on passe d’un système textuel à un système axé sur les octets.
Utilisez les fonctions pour regrouper des étapes et renvoyer des résultats, pas seulement pour les afficher.
Une fonction donne un nom à une tâche. Le livre présente la fonction comme une petite unité réutilisable qui peut recevoir des arguments. Une fonction qui affiche deux valeurs peut être appelée avec différentes données; une fonction de lecture de fichier peut recevoir un objet fichier et y lire des données. Les variables d’une fonction sont locales à cet appel, tandis que les arguments lui apportent les valeurs dont elle a besoin.
Séparez l’action du résultat. Afficher présente une information à une personne; renvoyer transmet une valeur au code qui a appelé la fonction. L’exercice d’arithmétique rend cette distinction visible: les fonctions additionnent, soustraient, multiplient ou divisent, puis renvoient le résultat afin qu’une autre expression puisse l’utiliser. Enchaîner les valeurs renvoyées permet de composer un calcul à partir d’opérations plus petites portant un nom, plus faciles à suivre qu’un bloc inexplicable.
Les fonctions créent des limites qui réduisent la quantité de code qu’un lecteur doit garder à l’esprit en même temps. Donner un nom à une unité de travail permet au programme de communiquer sa structure, tandis que les paramètres rendent cette unité utile dans plusieurs situations. La distinction entre afficher et renvoyer est particulièrement importante, car elle sépare le calcul interne du programme de sa présentation à l’utilisateur. C’est aussi un choix de conception : une fonction qui ne fait qu’afficher est plus difficile à réutiliser dans un autre contexte qu’une fonction qui renvoie des données. Les petites fonctions sont utiles, mais une fragmentation excessive peut masquer le déroulement d’ensemble ; les noms et les limites doivent donc clarifier, et non simplement se multiplier.
Suivez les décisions booléennes et l’état des boucles pour voir où va l’exécution.
Les conditions déterminent le chemin. Les expressions booléennes évaluent une condition, et un bloc `if`, `elif` ou `else` détermine quel code indenté s’exécute. Dans l’aventure textuelle du livre, un choix comme entrer par une porte mène à une autre question, puis à une autre décision. Combiner des conditions avec `and`, `or` et `not` permet au programme d’exprimer davantage qu’un simple test oui ou non.
Les boucles répètent le travail. Une boucle `for` traite les éléments d’une collection ou d’un intervalle. Une boucle `while` se répète tant que sa condition reste vraie; son état doit donc évoluer, faute de quoi le programme risque de ne jamais s’arrêter. Dans un exemple de comptage, la valeur est ajoutée à une liste, puis incrémentée. Afficher la valeur au début et à la fin de chaque passage rend le déroulement de la boucle visible.
Il est plus facile de comprendre le flux de contrôle en le traçant qu’en le considérant comme un bloc de texte. À chaque décision, demandez-vous quelle condition est vraie ; à chaque boucle, notez l’état avant et après un passage. Cela revient à suivre une démonstration : chaque étape doit découler de l’état précédent. La préférence du livre pour les boucles for lorsque le nombre d’éléments est limité constitue un bon réflexe de sécurité, car elle réduit le risque d’une boucle infinie accidentelle. Ses règles strictes concernant la structure conditionnelle sont à considérer comme un échafaudage pour débutants, et non comme une loi universelle. Les vrais programmes nécessitent parfois des branchements plus complexes qu’un choix bien ordonné à un seul niveau.
Choisissez les listes pour les séquences ordonnées et les dictionnaires pour les recherches par nom.
Les listes conservent une séquence. Une liste stocke des éléments dans un ordre donné, permet d’y accéder au moyen d’un indice numérique et s’utilise naturellement avec les boucles. Python commence l’indexation à zéro; le premier élément se trouve donc à l’indice zéro. Le livre utilise des listes pour des ensembles de mots et pour construire une séquence élément par élément avec `append`.
Les dictionnaires associent des clés à des valeurs. Un dictionnaire récupère des informations à l’aide d’une clé plutôt que d’une position. Dans l’exercice sur les États et les villes, un dictionnaire associe les noms des États à leurs abréviations, tandis qu’un autre associe les abréviations à des villes. Le programme peut suivre ces liens pour retrouver une ville à partir du nom complet d’un État. Utilisez une liste lorsque l’ordre et la position comptent; utilisez un dictionnaire lorsque la question utile est: « quelle valeur correspond à cette clé? »
Une structure de données est un choix qui détermine comment l’information sera organisée et récupérée. Les exemples du livre rendent ce choix concret : une séquence de type paquet de cartes convient à une liste, tandis qu’une recherche de type glossaire convient à un dictionnaire. Choisir une structure adaptée à la question simplifie le code qui suit. Cette distinction met aussi en lumière une limite des exemples : les informations réelles impliquent souvent plusieurs relations à la fois, qu’une seule liste ou table d’associations ne peut pas toujours représenter. Cela ne rend pas la leçon insuffisante. Elle fournit aux débutants une première question fiable : le programme va-t-il surtout parcourir les éléments dans l’ordre, ou les rechercher par identité ?
Privilégiez la composition à l’héritage, sauf si la relation est réellement de type « est-un ».
Les classes organisent des comportements apparentés. Une classe définit une sorte de chose; une instance est un objet particulier créé à partir de cette définition. Dans l’exemple `Song` du livre, on crée des objets chanson distincts, chacun contenant ses propres paroles et utilisant une méthode pour les afficher. Le livre présente aussi deux désignations de relations: « est-un » décrit une relation entre classes, comme dans « un saumon est un poisson »; « a-un » décrit une relation de composant, comme dans « une personne a un animal de compagnie ».
L’héritage partage des comportements, non sans risques. Une classe enfant peut hériter des méthodes d’une classe parent, en remplacer une ou appeler celle du parent au moyen de `super()`. La composition consiste plutôt à donner à un objet un autre objet qu’il pourra utiliser. Shaw recommande d’éviter l’héritage multiple et de privilégier la composition lorsque les éléments ne font pas véritablement partie d’une même famille.
La question de conception essentielle n’est pas de savoir quelle fonctionnalité de la programmation orientée objet paraît la plus sophistiquée, mais quelle relation le programme doit exprimer. L’héritage peut condenser le comportement commun lorsque les sous-classes peuvent réellement se substituer à leur classe parent. Une hiérarchie tentaculaire rend toutefois le comportement plus difficile à repérer et les modifications plus risquées. La composition rend les dépendances explicites et permet souvent des combinaisons plus souples, même si elle peut entraîner des délégations supplémentaires. La mise en garde du livre est utile, car les débutants peuvent confondre réutilisation du code et identité conceptuelle. Le fait que deux choses partagent un détail d’implémentation ne signifie pas automatiquement qu’elles doivent avoir une ascendance commune.
Modélisez un problème à partir de ses concepts, puis laissez un prototype fonctionnel corriger votre modèle.
Commencez en dehors du code. Pour l’aventure des Gothons, Shaw décrit d’abord l’histoire, puis en répertorie les concepts importants, tels que les scènes, une carte et un moteur. Il transforme ces concepts en une structure de classes préliminaire et recense les actions nécessaires au programme, comme entrer dans une scène ou trouver la suivante. Le code initial peut être un squelette composé de méthodes vides, suffisant pour vérifier si la structure tient la route.
Affinez dans un sens ou dans l’autre. Une conception descendante part du problème général et avance vers l’implémentation. Une conception ascendante commence par un petit élément fonctionnel, puis en dégage des concepts plus larges. Le livre présente ces deux approches comme utiles: le processus est itératif, et un sous-problème difficile peut être analysé séparément avant d’être réintégré à l’ensemble.
Le jeu des Gothons donne à l’abstraction un ancrage narratif : les salles ne sont pas simplement des classes, ce sont des lieux où le joueur se déplace, et la carte exprime les transitions possibles. Écrire et dessiner d’abord aide à révéler les hypothèses manquantes avant qu’elles ne se figent dans le code. Toutefois, extraire des noms et des verbes est une heuristique, pas une machine à concevoir automatiquement. Un nom peut désigner des données plutôt qu’un objet, et un verbe peut relever du moteur plutôt que d’une scène. La méthode la plus solide est le cycle complet proposé par le livre : décrire, modéliser, tester et réviser lorsque le programme en cours d’exécution révèle que le modèle est erroné.
Écrivez d’abord des tests qui échouent, puis gagnez en confiance à chaque petit changement.
Un test vérifie une promesse. Dans l’exemple `Room` du livre, on crée des salles, on les relie par des chemins et on vérifie que suivre une direction mène à la destination attendue. Les tests automatisés remplacent les vérifications manuelles répétées par un contrôle reproductible, qui peut être exécuté après chaque modification. Ils ne prouvent pas qu’un programme est exempt de bogues, mais ils peuvent détecter des régressions et expliciter le comportement attendu.
Progressez par petites étapes. L’exercice de tests d’abord commence par un test pour un analyseur qui classe des mots. L’apprenant ajoute un petit test, vérifie qu’il échoue en l’absence de la fonctionnalité, écrit suffisamment de code pour le faire réussir, puis recommence. Le livre recommande également d’exécuter souvent le code et de le refactoriser, c’est-à-dire d’en modifier la structure afin de le rendre plus clair ou plus utile sans perdre son comportement voulu.
Un test qui échoue est utile parce qu’il montre que le test est capable de détecter l’absence du comportement qu’il décrit. Les tests réussis fournissent ensuite un filet de sécurité limité, mais précieux, pour les révisions. Cela crée une boucle de rétroaction courte entre la spécification et l’implémentation, réduisant le coût de la découverte des malentendus. Le livre rappelle à juste titre que les tests ne détectent pas tous les défauts ; la qualité des cas de test compte, et la réussite d’exemples ne garantit pas un comportement correct pour les entrées non testées. L’importance accordée aux petites étapes est donc essentielle : les tests étayent le jugement, ils ne le remplacent pas.
Apprenez un autre langage en recréant des programmes familiers, en lisant du code et en réalisant quelque chose.
Un livre n’est qu’un début. Les exercices vont d’un premier message affiché à l’écran à une aventure textuelle, un squelette de projet, des tests automatisés et une petite application Web Flask. Cette progression montre comment assembler les notions élémentaires de Python pour produire un artefact plus important: un navigateur envoie une requête, une route la traite, puis une réponse ou un modèle est renvoyé au navigateur. Les formulaires et les sessions prolongent le même projet en y ajoutant la saisie interactive et l’état du jeu.
Continuez en pratiquant. La méthode d’apprentissage proposée par Shaw consiste à suivre un cours d’introduction, à saisir et exécuter ses exemples, à prendre des notes, à créer de petits programmes familiers et à lire le code d’autres personnes. La documentation et la recherche font partie du travail. L’objectif n’est pas de tout maîtriser immédiatement, mais d’acquérir des bases suffisantes pour entreprendre seul un autre projet ou découvrir un nouvel outil.
La meilleure façon de conclure est pratique plutôt que fondée sur des titres ou des diplômes : le débutant repart avec une méthode pour continuer à apprendre. Recréer un programme familier dans un nouveau langage permet de vérifier si les concepts ont été transférés, tandis que la lecture du code d’autres personnes révèle des conventions que les tutoriels peuvent omettre. Les exercices de jeu Web montrent aussi pourquoi la programmation ne se résume pas à la syntaxe : elle relie les choix de l’utilisateur, l’état stocké, le comportement du serveur et le résultat visible. La métaphore de la « ceinture noire » employée dans le livre ne doit pas être prise pour une promesse d’expertise. Le véritable acquis est la capacité d’un débutant à apprendre la couche suivante, notamment à reconnaître ce qu’il ne sait pas encore.
Analyse
Il vaut mieux considérer ce livre comme un cours consacré aux habitudes à acquérir quand on débute, enseigné à travers Python, plutôt que comme un ouvrage de référence compact sur le langage. Sa structure est cumulative et repose sur des exercices: on commence par mettre en place un environnement de travail, puis on s’exerce à de petites expressions, avant de les combiner dans des programmes faisant intervenir un état, des embranchements, des structures de données, des objets, des tests et une interface web. Le jeu final des Gothons donne à cette progression technique une destination sous forme de récit. Le lecteur commence par afficher une ligne et termine en réfléchissant à la manière dont un navigateur, un serveur, une carte et les choix d’un utilisateur peuvent former un même système.
L’idée pédagogique centrale est que l’aisance dans les gestes de base rend l’abstraction moins intimidante. En tapant à plusieurs reprises des signes de ponctuation et en observant la réponse de l’interpréteur, les débutants acquièrent un vocabulaire concret pour aborder les concepts ultérieurs. Le livre renforce cette démarche par des variations délibérées: les lecteurs doivent prédire les résultats, casser des programmes, examiner les erreurs et suivre les valeurs. Cette alternance entre imitation et diagnostic est plus efficace qu’une explication passive, car elle rend l’apprenant responsable de la production d’éléments probants.
Cette méthode comporte aussi des tensions. La répétition peut devenir mécanique si elle ne favorise pas le transfert des acquis, et des règles de configuration rigides peuvent faire des préférences en matière d’outils une source de distraction. Certains conseils reflètent le contexte de 2017, notamment Python 3.6, Atom et le paquet de tests nose. Il ne faut pas prendre ces détails pour des recommandations intemporelles. Les principes qui durent sont plus généraux: adopter un flux de travail simple et compréhensible, exécuter tôt de petits morceaux de code, lire les erreurs comme des informations et automatiser les vérifications lorsque leur répétition devient fastidieuse.
Le traitement de la conception orientée objet dans le livre est délibérément provisoire. Ses analogies aident à établir un vocabulaire, tandis que sa mise en garde contre l’héritage incite à la retenue. La leçon plus générale n’est pas qu’un style de programmation l’emporte toujours, mais que les structures doivent clarifier les relations et faciliter les changements. De même, les exercices ne font pas de quelqu’un un programmeur professionnel. Ils offrent un solide point de départ: suffisamment de syntaxe, de modèles mentaux et de pratique de l’apprentissage pour créer quelque chose de modeste, l’examiner et poursuivre.
Résumé des avis
Learn Python 3 the Hard Way reçoit des avis mitigés. Beaucoup le trouvent utile aux débutants et apprécient son approche pratique ainsi que l’importance accordée à la pratique du codage. Son style direct et sa présentation approfondie des notions de base sont appréciés. Cependant, certains critiquent le ton condescendant de l’auteur et la hausse brutale du niveau de difficulté vers la fin. Les lecteurs remarquent que, si le livre est bon pour apprendre la syntaxe, il n’est peut-être pas idéal pour comprendre des concepts plus complexes. Le caractère dépassé de certains contenus et le manque d’explications sur certains sujets sont également mentionnés parmi ses défauts.
Les lecteurs ont aussi lu
Glossaire
enseignement
suite d’exercices pour développer une compétenceDans le livre, l’enseignement désigne une suite d’exercices contrôlés qui développe une compétence par la pratique répétée. Dans cette approche, les apprenants reproduisent d’abord de petits exemples, puis les expliquent, les modifient et les combinent. L’objectif est d’acquérir une aisance de base avant de demander aux débutants de résoudre des problèmes de programmation plus complexes.
DBES
décoder les octets, encoder les chaînesDBES est le moyen mnémotechnique du livre pour se rappeler deux conversions de texte : décoder des octets pour obtenir une chaîne, et encoder une chaîne pour obtenir des octets. Il sert lorsque le texte Python doit être converti pour être stocké, transmis ou interprété selon un encodage de caractères donné. Ce moyen mnémotechnique rappelle le sens de la conversion ; il ne décrit pas tous les détails internes des chaînes Python.
relation « est-un »
relation d’héritage entre classesL’expression « est-un » décrit une relation dans laquelle une classe est un type plus spécifique d’une autre. Dans l’exemple du livre, un saumon est un poisson. En Python, cette relation est généralement représentée par l’héritage : une classe enfant peut utiliser le comportement défini par une classe parente. La relation doit refléter les concepts modélisés, et non simplement offrir une occasion de réutiliser du code.
relation « a-un »
relation de composant ou d’attributL’expression « a-un » décrit une relation dans laquelle un objet contient un autre objet, y fait référence ou l’utilise comme l’une de ses parties. Le livre l’illustre par l’exemple d’une personne qui a un animal de compagnie. Cette relation se distingue de l’héritage : la personne n’est pas un type d’animal de compagnie. Ces relations mènent souvent à la composition, dans laquelle un objet délègue une tâche à un autre.
composition
construire un comportement à partir de composantsLa composition organise un programme en faisant appel à des objets ou à des modules pour effectuer des tâches. Au lieu d’hériter du comportement d’une classe parente, un objet contient un composant et appelle ses fonctions. Le livre présente la composition comme un moyen de réutiliser du code dans des situations sans lien entre elles et comme une solution de remplacement à l’héritage lorsqu’il n’existe pas de véritable relation « est-un ».
conception descendante
passer d’une idée abstraite à sa mise en œuvreUne démarche de conception descendante part d’une description générale d’un problème et la transforme progressivement en concepts, relations, classes, fonctions et code exécutable. Dans l’exemple de jeu du livre, la personne qui conçoit le jeu décrit l’aventure, détermine les scènes et le moteur, esquisse leurs relations, puis crée une structure fonctionnelle. Le processus peut revenir en arrière lorsque la mise en œuvre révèle des informations manquantes.
conception ascendante
passer du code fonctionnel à l’abstractionUne démarche de conception ascendante part d’un petit morceau de code qui résout tout juste une partie d’un problème. La personne qui programme le perfectionne, le teste, détermine les concepts qu’il mobilise et l’intègre progressivement à une conception plus vaste. Le livre oppose cette démarche au fait de partir d’une vue d’ensemble abstraite, tout en considérant les deux approches utiles à différentes étapes de la résolution de problèmes.
tests d’abord
tester avant la mise en œuvreLes tests d’abord sont une méthode de programmation qui consiste à écrire un test décrivant le comportement souhaité avant le code qui le fournit. L’apprenant exécute le test pour confirmer qu’il échoue en l’absence de la fonctionnalité, met en œuvre une petite modification, puis répète le cycle. Le livre utilise cette démarche pour construire un analyseur de mots et souligne qu’il faut résoudre une tâche importante par petites étapes vérifiables.
refactorisation
restructurer sans changer la finalitéLa refactorisation consiste à modifier du code existant pour en améliorer l’organisation ou la clarté tout en préservant le comportement attendu. Dans le livre, un jeu d’aventure antérieur est remanié pour obtenir une structure qui peut être testée et exécutée dans une application web. Les tests automatisés aident à vérifier que les changements apportés à la structure interne n’ont pas altéré le comportement attendu du programme.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.