Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Think Like a Programmer

Think Like a Programmer

Transformez des problèmes de programmation inconnus en étapes vérifiables, puis construisez des solutions que vous pouvez expliquer.
par V. Anton Spraul 2012 233 pages
3.87
500+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérer la programmation comme la résolution de problèmes, et non comme un exercice de mémorisation de la syntaxe

Connaître le code, ce n’est pas créer du code. Les étudiants de Spraul comprenaient souvent les exemples et les règles du langage, mais restaient bloqués lorsqu’on leur demandait d’écrire un programme original. Ce qui leur manquait, c’était la capacité à résoudre des problèmes: transformer une tâche en un programme qui respecte ses contraintes. Lire du code ressemble à apprendre à connaître les ingrédients et les ustensiles de cuisine; programmer, c’est les associer pour créer quelque chose que la recette ne précisait pas. La syntaxe compte, mais elle ne fournit pas de méthode pour décider quoi construire.

Exercez-vous à l’étape créative. Le livre s’intéresse aux méthodes systématiques qui permettent d’explorer un problème, de mettre à l’épreuve différentes approches et de construire une solution à partir de techniques familières. Ses exercices ne sont pas de simples compléments facultatifs: lire une méthode ne remplace pas le fait de l’appliquer à une nouvelle tâche.

Analyse

Cette distinction est utile bien au-delà de la programmation. La reconnaissance donne une impression de maîtrise parce qu’il est facile de suivre des exemples familiers, mais se rappeler et construire exigent un travail différent. Un apprenant capable d’expliquer une solution déjà achevée peut néanmoins ne pas savoir comment en produire une. Le geste pédagogique le plus fort du livre consiste à rendre cet écart explicite, plutôt qu’à le traiter comme une épreuve de talent. Les exemples en C++ sont un véhicule, pas la leçon. Cela dit, les méthodes systématiques ne rendent pas toutes les tâches faciles ; elles facilitent l’examen de l’incertitude et réduisent le risque de la confondre avec une incapacité.

Établir les contraintes et les actions autorisées avant de choisir une solution

Obtenir un résultat ne suffit pas. Spraul définit la résolution de problèmes en programmation comme la création d’un programme qui effectue la tâche demandée tout en respectant chacune des contraintes énoncées. Un programme qui ne fonctionne que pour une petite entrée, ou qui ignore la plateforme imposée, n’est pas une solution valable. Il appelle une telle fausse victoire un Kobayashi Maru, empruntant le nom d’un test fictif dont les règles semblent impossibles à respecter. Contourner une contrainte peut sembler ingénieux tout en laissant le véritable problème sans solution.

Rendre le problème explicite. Dans l’énigme de la traversée de la rivière, un fermier doit faire passer un renard, une oie et du maïs sans laisser ensemble des éléments qui se mettraient en danger. L’action autorisée qu’on oublie est de ramener l’oie. Dresser la liste des contraintes et des opérations possibles fait apparaître cette possibilité. Une énigme complexe mettant en scène une serrure extraterrestre se réduit aux mêmes relations, une fois débarrassée de son récit distrayant.

Analyse

C’est une forme concrète de rigueur dans la spécification. Écrire les actions autorisées et les états interdits transforme une intuition vague en quelque chose que l’on peut vérifier, discuter et mettre en œuvre. Les contraintes peuvent restreindre l’espace de recherche plutôt que simplement faire obstacle. Il faut toutefois garder à l’esprit que les spécifications elles-mêmes peuvent être incomplètes ou contradictoires ; leur formalisation doit donc s’accompagner de questions sur les ambiguïtés restantes. L’énigme du fermier le montre élégamment : on peut oublier une action autorisée simplement parce que l’énoncé ne la met pas en évidence.

Décomposer la tâche jusqu’à ce que chaque étape suivante puisse être testée

On peut progresser pas à pas. Une grande tâche devient plus facile lorsqu’on la divise en petits éléments ou qu’on la réduit provisoirement à une version plus simple. Pour produire un triangle de symboles, Spraul commence par résoudre le cas d’une ligne, puis d’un carré, avant d’ajuster la longueur des rangées. Chaque résultat devient un élément de base testé. Pour un casse-tête à tuiles coulissantes, il place une rangée ou une colonne complète et traite le reste du plateau comme un casse-tête plus petit, au lieu d’essayer de prévoir tous les déplacements d’un coup.

Planifiez aussi la recherche. Un plan n’a pas besoin de prévoir chaque obstacle. Il peut préciser quoi tester en premier, quel résultat partiel constituera un progrès et quoi réviser si une approche échoue. Commencer par un élément que l’on comprend déjà permet de prendre de l’élan et peut révéler comment l’élément inconnu devrait fonctionner.

Analyse

La décomposition réduit à la fois la complexité technique et le coût émotionnel d’une tâche. Un petit test fournit rapidement un retour, ce qui rend moins coûteuse la correction d’une hypothèse erronée. Cela rappelle la conception expérimentale : isoler un facteur incertain au lieu de modifier plusieurs choses à la fois. Il y a néanmoins une limite. Une division du travail mal pensée peut produire des éléments qui fonctionnent chacun de leur côté, mais pas ensemble. Une décomposition utile explique clairement comment chaque partie contribue au comportement final.

Commencer par la partie qui admet le moins de réponses possibles

Les contraintes peuvent guider votre premier geste. Au Sudoku, une case qui n’admet qu’un seul chiffre légal constitue un meilleur point de départ qu’une case offrant de nombreuses possibilités. Spraul rapproche cela de la règle de la variable la plus contrainte: lorsqu’on attribue des valeurs sous contraintes, on s’attaque à la variable qui dispose du moins de choix. Une région de trois cases sur trois presque complète peut imposer un chiffre, qui réduit alors les possibilités dans sa ligne et sa colonne.

Servez-vous des problèmes résolus comme de cartes. La serrure extraterrestre devient abordable lorsqu’on compare ses interactions réelles à celles de l’énigme du renard, de l’oie et du maïs. La ressemblance peut ne concerner qu’une partie d’une tâche, mais cela peut tout de même faire gagner du travail. De petites expériences aident également à en révéler la structure: Spraul élabore une méthode pour le casse-tête à tuiles en jouant sur un plateau réduit, puis applique cette découverte à des plateaux plus grands.

Analyse

Choisir l’élément le plus contraint est une stratégie de recherche, pas seulement une astuce de Sudoku. Cela permet de repérer tôt les contradictions, avant d’avoir investi des efforts dans des choix qui se révéleront ensuite impossibles. L’analogie offre un raccourci complémentaire : elle permet de transposer une structure, pas nécessairement une réponse complète. Le danger est de forcer une ressemblance alors que les règles importantes diffèrent. Une bonne comparaison consiste à se demander quelles relations sont préservées et lesquelles ne le sont pas, plutôt qu’à se fier à une ressemblance superficielle ou à un vocabulaire familier.

Construire du code complexe à partir d’expériences isolées, et non de suppositions optimistes

Transformez l’incertitude en petit test. Le problème du chiffre de contrôle de Luhn consiste à lire un nombre de longueur inconnue caractère par caractère, à doubler un chiffre sur deux, puis à vérifier si le total est divisible par dix. Plutôt que d’essayer de tout résoudre d’un coup, Spraul isole les sous-tâches: convertir un caractère représentant un chiffre en entier, traiter les valeurs doublées et détecter la fin de l’entrée. Comme le double d’un chiffre de zéro à neuf ne dépasse jamais dix-huit, il est facile de tester séparément la règle qui consiste à additionner les chiffres.

Gardez ouvertes les deux possibilités. Le programme ne peut pas connaître la longueur du nombre avant la fin de la saisie, alors que cette longueur détermine quels chiffres doivent être doublés. Il maintient donc deux totaux de contrôle cumulés, un pour chaque parité, et choisit celui qui convient à la fin. Une expérience réfléchie met une hypothèse à l’épreuve; modifier le code au hasard ne fait que miser sur la chance.

Analyse

La solution des deux sommes de contrôle est un exemple concis de décision différée jusqu’à l’arrivée des éléments nécessaires. On retrouve le même principe dans d’autres domaines dès qu’un choix initial dépend d’informations qui ne seront disponibles que plus tard : préserver les possibilités, les mettre à jour à mesure que les données arrivent, puis choisir. Les petits programmes de test servent aussi d’instruments pour se familiariser avec une interface inconnue. Leur intérêt ne tient pas seulement à l’obtention d’un extrait de code fonctionnel, mais aussi au fait qu’ils consignent ce que le programmeur a effectivement vérifié.

Choisir les structures de données en fonction des opérations requises, et non par habitude

Commencez par ce qu’exige le travail. Les tableaux offrent un accès aléatoire par indice, mais leur taille est fixe. Les vecteurs peuvent s’agrandir, tandis que les listes chaînées permettent une insertion efficace en tête, mais exigent un parcours séquentiel. Le bon choix dépend des opérations et des limites de taille imposées par la tâche, pas de la structure que l’on connaît le mieux.

Laissez les données façonner la méthode. Pour trouver la réponse la plus fréquente à un sondage lorsque les réponses vont de un à dix, on peut trier et compter les séries de réponses identiques, mais un histogramme est plus direct. Il conserve un compteur pour chaque réponse possible; un seul parcours permet ensuite de repérer le compteur le plus élevé. Si les réponses arrivent une à une et qu’il n’est pas nécessaire de les consulter à nouveau, le programme peut mettre à jour l’histogramme immédiatement au lieu de stocker chaque réponse. On évite ainsi de consommer inutilement de l’espace et du temps.

Analyse

C’est une forme utile et quotidienne de pensée algorithmique : décrire la charge de travail avant de choisir l’outil. Aucune structure n’est efficace dans l’absolu ; son efficacité dépend de ce qu’elle doit faire, de la fréquence à laquelle elle doit le faire et de l’échelle concernée. L’histogramme convient particulièrement bien parce que l’éventail des valeurs est petit et connu. Si cet éventail était immense ou ouvert, cette même représentation risquerait de gaspiller de l’espace. Les exemples du livre incitent à adapter la représentation aux contraintes, au lieu de considérer une structure comme universellement supérieure.

Représenter la propriété de la mémoire dynamique avant de modifier les pointeurs

Rendez visible la mémoire invisible. Une chaîne de caractères allouée dynamiquement peut nécessiter un tableau de remplacement plus grand lorsqu’on lui ajoute un caractère. Le programme doit en déterminer la longueur, copier les anciens caractères, ajouter le nouveau et un caractère de terminaison, puis libérer l’ancienne allocation. Un schéma permet de suivre le bloc auquel renvoie chaque pointeur et ceux qu’il faut libérer. Sans cette représentation, une modification qui semble mineure peut provoquer une fuite de mémoire ou une référence pendante.

Vérifiez les cas limites. Les listes chaînées grandissent nœud par nœud. L’insertion en tête évite de parcourir toute la liste, tandis que la suppression d’un nœud exige de reconnecter son prédécesseur, avec un traitement distinct lorsque le premier nœud est supprimé. Le cas d’une liste vide compte aussi. Le code fondé sur les pointeurs devient plus facile à raisonner lorsque chaque allocation, chaque lien et chaque durée de vie sont explicitement pris en compte.

Analyse

Les schémas externalisent une charge mentale que la mémoire de travail gère mal : plusieurs pointeurs peuvent changer alors que les données auxquelles ils renvoient restent invisibles. Ce n’est pas qu’une béquille pour débutants ; visualiser la propriété et l’état peut aussi éclaircir des systèmes complexes. Cette discipline est particulièrement précieuse lors d’une suppression, car un pointeur peut rester syntaxiquement valide tout en renvoyant à une mémoire qui n’appartient plus au programme. Les abstractions modernes peuvent réduire cette charge, mais elles ne suppriment pas la nécessité de comprendre la durée de vie et la propriété.

Utiliser les classes pour masquer une implémentation cohérente, et non pour déguiser des variables globales

Regroupez ce qui va ensemble. Une classe peut réunir des données et des opérations liées, offrir une interface claire et tenir les détails d’implémentation à l’écart du code client. Un dossier étudiant, par exemple, peut protéger son champ de note et valider les modifications par l’intermédiaire de méthodes. Une classe de collection peut masquer les pointeurs de sa liste chaînée, afin que les utilisateurs ajoutent, recherchent ou suppriment des dossiers sans manipuler eux-mêmes les nœuds.

La mémoire dynamique augmente les enjeux. Une classe qui possède une liste chaînée doit libérer ses nœuds lorsqu’elle est détruite et effectuer de véritables copies lorsqu’on la duplique. Une copie superficielle ne duplique que le pointeur de tête, ce qui fait que deux objets partagent une même liste; une modification ou une suppression de nœuds effectuée par l’un peut alors endommager l’autre. Les classes aident à contenir cette complexité, mais une classe qui ne fait que rassembler des fonctions sans rapport entre elles ou un état de type global constitue une fausse abstraction, pas une bonne conception.

Analyse

Le masquage de l’information est précieux parce qu’il donne au programme une frontière stable : les clients dépendent des garanties d’un objet, non de la façon dont celui-ci stocke ses données. Cette frontière permet aussi de modifier l’implémentation sans devoir changer le code partout. Mais masquer ne doit pas revenir à dissimuler des compromis importants. Une collection fondée sur une liste chaînée et une collection fondée sur un tableau ont des propriétés différentes en matière d’accès et de croissance, et les clients peuvent s’en soucier. Une bonne abstraction masque les détails accessoires tout en rendant lisibles le comportement essentiel et les limites.

Faire confiance à l’appel récursif pour résoudre le problème réduit

Définissez d’abord le cas le plus simple. La récursivité consiste pour une fonction à s’appeler elle-même sur un problème réduit, jusqu’à atteindre un cas auquel elle peut répondre directement. Pour calculer la somme d’un tableau, la somme d’un tableau vide vaut zéro; sinon, on ajoute la dernière valeur à la somme de toutes les valeurs précédentes. La grande idée récursive de Spraul consiste à traiter cet appel récursif comme un auxiliaire fiable, sans suivre chaque appel à la trace pendant la conception de l’appel en cours.

Adaptez la récursivité à la structure. Une liste chaînée se divise naturellement en son premier nœud et le reste. Un arbre binaire se divise en une racine, un sous-arbre gauche et un sous-arbre droit. La récursivité peut clarifier les parcours à embranchements, surtout lorsqu’une version itérative aurait besoin d’une pile distincte pour mémoriser où reprendre. Pour les simples parcours vers l’avant, une boucle est généralement plus simple. Une fonction enveloppe peut transmettre les données privées de l’arbre à une fonction auxiliaire récursive.

Analyse

Le changement essentiel consiste à ne plus imaginer le déroulement d’un appel, mais à définir son contrat : quelle question plus petite il résout et comment sa réponse aide à résoudre le problème en cours. C’est une forme de raisonnement compositionnel, qui consiste à comprendre un système à partir de ses éléments fiables. La récursivité n’est toutefois pas intrinsèquement élégante ou efficace. Les chaînes d’appels profondes peuvent consommer beaucoup de mémoire de pile, et les tâches linéaires simples n’ont souvent pas besoin de mécanisme récursif. Le bon choix dépend de la mesure dans laquelle la structure du problème justifie la surcharge due aux appels.

Réutiliser des modèles que l’on comprend, et non du code que l’on ne sait pas expliquer

Empruntez des concepts, puis appropriez-vous-les. Spraul distingue la réutilisation maîtrisée, qui développe les compétences et produit du code que le programmeur comprend, de la copie qui contourne l’apprentissage et peut échouer au moment des modifications. Un algorithme décrit une méthode, un patron de conception propose une structure réutilisable, un type de données abstrait spécifie des opérations et une bibliothèque fournit des composants déjà implémentés. Chacun fait économiser une quantité différente de travail et offre un degré de flexibilité différent.

Renseignez-vous avant de vous en remettre à un outil. Pour permettre aux clients de parcourir efficacement une liste étudiante privée, le livre emprunte l’idée de l’itérateur aux bibliothèques standard et construit un petit itérateur doté d’opérations permettant de commencer le parcours, d’avancer, de vérifier si l’on est à la fin et de récupérer l’enregistrement courant. Une fois son fonctionnement compris, utiliser un itérateur de bibliothèque relève d’une réutilisation éclairée, et non d’une copie aveugle. Le même principe s’applique lorsqu’on adapte un programme existant ou qu’on apprend à utiliser une nouvelle bibliothèque.

Analyse

Comprendre la réutilisation comme un continuum évite deux extrêmes néfastes : réinventer chaque outil ou traiter le code emprunté comme de la magie. Une bibliothèque bien choisie peut améliorer la fiabilité et faire gagner du temps, tandis qu’un patron conceptuel peut s’adapter plus précisément à une exigence inhabituelle. Le bon niveau dépend des délais, de la flexibilité et du besoin d’apprendre du programmeur. Reconstruire un petit composant peut être utile pour le comprendre, mais reproduire une infrastructure éprouvée pour le seul principe risque de faire perdre du temps.

Élaborer un processus de travail personnel à partir de ses habitudes récurrentes de programmation

Adaptez le processus au programmeur. La dernière méthode du livre consiste à établir un plan directeur personnel à partir de ses forces et faiblesses récurrentes. Une personne qui omet les tests peut les inscrire comme étape obligatoire; celle qui surconçoit peut limiter le temps consacré à la conception; un apprenant rapide peut se réserver du temps pour découvrir des outils inconnus. Il ne s’agit pas d’adopter un processus de travail universel, mais de repérer les tendances dans ses propres erreurs et de les compenser délibérément.

Réalisez un prototype de ce qui est inconnu. Dans le projet final du pendu, le programme triche en conservant tous les mots candidats et en choisissant chaque réponse de façon à préserver le groupe restant le plus nombreux. Spraul commence par tester une version rudimentaire, puis envisage une meilleure structure et une meilleure interface. L’exemple réunit reformulation, expérimentation, décomposition et réutilisation. Pour acquérir ces méthodes, entraînez-vous avec des exercices et de petits projets avant de compter sur elles sous pression.

Analyse

Un processus de travail personnel transforme la connaissance de soi en pratique d’ingénierie. Au lieu d’espérer devenir plus prudent, un programmeur peut concevoir des points de contrôle qui favorisent la prudence ; au lieu de combattre chacune de ses faiblesses par la seule volonté, il peut organiser son processus pour les contourner. Le prototype du pendu tricheur montre aussi pourquoi une première version fonctionnelle est importante : elle fournit un point de comparaison concret pour les remaniements ultérieurs. Un prototype ne prouve toutefois pas la qualité. Il doit encore être testé au regard de toutes les exigences et affiné sans abandonner discrètement certaines contraintes.

Analyse

Think Like a Programmer est moins un catalogue d’astuces en C++ qu’un apprentissage de la manière de gérer l’incertitude. Son geste récurrent consiste à transformer une tâche opaque en quelque chose d’observable: énumérer les contraintes, nommer les opérations, isoler les inconnues, construire un petit cas et le tester. Les énigmes rendent la méthode mémorable, tandis que les exemples de programmation montrent que le même raisonnement résiste au changement de sujet, des boucles d’affichage à la propriété de la mémoire, à la conception des classes et aux parcours récursifs.

L’affirmation pédagogique la plus profonde du livre est que la compétence se construit en produisant des solutions, et non en se contentant de les reconnaître. C’est pourquoi les exemples s’arrêtent souvent avant le code, et pourquoi les exercices comptent davantage qu’une familiarité passive. Le lecteur est encouragé à conserver les programmes intermédiaires, à considérer les approches infructueuses comme des éléments d’information et à utiliser les analogies comme des passerelles entre problèmes connus et inconnus. La confiance naît de l’accumulation de tentatives réussies, pas d’un don mystérieux pour la programmation.

Cette approche a une limite importante. Un plan clair ne garantit pas de solution lorsque les exigences sont contradictoires, que le temps manque ou que le problème est irréalisable sur le plan du calcul. Le texte, qui insiste sur la résolution individuelle des problèmes, ne représente pas non plus pleinement le développement collaboratif, où les exigences évoluent et où les décisions de conception doivent faire l’objet d’une négociation. Les mécanismes du C++ rendent également certaines leçons particulièrement explicites, notamment la durée de vie et la copie des pointeurs, tandis que d’autres langages dissimulent ces détails derrière des abstractions. La méthode générale demeure transposable: comprendre ce qui doit être vrai, choisir des représentations adaptées aux opérations nécessaires et tester rapidement ses hypothèses.

L’exemple final du pendu convient parfaitement à cette démonstration. Le programme devient plus habile à tricher non pas en devinant un mot secret, mais en reformulant son objectif: préserver autant de mots candidats que possible. Ce changement de perspective résume toute la méthode: une tâche difficile peut devenir abordable dès lors que sa véritable structure est rendue visible. Penser comme un programmeur, c’est apprendre à trouver cette structure, une étape testée à la fois.

Résumé en 30 secondes
La compétence en programmation vient de la production de solutions, et non de la simple reconnaissance de la syntaxe ou d’exemples. Explicitez les contraintes et les opérations autorisées, puis divisez la tâche en petites parties que vous pouvez tester. Commencez par les choix les plus contraints et isolez les incertitudes au moyen d’expériences avant de combiner les éléments. Choisissez les structures de données en fonction des opérations requises. Représentez la propriété de la mémoire avant de modifier les pointeurs, utilisez la récursion lorsqu’un problème comporte des versions plus petites de lui-même, et adaptez votre méthode de travail aux erreurs qui se répètent.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

3.87 sur 5
Moyenne de 500+ évaluations de Goodreads et Amazon.

Think Like a Programmer reçoit des avis partagés, avec une note moyenne de 3,86 sur 5. Les lecteurs apprécient son approche axée sur la résolution de problèmes et ses exercices, qu’ils jugent utiles pour développer des compétences en programmation. Certains saluent les explications de l’auteur et considèrent l’ouvrage comme une ressource précieuse pour les débutants. Toutefois, ses détracteurs estiment que la place accordée au C++ en limite l’accessibilité, et certains trouvent le contenu trop élémentaire ou trop académique. L’accent mis sur le raisonnement logique et la décomposition des problèmes est généralement bien accueilli, même si les avis divergent quant à son efficacité auprès des programmeurs expérimentés.

Votre note :
4.4
367 évaluations
Envie de lire le livre complet ?

Glossaire

Kobayashi Maru

Une fausse solution qui enfreint des contraintes

Terme employé par Spraul pour désigner un programme qui semble résoudre une tâche, mais enfreint une ou plusieurs contraintes énoncées. Il fait référence à un scénario fictif d’entraînement de Starfleet, que l’on peut réussir en modifiant ses règles. En programmation, cette appellation met en garde contre le fait de prendre pour une véritable solution un contournement qui élude une exigence.

le train (the train)

Une technique de rotation de tuiles coulissantes

Méthode mise au point par Spraul pour les casse-têtes à tuiles coulissantes. Une suite de positions de tuiles comprenant l’espace vide peut être déplacée en boucle, tout en préservant l’ordre relatif des tuiles. Cette méthode aide à positionner des groupes de tuiles et permet de résoudre progressivement un plateau en complétant une ligne ou une colonne, puis en considérant le reste comme un casse-tête plus petit.

variable la plus contrainte

Choisir celle qui a le moins d’options légales

Règle applicable aux problèmes sous contraintes, qui recommande d’attribuer en premier une valeur à la variable ayant le moins de valeurs possibles. Au Sudoku, cela signifie examiner une case n’ayant que très peu de chiffres légaux avant d’en traiter une qui offre beaucoup de possibilités. Résoudre une partie fortement contrainte peut imposer d’autres choix et révéler rapidement des contradictions.

le roi de la colline (King of the Hill)

Garder en mémoire la meilleure valeur trouvée

Technique récurrente de traitement de tableaux permettant de trouver une valeur extrême ou le meilleur candidat. On conserve dans une variable la meilleure valeur rencontrée jusque-là, on examine chaque nouvel élément et on remplace le candidat actuel lorsque le nouveau est meilleur. Cette même structure permet de suivre un maximum, un minimum ou la position du meilleur candidat.

résolution par étude d’un cas concret

Suivre une entrée concrète étape par étape

Méthode de conception du code qui consiste à choisir une entrée représentative, à noter son état pertinent et à suivre la manière dont chaque opération devrait la transformer en résultat attendu. Spraul la recommande particulièrement pour le code utilisant des pointeurs, car des schémas peuvent montrer les allocations, les liens et les désallocations que les variables ordinaires ne rendent pas visibles.

grande idée récursive (Big Recursive Idea)

Faire confiance à la réponse récursive pour le problème plus petit

Méthode de Spraul pour concevoir des fonctions récursives : traiter directement le cas le plus simple, puis supposer qu’un appel récursif répond correctement à la même question pour un problème plus petit. Utiliser cette réponse, ainsi que l’élément ou la structure en cours, pour résoudre le cas d’origine. Cela évite d’essayer de suivre mentalement chaque appel imbriqué pendant la conception.

fonction enveloppe

Adapter une interface à une fonction auxiliaire

Fonction qui prépare l’appel à une autre fonction dont les paramètres ne correspondent pas à l’interface souhaitée par le client. Dans les méthodes récursives d’une classe, une fonction enveloppe publique peut transmettre des données privées, comme le pointeur vers la racine d’un arbre, à une fonction récursive auxiliaire privée. Le client dispose ainsi d’une méthode simple sans accéder aux détails de l’implémentation.

réutilisation maîtrisée

Une réutilisation qui approfondit la compréhension

Utilisation du travail d’un autre programmeur d’une manière qui étend les capacités tout en préservant la compréhension. Cela peut consister à mettre en œuvre un algorithme à partir de sa description, à appliquer un patron ou à utiliser du code que le programmeur sait expliquer et modifier. Spraul oppose cette approche à la copie de code comme raccourci : elle peut fonctionner au départ, mais laisse le programmeur incapable de diagnostiquer le code ou de l’étendre sans risque.

patron de l’itérateur

Parcourir une collection sans exposer son stockage

Patron de conception qui permet au code client d’accéder séquentiellement à une collection sans en révéler la représentation interne. Un itérateur désigne l’élément courant, passe au suivant, indique la fin du parcours et donne accès à la valeur courante. Il permet un parcours efficace tout en gardant privés les liens ou le stockage sous-jacents de la collection.

FAQ

De quoi parle Think Like a Programmer de V. Anton Spraul ?

  • La résolution de problèmes au premier plan : Le livre enseigne aux programmeurs une approche créative et systématique de la résolution de problèmes, plutôt que la simple syntaxe du code ou les fonctionnalités d’un langage.
  • Le C++ comme outil pédagogique : Le C++ sert d’exemple, mais les stratégies et les concepts de résolution de problèmes s’appliquent à tous les langages de programmation.
  • Un contenu complet : L’ouvrage couvre aussi bien les notions fondamentales de programmation (tableaux, pointeurs, classes) que des sujets avancés comme la récursion, la mémoire dynamique et les patrons de conception.
  • Un objectif de transformation : Le but ultime est d’aider les lecteurs à devenir des personnes capables de résoudre les problèmes de manière autonome et avec assurance, et d’écrire des programmes originaux à partir de rien.

Pourquoi lire Think Like a Programmer de V. Anton Spraul ?

  • Développer un état d’esprit axé sur la résolution de problèmes : Le livre traite de la compétence souvent manquante qui consiste à résoudre de nouveaux problèmes de programmation, et non simplement à lire ou modifier du code existant.
  • Une méthode d’apprentissage structurée : Il propose des techniques et des stratégies systématiques pour organiser ses idées, décomposer les problèmes et gagner en assurance.
  • Développer des compétences durables : Les lecteurs apprennent à concevoir des programmes robustes, à éviter les pièges courants et à réfléchir de manière critique à la réutilisation du code et aux décisions de conception.
  • Des exercices pratiques : Le livre propose des exercices concrets qui aident à assimiler les concepts et à acquérir une véritable assurance en programmation.

Quels sont les principaux enseignements de Think Like a Programmer de V. Anton Spraul ?

  • Toujours avoir un plan : L’accent est mis sur la planification avant de coder, afin d’éviter la frustration et les efforts sans direction.
  • Reformuler et décomposer les problèmes : Les diviser en parties plus petites et plus faciles à gérer, puis les reformuler, peut faire apparaître des solutions plus simples.
  • Chercher des analogies : Repérer les ressemblances avec des problèmes déjà résolus accélère la recherche de solutions.
  • La pratique donne confiance : Une pratique systématique et la réalisation d’exercices contribuent à renforcer l’assurance nécessaire pour relever de nouveaux défis de programmation.

Comment Think Like a Programmer de V. Anton Spraul définit-il et enseigne-t-il la résolution créative de problèmes en programmation ?

  • Une approche créative et systématique : La programmation est présentée comme une activité créative, et le livre propose des méthodes systématiques pour stimuler cette créativité.
  • Des casse-têtes classiques comme outils pédagogiques : Des casse-têtes comme celui du renard, de l’oie et du maïs, les tuiles coulissantes et le Sudoku servent à illustrer des stratégies de résolution de problèmes.
  • L’accent sur l’expérimentation : Les lecteurs sont encouragés à expérimenter, à s’appuyer sur ce qu’ils savent et à tirer des enseignements d’essais contrôlés.
  • Gérer la frustration : Le livre souligne l’importance de gérer sa frustration pour conserver une pensée claire et résoudre les problèmes efficacement.

Quelles sont les stratégies de résolution de problèmes les plus importantes dans Think Like a Programmer de V. Anton Spraul ?

  • Toujours avoir un plan : Même si le plan évolue, en avoir un évite de travailler sans but et aide à fixer des objectifs intermédiaires.
  • Reformuler et décomposer : Reformuler clarifie la compréhension, et décomposer les problèmes réduit souvent leur complexité de façon exponentielle.
  • Commencer par ce que l’on connaît : S’appuyer sur ses compétences existantes et mener de petites expériences pour mieux comprendre, notamment avec des API ou des comportements inconnus.
  • Chercher des analogies : Établir des parallèles avec des problèmes déjà résolus peut mener à des solutions plus rapides et plus efficaces.

Comment Think Like a Programmer de V. Anton Spraul utilise-t-il le C++ pour enseigner la résolution de problèmes ?

  • Des connaissances de base en C++ sont présupposées : Le livre s’attend à ce que les lecteurs connaissent la syntaxe et la sémantique élémentaires du C++, et se concentre plutôt sur les compétences en résolution de problèmes.
  • Des exemples de code lisibles : Le code est écrit dans un souci de clarté et de compréhension, et les étapes complexes sont souvent décomposées.
  • Pas un recueil de recettes : L’accent est mis sur l’acquisition de compétences adaptables en résolution de problèmes, et non sur la mémorisation de recettes ou d’algorithmes.
  • Un apprentissage actif : Les lecteurs sont encouragés à faire eux-mêmes les exercices pour assimiler les concepts.

Comment Think Like a Programmer de V. Anton Spraul explique-t-il les tableaux et leur utilisation pour résoudre des problèmes ?

  • Les bases des tableaux : L’ouvrage traite du stockage, de la copie, de la récupération, de la recherche et du tri de données au moyen de tableaux.
  • Techniques de résolution de problèmes : Il présente des stratégies comme le tri avant la recherche du mode et l’utilisation d’histogrammes pour compter les fréquences.
  • Quand utiliser des tableaux : Il aborde les situations où les tableaux conviennent, par exemple lorsque la taille est connue ou qu’un accès aléatoire est nécessaire.
  • Des solutions autres que les tableaux : Il présente les vecteurs et les listes lorsque la taille des données est inconnue ou qu’un accès séquentiel est préférable.

Qu’enseigne Think Like a Programmer de V. Anton Spraul sur les pointeurs et la gestion dynamique de la mémoire ?

  • Les bases des pointeurs : L’ouvrage passe en revue la déclaration des pointeurs, leur déréférencement, l’allocation dynamique de mémoire (new/delete) et l’affectation.
  • Les avantages des pointeurs : Il explique comment les pointeurs permettent de créer des structures de données dont la taille est déterminée à l’exécution ou peut varier, ainsi que de partager efficacement la mémoire.
  • Les pièges de la gestion de la mémoire : Il aborde la mémoire de pile et la mémoire de tas, la fragmentation, les fuites de mémoire et les pointeurs pendants.
  • Résoudre des problèmes à l’aide de pointeurs : Il propose des exemples comme les tableaux dynamiques pour les chaînes de longueur variable et les listes chaînées pour les collections.

Comment Think Like a Programmer de V. Anton Spraul présente-t-il les classes et la programmation orientée objet ?

  • Les bases des classes : L’ouvrage passe en revue les déclarations de classes, les variables membres, les spécificateurs d’accès et les constructeurs.
  • Encapsulation et masquage de l’information : Il insiste sur la mise en privé des données et sur l’exposition des seules méthodes nécessaires à une conception robuste.
  • Une conception lisible : Il encourage à choisir des noms clairs et à structurer le code de façon à le rendre facile à comprendre et à maintenir.
  • Des exemples pratiques : Il construit une classe studentRecord à partir d’une structure, puis y ajoute la validation et des constructeurs pour illustrer les principes de la programmation orientée objet.

Quels conseils pratiques Think Like a Programmer de V. Anton Spraul donne-t-il pour concevoir et utiliser des classes ?

  • Encapsulation : Garder les données privées et ne fournir que les méthodes d’accès nécessaires pour protéger les détails de l’implémentation.
  • Diviser pour régner : Utiliser les classes pour décomposer les problèmes complexes en unités faciles à gérer et réutilisables.
  • Lisibilité et expressivité : Choisir des noms de méthodes et des structures de classes qui rendent le code intuitif pour les utilisateurs et les personnes chargées de sa maintenance.
  • Tests et validation : Toujours tenir compte des cas limites et valider les entrées dans les méthodes de la classe afin d’assurer sa robustesse.

Comment Think Like a Programmer de V. Anton Spraul explique-t-il la récursion et le raisonnement récursif ?

  • La grande idée récursive (BRI) : Il enseigne que l’on peut considérer les appels récursifs comme des appels à une autre fonction, ce qui simplifie la conception de solutions récursives.
  • Récursion en tête et récursion terminale : Il explique leur différence et s’appuie sur des analogies tirées de situations réelles pour préciser quand utiliser chacune.
  • Erreurs courantes : Il met en garde contre l’usage d’un trop grand nombre de paramètres et de variables globales dans la récursion.
  • Une structure naturellement adaptée aux structures de données : Il montre que la récursion convient bien aux structures dynamiques comme les listes chaînées et les arbres binaires.

Quels sont les pièges et les erreurs les plus courants signalés dans Think Like a Programmer de V. Anton Spraul ?

  • Les fausses classes : Il met en garde contre les classes qui se contentent d’encapsuler des variables globales ou qui imposent la programmation orientée objet là où elle n’est pas adaptée.
  • Les données redondantes : Il souligne que stocker des données que l’on peut déduire d’autres données entraîne des incohérences et des bogues.
  • Les copies superficielles et les fuites de mémoire : Il explique les dangers de la copie superficielle d’objets contenant de la mémoire dynamique et l’importance de mettre en œuvre une copie profonde.
  • La récursion inutilement compliquée : Il déconseille les paramètres et les variables globales inutiles dans les fonctions récursives, qui peuvent rendre le code plus difficile à comprendre et à maintenir.

Quelles sont les meilleures citations de Think Like a Programmer de V. Anton Spraul et que signifient-elles ?

  • « Commences-tu déjà à penser comme un programmeur ? » — Résume l’objectif du livre : faire des lecteurs des personnes capables de résoudre les problèmes de manière créative et efficace.
  • « Ayez toujours un plan. » — Souligne qu’il est nécessaire de planifier avant de coder pour éviter la frustration et produire des solutions robustes.
  • « Les données redondantes sont une source de problèmes en puissance. » — Met en garde contre le stockage de données inutiles, qui peut provoquer des incohérences et des bogues.
  • « Si vous suivez certaines conventions dans votre code, vous pouvez faire comme si aucune récursion n’avait lieu. » — Encourage à simplifier le raisonnement récursif en considérant les appels récursifs comme des appels à d’autres fonctions.
  • « Les fausses classes font que le programme présente tous les mêmes défauts qu’un programme utilisant des variables globales. » — Souligne l’importance d’une bonne conception des classes pour tirer parti de la programmation orientée objet.

À propos de l'auteur

V. Anton Spraul est un programmeur informatique et auteur connu pour ses travaux sur l’enseignement des concepts de programmation. Il possède une vaste expérience en développement logiciel et s’est attaché à aider les débutants à comprendre les fondamentaux de la programmation. Son approche met l’accent sur la résolution de problèmes et le raisonnement logique plutôt que sur le simple apprentissage de la syntaxe. Il estime qu’il est important de savoir décomposer les problèmes complexes en éléments plus faciles à gérer. Spraul a écrit d’autres livres et articles sur la programmation, dans le but de rendre ces concepts accessibles à un large public. Son style d’écriture est décrit comme captivant et parfois humoristique, même si certains lecteurs le trouvent parfois condescendant.

Télécharger le PDF

Pour garder le résumé de Think Like a Programmer pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Think Like a Programmer sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...