Vision

Pour qualifier davantage la pensée informatique, Al Aho du département d'informatique de l'Université Columbia décrit la pensée informatique comme « les processus de pensée impliqués dans la formulation de problèmes afin que leurs solutions puissent être représentées comme des étapes de calcul et des algorithmes ». Jeannette Wing, également de l'Université Columbia, a mis en évidence l'idée de pensée informatique dans un article qu'elle a écrit en 2006 alors qu'elle était à l'Université Carnegie Mellon. Elle estime que la pensée informatique détaille les actes mentaux nécessaires pour calculer une solution à un problème, que ce soit par des actions humaines ou par une machine. La pensée informatique englobe un ensemble de méthodes et d'approches pour résoudre (et acquérir les compétences pour résoudre) des défis complexes, étroitement alignées sur la pensée mathématique par son utilisation de l'abstraction, de la généralisation, de la modélisation et de la mesure (Figure 2.2). Cependant, elle se différencie en étant plus clairement consciente que les mathématiques seules de sa capacité de calcul et des avantages potentiels qu'elle offre.

Figure 2.2 Ce diagramme illustre les principales composantes de la pensée informatique. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

La pensée critique est une compétence importante qui peut aider à la pensée informatique. Elle se résume à comprendre les concepts plutôt qu'à simplement maîtriser les détails techniques pour utiliser des logiciels, en privilégiant la compréhension à l'apprentissage par cœur. C'est une compétence essentielle, et non un fardeau supplémentaire sur une liste de contrôle de programme, et elle implique uniquement les humains, et non les ordinateurs, en mélangeant la résolution de problèmes et la pensée critique. La pensée critique se concentre sur les idées, et non sur des éléments tangibles, en appliquant une pensée avancée pour concevoir des solutions. La pensée critique est essentielle pour tous et est comparable aux capacités fondamentales comme la lecture, l'écriture et l'arithmétique.

Concepts de la pensée informatique

La description fournie par la Société internationale pour la technologie en éducation (ISTE) (International Society for Technology in Education) décrit les composants clés et les dispositions de la pensée informatique. Explorons chaque caractéristique plus en détail :

• Décomposition : Le processus analytique de décomposition de concepts ou de problèmes complexes en parties plus petites est appelé décomposition (decomposition). Cette approche aide à analyser et à résoudre les problèmes plus efficacement.
• Reconnaissance de formes (pattern recognition) (organisation et analyse logique des données) : La pensée informatique met l'accent sur l'organisation et l'analyse logique des données. Cela inclut la capacité à structurer l'information de manière à faciliter une résolution de problèmes efficace.
• Représentation des données par des abstractions : Une abstraction (abstraction) est une représentation simplifiée de systèmes ou de phénomènes complexes. La pensée informatique implique de représenter les données par une abstraction, telle qu'une simulation, qui utilise des modèles comme substituts de systèmes réels.
• Automatisation par la pensée algorithmique : L'utilisation d'un programme ou d'une application informatique pour effectuer des tâches ou des calculs répétitifs est considérée comme de l'automatisation (automation).
• Identification, analyse et mise en œuvre de solutions : La pensée informatique met l'accent sur l'identification, l'analyse et la mise en œuvre de solutions potentielles pour atteindre une efficacité et une efficience optimales grâce à une combinaison d'étapes et de ressources.
• Généralisation et transférabilité : La généralisation et le transfert de ce processus de résolution de problèmes à une grande variété de problèmes démontrent l'adaptabilité et l'applicabilité de la pensée informatique.

Ces capacités sont soutenues et enrichies par des capacités fondamentales intégrales à la pensée informatique. Ces capacités impliquent les caractéristiques suivantes : la confiance dans la navigation de la complexité, la résilience face aux problèmes difficiles, l'acceptation de l'ambiguïté, l'habileté à aborder les problèmes ouverts et la compétence à collaborer avec d'autres pour atteindre des objectifs ou des solutions partagés. Une autre illustration de la pensée informatique est les trois A, qui est organisée en trois phases, comme visualisé dans la Figure 2.3 :

1. Abstraction : La première étape implique la formulation du problème.
2. Automatisation : Ensuite, l'accent est mis sur l'expression de la solution.
3. Analyse : Enfin, le processus englobe l'exécution et l'évaluation de la solution.

Figure 2.3 Les trois A—abstraction, automatisation, analyse—illustrent la puissance de la pensée informatique. (source photo : modification de « Avalanche on Everest » par Chagai/Wikimedia Commons, Domaine public ; source graphique : modification de « Slope stability calculation for a model landslide » par B. Terhost et Bodo Damm/Journal of Geological Research, CC BY)

Techniques de pensée informatique

Dans le monde technologique d'aujourd'hui, la maîtrise des techniques de pensée informatique est importante. Ces techniques offrent un moyen systématique de résoudre des problèmes en utilisant des outils comme les structures de données, qui sont comme des conteneurs utilisés pour organiser et stocker les données efficacement dans un ordinateur. Elles définissent comment les données sont logiquement arrangées et manipulées, facilitant ainsi l'accès et le travail avec l'information dans les algorithmes et les programmes. Il existe quatre techniques clés de la pensée informatique, comme illustré dans la Figure 2.4 :

• La décomposition est un concept fondamental de la pensée informatique, représentant le processus de décomposition systématique d'un problème ou d'un système complexe en parties ou sous-problèmes plus petits et plus gérables. En décomposant la complexité en éléments plus simples, la décomposition favorise une approche plus organisée de la résolution de problèmes.
• La pensée logique et la reconnaissance de formes est une technique de pensée informatique qui implique le processus d'identification des similitudes entre et au sein des problèmes. Cette technique de pensée informatique met l'accent sur la capacité à reconnaître des structures, des relations ou des séquences récurrentes dans diverses situations de résolution de problèmes.
• L'abstraction est une technique de pensée informatique qui se concentre sur les informations importantes tout en ignorant les détails non pertinents. Cette technique permet une compréhension plus claire des problèmes fondamentaux.
• Les algorithmes sont comme des ensembles détaillés d'instructions pour résoudre un problème étape par étape. Ils aident à décomposer des tâches complexes en actions gérables, assurant un chemin clair vers la résolution de problèmes.

Figure 2.4 Les utilisateurs peuvent explorer l'essence de la pensée informatique à travers la décomposition, la pensée logique, l'abstraction et les algorithmes. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

En plus des quatre techniques, la pensée informatique implique des étapes essentielles telles que les tests et le débogage. Les tests sont cruciaux pour découvrir les erreurs dans les instructions étape par étape ou les algorithmes employés pour résoudre un problème. D'autre part, le débogage (debugging) implique l'identification et la rectification des problèmes dans le code.

Un programmeur est quelqu'un qui écrit des instructions pour qu'un ordinateur les suive. Un exemple typique est celui d'un programmeur qui donne des instructions à un robot et lui dit de faire un sandwich à la confiture. Dans ce cas, l'application de techniques informatiques pour donner des instructions au robot implique les techniques suivantes : décomposition, pensée logique et reconnaissance de formes, abstraction et algorithmes. Ces techniques sont expliquées dans les sous-sections suivantes telles qu'elles s'appliquent à l'exemple du sandwich à la confiture.

Décomposition

La décomposition implique de résoudre un problème complexe en le divisant en tâches plus petites et plus gérables. La décomposition permet de prendre en compte divers composants essentiels pour résoudre une tâche apparemment complexe, ce qui permet de la redéfinir en un problème plus gérable. Dans le cas de l'exemple du sandwich à la confiture, la décomposition implique d'identifier tous les ingrédients requis et les étapes que le robot doit suivre pour créer avec succès un sandwich à la confiture.

Pensée logique et reconnaissance de formes

La reconnaissance de formes permet de regrouper toutes les différentes caractéristiques considérées dans la décomposition en catégories. Dans l'exemple du sandwich à la confiture, la reconnaissance de formes conduit à regrouper les diverses choses identifiées par la décomposition en catégories, dans ce cas, les ingrédients, l'équipement et les actions. Par conséquent, l'application de la décomposition et de la reconnaissance de formes conduira à penser à autant de choses que possible qui sont nécessaires pour faire un sandwich à la confiture. Plus il y a de choses auxquelles on peut penser (c'est-à-dire les ingrédients, l'équipement et les actions), plus les instructions seront claires. Une première tentative de décomposition et de reconnaissance de formes est résumée dans le Tableau 2.1.

Le processus d'identification des modèles nécessite généralement une pensée logique telle que le raisonnement inductif ou déductif. Le raisonnement inductif permet de passer d'exemples spécifiques à des principes généraux. Par exemple, reconnaître que diviser n'importe quel nombre par 1 donne le nombre original conduit à la conclusion plus large qui est vraie pour n'importe quel nombre. De même, comprendre que la somme de deux nombres impairs donne un nombre pair conduit à la généralisation que l'ajout de deux nombres impairs donne toujours un nombre pair. Le raisonnement inductif transforme une observation en un modèle, ce qui permet de formuler une hypothèse provisoire qui peut être transformée en théorie. Le raisonnement déductif est le processus de tirer des conclusions valides à partir de prémisses étant donné qu'il n'est pas possible que les prémisses soient vraies et la conclusion fausse. Un exemple traditionnel illustre comment les prémisses « tous les hommes sont mortels » et « Socrate est un homme » mènent à la conclusion déductivement correcte que « Socrate est mortel ».

Abstraction

L'abstraction permet de dégager les détails importants et d'identifier des principes qui s'appliquent à d'autres problèmes ou situations. Lors de l'application de l'abstraction, il peut être utile de prendre des notes ou de dessiner des diagrammes pour aider à comprendre comment résoudre le problème. Dans l'exemple du sandwich à la confiture, l'abstraction signifie se faire une idée de ce à quoi le sandwich devrait ressembler. Pour appliquer l'abstraction ici, vous créeriez un modèle ou dessineriez une image représentant l'apparence finale du sandwich à la confiture une fois qu'il est fait. Cela simplifie les détails, offrant une image plus claire du résultat souhaité. Des outils simples comme le programme Windows Paint (Windows Paint program) peuvent être utilisés pour ce faire, comme le montre la Figure 2.5.

Figure 2.5 Cet exemple d'abstraction du sandwich à la confiture illustre à quoi le produit final devrait ressembler. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

En technologie, les données sont représentées à différents niveaux d'abstraction pour simplifier l'interaction de l'utilisateur et gérer efficacement des opérations complexes. Les utilisateurs interagissent avec une application web via une interface simple, comme demander de l'aide à un outil GenAI, sans voir la complexité sous-jacente. Cette invite GenAI (GenAI) est ensuite traitée par la logique de l'application, qui la valide et la dirige de manière appropriée, souvent de manière invisible pour l'utilisateur. Enfin, au niveau du dorsal, l'invite est traitée et une réponse générée par GenAI est fournie. Chaque couche d'abstraction remplit un rôle distinct, rendant l'ensemble du processus efficace à la fois pour l'utilisateur et pour le système (Figure 2.6).

Figure 2.6 Lors de l'utilisation de GenAI, un utilisateur interagit avec l'interface tandis que l'application traite l'invite avec des couches d'abstraction sur le dorsal. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Algorithme

Un algorithme est une séquence d'étapes/d'instructions qui doivent être suivies dans un ordre spécifique pour résoudre un problème. Les algorithmes permettent de décrire une solution à un problème en écrivant les instructions nécessaires pour le résoudre. Les programmes informatiques exécutent généralement des algorithmes pour effectuer certaines tâches. Dans l'exemple du sandwich à la confiture, la technique de l'algorithme consiste à écrire des instructions que le robot peut suivre pour faire le sandwich à la confiture. Comme vous l'apprendrez dans le Chapitre 3 Structures de données et algorithmes, les algorithmes sont le plus souvent écrits sous forme de pseudo-code ou d'organigramme. Une ébauche de la logique des algorithmes utilisant une combinaison de langage et de concepts de programmation de haut niveau est appelée pseudo-code (pseudocode). Chaque étape est présentée dans une structure écrite clairement ordonnée. Un organigramme (flowchart) montre clairement le flux et la direction des décisions de manière visuelle à l'aide d'un diagramme. L'une ou l'autre méthode convient, et c'est une question de préférence personnelle. Des modèles de base pour l'organigramme et le pseudo-code se trouvent dans la Figure 2.7.

Figure 2.7 Le pseudo-code liste chaque étape, tandis qu'un organigramme décrit visuellement le processus de prise de décision. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

L'écriture d'algorithmes demande de la pratique. Tout le monde n'aime pas le beurre dans son sandwich à la confiture. Le robot a besoin d'une méthode pour s'assurer qu'il ajoute ou n'ajoute pas de beurre, selon les préférences. Il est donc nécessaire de tenir compte des étapes suivantes dans le pseudo-code et l'organigramme :

1. Demander s'il doit y avoir du beurre sur le pain.
2. Soit étaler du beurre sur le pain,
3. Soit ne pas utiliser de beurre.

Ces étapes peuvent être ajoutées comme actions dans le tableau précédemment montré et exprimées comme des étapes dans le pseudo-code en utilisant des mots-clés de programmation tels que INPUT, OUTPUT, IF, THEN, ELSE et START. Les instructions correspondantes peuvent ensuite être converties en un organigramme en utilisant les symboles de la Figure 2.8.

Figure 2.8 Les symboles utilisés dans un organigramme sont associés à leurs instructions. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Modèles de patrons d'exécution d'algorithmes

Divers modèles de patrons d'exécution peuvent être utilisés pour parcourir les instructions fournies dans un algorithme. Jusqu'à présent, nous n'avons considéré que le modèle d'exécution séquentiel traditionnel (c'est-à-dire étape par étape) pour les instructions d'algorithme. Cependant, il est également possible de tirer parti du parallélisme/de la concurrence et de la récursivité comme modèles alternatifs pour piloter l'exécution des instructions des algorithmes.

Les modèles d'exécution parallèle/concurrentielle sont généralement utilisés pour optimiser l'efficacité de l'exécution des algorithmes. Par exemple, si vous et un ami achetez des billets pour un film et qu'il y a trois files d'attente indépendantes, vous pouvez opter pour un modèle d'exécution de traitement parallèle en vous faisant rejoindre, vous et votre ami, deux files d'attente distinctes pour acheter les billets. Dans ce cas, vous êtes assuré de pouvoir obtenir les billets plus rapidement en supposant que l'une des files d'attente fonctionnant en parallèle avec l'autre finit par servir les clients plus rapidement, ce qui est le plus souvent le cas. Notez que l'exécution simultanée du même algorithme sur un ordinateur peut ne pas être possible si vous n'avez qu'une seule unité centrale de traitement dans votre machine. Dans ce cas, vous pouvez simuler le parallélisme en faisant exécuter les deux algorithmes concurremment par le système d'exploitation de la machine en tant que tâches distinctes tout en partageant les ressources du processeur unique. Cette approche est moins efficace que le vrai parallélisme. Plus de détails sur les différences entre la concurrence et le parallélisme seront fournis dans le Chapitre 4 Réalisation linguistique des algorithmes : langages de programmation de bas niveau.

Les modèles d'exécution récursifs offrent une autre alternative élégante et efficace au modèle d'exécution séquentiel traditionnel. La technique de résolution de problèmes où un processus s'appelle lui-même afin de résoudre des instances plus petites du même problème est appelée récursivité (recursion). C'est un outil puissant en programmation car il permet des solutions élégantes à des problèmes complexes en les décomposant en parties plus petites et plus gérables. En tirant parti de la récursivité, les programmeurs peuvent écrire du code concis et efficace pour résoudre un large éventail de problèmes.

L'un des principaux avantages de la récursivité est sa capacité à gérer des tâches complexes avec un minimum de code. Au lieu d'écrire de longues boucles itératives pour résoudre des tâches répétitives, la récursivité permet aux programmeurs de définir un processus qui s'appelle lui-même avec des paramètres d'entrée modifiés, réduisant ainsi efficacement la quantité de code nécessaire. Cependant, il est essentiel d'être prudent lors de l'utilisation de la récursivité, car une implémentation incorrecte peut entraîner des erreurs de débordement de pile en raison d'appels de processus excessifs. Les programmeurs doivent s'assurer que les processus récursifs ont des cas de base appropriés pour terminer la récursivité et éviter les boucles infinies. Exemple :

#include <iostream>
using namespace std;

    
int recursiveSum (int x) {
  // Base case
  if (x == 0) {
    return 0;
  } else {
    // Recursive step
    return x + recursiveSum (x - 1);
  }
}
int main() {
  cout << recursiveSum (10);
  // Answer is 55
  return 0;
}

Dans ce scénario, le processus implique d'ajouter progressivement des valeurs à la variable totale au fur et à mesure que vous itérez dans une boucle. Cependant, une approche différente consiste à tirer parti de la pensée informatique pour déconstruire le problème, en le décomposant en sous-composants plus petits. Cette méthode aborde ces sous-composants individuellement pour résoudre le problème global. Lorsque ces petites parties représentent des versions réduites du problème original, la récursivité devient un outil précieux.

Dans des scénarios pratiques, la récursivité se manifeste souvent comme une fonction (function), qui est un ensemble de commandes pouvant être exécutées de manière répétée. Elle peut accepter une entrée et peut renvoyer une sortie. Le cas de base représente l'opération la plus simple de la fonction pour une entrée donnée. Pour implémenter efficacement la récursivité, deux étapes principales doivent être suivies : (a) identifier le cas de base, et (b) décrire les étapes récursives. Dans le contexte d'une fonction récursive, lorsque n est 0, la somme cumulative de 0 à 0 est intuitivement 0, représentant le sous-problème le plus fondamental du problème principal. Fort de ce cas de base, vous pouvez commencer à élaborer la partie initiale de la fonction.

int recursiveSum (int x)
{
  // Base case
  if (x == 0)
    return 0;
}

La récursivité fonctionne par un processus de simplification, réduisant progressivement la valeur de x jusqu'à ce qu'elle atteigne la condition de base, où x est égal à 0. Cette technique présente une méthode alternative, offrant une solution algorithmique raffinée et efficace pour le problème actuel :

#include <iostream>
using namespace std;

    
int recursiveSum (int x) {
  // Base case
  if (x == 0) {
    return 0;
  }
  else {
    // Recursive step
    return x + recursiveSum (x - 1);
  }
}
int main() {
cout << recursiveSum(10); // Output will be the sum = 55.
  return 0;
}

Bien qu'il semble que la récursivité consiste à appeler la même fonction de manière répétée, ce n'est que partiellement vrai, et il ne faut pas l'envisager de cette manière. Ce qui se passe est bien plus que la répétition de l'appel d'une fonction. Il est plus utile de la considérer comme une chaîne d'opérations différées. Ces opérations différées ne sont pas visibles dans votre code ou votre sortie, elles sont en mémoire. Le programme doit les conserver d'une manière ou d'une autre pour pouvoir les exécuter à la fin. En fait, si vous n'aviez pas spécifié le cas de base, le processus récursif ne se terminerait jamais. La Figure 2.9 illustre un organigramme pour une solution itérative qui additionne N nombres.

Figure 2.9 Un organigramme représente une solution itérative pour l'addition de N nombres. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Concepts en pratique

La pensée informatique pour la résolution de problèmes d'échecs

Les ordinateurs peuvent nous aider à résoudre des problèmes. Cependant, avant de pouvoir aborder un problème, le problème lui-même et la manière dont il pourrait être résolu doivent être compris. La pensée informatique transcende la simple programmation ; elle n'équivaut pas à penser de manière binaire comme les ordinateurs, car ils manquent fondamentalement de capacité de pensée. Au contraire, alors que la programmation est l'art d'instruire un ordinateur sur les actions à exécuter, la pensée informatique vous permet de déterminer méticuleusement quelles devraient être ces instructions. Prenez, par exemple, le jeu stratégique impliqué dans les échecs. Pour exceller dans une partie d'échecs, un joueur doit :

• Comprendre les mouvements uniques et les valeurs stratégiques de chaque pièce, en reconnaissant comment chacune peut être manœuvrée pour contrôler l'échiquier.
• Visualiser la disposition de l'échiquier, identifier les menaces et les opportunités potentielles, et planifier les coups plusieurs étapes à l'avance pour assurer une position avantageuse.
• Reconnaître les modèles des parties précédentes, comprendre les tactiques et les contres courants, pour formuler une stratégie robuste et adaptable.

Dans l'élaboration d'une stratégie gagnante, la pensée informatique est le cadre sous-jacent :

• Le jeu complexe est disséqué en composants plus petits et plus gérables (par exemple, la fonction de chaque pièce d'échecs, l'état de l'échiquier) — c'est la décomposition.
• L'attention est concentrée sur les éléments pivots qui influencent le résultat du jeu, tels que le positionnement des pièces clés et les tendances de l'adversaire, en mettant de côté les facteurs moins critiques — c'est une abstraction.
• En s'appuyant sur les connaissances et les expériences antérieures dans des scénarios similaires, une approche étape par étape est développée pour naviguer dans le jeu — c'est la pensée algorithmique.

Si vous vous aventurez à développer votre propre programme ou stratégie d'échecs, ce sont précisément les types de considérations sur lesquelles vous délibéreriez et que vous résoudriez avant la programmation réelle.

Tests et débogage

Les tests et le débogage sont des techniques utilisées pour identifier les défauts dans les algorithmes et les défauts dans le code afin de pouvoir les corriger. Les cas de test reposent sur la fourniture de données d'entrée spécifiques pour vérifier si un programme logiciel fonctionne correctement et répond à ses exigences de conception. Les cas de test doivent être identifiés pour piloter les tests. Si un test associé à un cas de test échoue, un débogage doit être effectué pour identifier la source du problème et le corriger. En d'autres termes, le débogage consiste à localiser et à corriger les défauts (c'est-à-dire les bogues) dans les algorithmes et les processus pour qu'ils se comportent comme prévu. En programmation, tout le monde fait des erreurs, elles font partie du processus d'apprentissage. L'important est d'identifier l'erreur et de trouver comment la surmonter. Il y a ceux qui pensent que l'apprentissage le plus profond a lieu lorsque des erreurs sont commises.

Dans l'algorithme du sandwich à la confiture, les tests peuvent être facilités en jouant tour à tour le rôle du programmeur qui donne les instructions ainsi que celui du robot. Si vous êtes programmeur, votre travail consiste à lire les instructions et à suivre chaque étape. Vous pouvez choisir de suivre votre pseudo-code ou votre organigramme. Chaque instruction devient un cas de test, et le test réussit si le robot peut suivre chaque instruction exactement et avec succès. Dans le cas contraire, vous devrez déboguer l'instruction pour identifier la source du problème et le corriger. Le Tableau 2.2 peut être utilisé pour enregistrer les problèmes rencontrés et les améliorations à apporter.