Tout comprendre à l’informatique : du processeur au quantique de A à Z

L’informatique est souvent apprise par morceaux : un peu de matériel ici, quelques algorithmes là, puis une pincée de réseaux et de bases de données. Résultat : on retient des définitions, mais on peine à voir le tout. Une meilleure façon de comprendre, c’est de la considérer comme une pile de couches, où chaque niveau s’appuie sur celui du dessous.

Dans l’esprit d’un parcours visuel popularisé par Dr. Ashish Bamania, voici une visite guidée des briques électroniques jusqu’aux techno émergentes.

1) Les portes logiques : l’alphabet de la machine

Tout commence par un concept ultra simple : deux états. Sur un ordinateur, ce “oui/non” est matérialisé par le transistor, un interrupteur électronique miniature capable de basculer des milliards de fois par seconde. On traduit ces états en binaire :

état actif → 1
état inactif → 0

En combinant des transistors, on construit des portes logiques : de petits circuits qui appliquent des règles booléennes à des entrées binaires pour produire une sortie binaire.

Les principales portes à connaître :

AND : sortie à 1 uniquement si toutes les entrées valent 1
OR : sortie à 1 si au moins une entrée vaut 1
NOT : inverse le bit (0 devient 1, 1 devient 0)
NAND : inverse de AND (seule la configuration “tout à 1” donne 0)
NOR : inverse de OR (seule la configuration “tout à 0” donne 1)
XOR : 1 si les entrées sont différentes
XNOR : 1 si les entrées sont identiques
et le buffer (tampon), utile pour répéter/amplifier/isoler un signal sans le modifier

Fait fascinant : certaines portes sont dites universelles, car on peut reconstruire toutes les autres à partir d’elles. Deux candidates célèbres : NAND et NOR. Autrement dit, même un ordinateur “monstrueux” peut, en théorie, être assemblé à partir d’un seul type de porte universelle.

Petite anecdote historique : l’Apollo Guidance Computer s’appuyait massivement sur des circuits intégrés basés sur des NOR à 3 entrées — preuve qu’avec des briques simples, on peut viser la Lune.

2) Le CPU : la couche “cerveau” faite de logique

Un processeur n’est pas magique : c’est une grande composition de circuits qui implémentent ces opérations élémentaires. Dans les grandes lignes, on retrouve :

ALU (Arithmetic Logic Unit) : calcule (addition, soustraction, etc.) et compare (égal, supérieur, inférieur…)
Registres : mini-zones mémoire très rapides intégrées au CPU, utilisées pour stocker des valeurs temporaires et suivre l’exécution
Unité de contrôle (CU) : “chef d’orchestre” qui récupère les instructions en mémoire, les interprète et coordonne la circulation des données

Le tout permet d’exécuter des milliards d’instructions par seconde, en enchaînant lecture d’instruction → décodage → exécution → écriture du résultat.

3) La machine de Turing : ce que “calculer” veut dire

Avant d’empiler les abstractions logicielles, il y a une question de fond : qu’est-ce qu’un calcul ?

En 1936, Alan Turing propose un modèle théorique devenu central : la machine de Turing. Elle se résume à :

un ruban (conceptuellement infini) découpé en cases, contenant des symboles
une tête de lecture/écriture qui se déplace à gauche/droite
un ensemble de règles déterminant l’action à effectuer selon l’état courant et le symbole lu

Même si aucun ruban n’est réellement infini, cette idée formalise un point clé : un problème complexe peut être résolu par une suite d’opérations simples, si on a assez de temps et de mémoire.

Dans la foulée, la thèse “Church-Turing” (souvent évoquée dans ce contexte) suggère que tout ce qui est calculable par un procédé mécanique peut l’être par ce type de machine — et donc, en pratique, par un ordinateur généraliste.

4) Langages, compilateurs, interprètes : parler humain, exécuter machine

Écrire directement en 0 et 1 serait un cauchemar. Les langages de programmation servent d’interface entre nos intentions et les instructions exécutables par le CPU.

Pour passer du code source aux instructions machine, deux approches dominantes :

Les compilateurs

Ils transforment un programme entier en binaire exécutable avant l’exécution. Résultat : performances élevées, car la traduction est faite “en amont”. En contrepartie, il faut souvent recompiler selon la plateforme et après chaque modification importante.

Exemples typiques : C, C++, Rust, Go.

Les interprètes

Ici, le code est lu et exécuté à la volée, instruction par instruction, sans générer forcément un exécutable autonome. Gros avantage : lancement immédiat et portabilité plus simple. Limite classique : c’est souvent plus lent qu’un binaire compilé, car la traduction accompagne l’exécution.

Exemples : Python, JavaScript, Ruby.

5) Structures de données : ranger l’information pour la manipuler vite

Dès qu’on code un peu sérieusement, tout tourne autour de la manière de stocker et accéder aux données. Quelques incontournables :

Tableau (array) : mémoire contiguë, accès indexé rapide, mais redimensionnement/insertion coûteux
Liste chaînée : éléments reliés par pointeurs, insertion/suppression facile, accès direct plus lent
Pile (stack) : logique LIFO (dernier entré, premier sorti)
File (queue) : logique FIFO (premier entré, premier sorti)
Table de hachage (hash table) : paires clé/valeur, recherche/insertion/suppression proches du temps constant dans de bonnes conditions
Arbre (tree) : structure hiérarchique avec une racine, des parents et des enfants
Graphe (graph) : nœuds + arêtes, parfait pour représenter réseaux, dépendances, relations
Tas (heap) : arbre binaire complet respectant une propriété min-heap ou max-heap (le plus petit ou le plus grand élément “remonte” à la racine)

6) Algorithmes : la recette, indépendante du matériel

Un algorithme, c’est une procédure finie d’étapes pour résoudre un problème, en s’appuyant sur des structures de données. Il ne dépend pas d’un langage particulier : on peut l’exprimer en pseudo-code, en Python, en C… le principe reste identique.

Un bon algorithme vise généralement :

justesse (bon résultat pour toutes les entrées valides)
efficacité (temps et mémoire raisonnables)
lisibilité (comprendre, déboguer, maintenir)
terminaison (il doit finir, pas tourner à l’infini)

Trois familles très courantes :

a) La récursion

Une fonction se résout en appelant une version plus petite du même problème, jusqu’à atteindre un cas de base (simple à traiter). Classique pour les arbres, certains calculs (factorielle), ou des explorations de graphes (DFS).

b) Les tris

Mettre des éléments dans un ordre donné (croissant/décroissant). Il existe une galaxie de méthodes, du simple au très optimisé.

c) La recherche binaire

Sur un tableau trié, on divise l’espace de recherche par deux à chaque étape : c’est beaucoup plus rapide que parcourir tout le tableau.

7) La notation Big-O : prédire comment ça “scale”

Quand l’entrée grossit, combien de temps ça prend ? Et combien de mémoire ça consomme ? La notation Big-O sert à décrire ces croissances.

Exemples fréquents côté temps :

O(1) : accès direct (par index, ou table de hachage dans l’idéal)
O(log n) : recherche binaire
O(n) : parcours simple
O(n log n) : tris efficaces type merge sort / heapsort
O(n²) : tris naïfs type bubble sort
O(2ⁿ) : explosion combinatoire (ex. Fibonacci récursif sans optimisation)
O(n!) : permutations/brute force (ex. voyageur de commerce en force brute)

Côté mémoire, mêmes idées : constant, logarithmique, linéaire, quadratique… selon ce que l’algorithme doit garder en réserve (tableaux, piles d’appels, matrices d’adjacence, ensembles de sous-ensembles, etc.).

8) Paradigmes de programmation : différentes façons de penser le code

Un paradigme, c’est une “philosophie” d’écriture. Deux grandes familles :

Impératif

On décrit comment faire : une suite d’instructions qui manipulent explicitement l’état. C’est la base de beaucoup de langages.

Sous-catégories très courantes :

procédural : organisation en fonctions/procédures
orienté objet (OOP) : le code tourne autour d’objets (données + comportements)

L’OOP s’appuie souvent sur 4 piliers :

encapsulation
abstraction
héritage
polymorphisme

Déclaratif

On exprime ce qu’on veut obtenir, et le système se charge du “comment”. Le SQL en est un exemple emblématique.

Dans la famille déclarative, la programmation fonctionnelle est un monde à part, avec des idées comme :

fonctions pures (pas d’effets de bord)
données immuables
fonctions comme valeurs (passées en argument, retournées, stockées…)

9) Design patterns : des solutions réutilisables aux problèmes récurrents

Au-delà du “ça marche”, on vise du code qui reste maintenable, extensible et robuste. Les patterns fournissent des modèles d’architecture ou de construction, souvent discutés en contexte orienté objet.

On les classe généralement en :

créationnels (comment instancier proprement)
structurels (comment composer les objets)
comportementaux (comment faire collaborer les objets)

10) SOLID : cinq règles pour garder l’OOP propre

Les principes SOLID servent de garde-fous pour éviter les systèmes rigides et fragiles :

responsabilité unique
ouvert à l’extension, fermé à la modification
substitution de Liskov
ségrégation des interfaces
inversion des dépendances

Beaucoup de patterns “bien choisis” aident justement à respecter ces principes.

11) Bases de données : stocker, retrouver, garantir

Un programme n’a pas seulement besoin de calculer : il doit aussi persister l’information.

Deux grandes catégories :

SQL / relationnel

Données en tables (schémas définis), requêtes via SQL. Exemples : PostgreSQL et MySQL.

Souvent associé à ACID pour garantir l’intégrité :

atomicité
cohérence
isolation
durabilité

NoSQL / non relationnel

Schémas plus flexibles, modèles variés (documents, clé/valeur, colonnes…). Exemples : MongoDB, Redis, Apache Cassandra.

Souvent lié à une philosophie BASE (disponibilité et passage à l’échelle, avec cohérence assouplie) :

disponibilité “basique”
état “souple”
cohérence éventuelle

12) Réseaux : faire parler les machines

Dès qu’on sort d’un ordinateur isolé, on entre dans la communication entre systèmes.

Le modèle OSI découpe cette communication en 7 couches (du signal brut au protocole applicatif) :

physique
liaison de données
réseau (IP, routage)
transport (TCP/UDP)
session
présentation (formats, chiffrement)
application (HTTP, FTP, SMTP…)

Dans la pratique, on parle très souvent du modèle TCP/IP, plus “terrain”, en 4 niveaux :

accès réseau
internet
transport
application

13) Concurrence et parallélisme : gérer plusieurs choses à la fois

Quand une application doit répondre vite à beaucoup de demandes, la capacité à exécuter plusieurs tâches devient critique.

Concurrence : gérer plusieurs tâches “en même temps” (souvent via entrelacement et changements de contexte, ou via plusieurs cœurs)
Parallélisme : exécuter réellement plusieurs opérations simultanément (multi-cœurs / multi-processeurs)

Qui dit tâches simultanées dit risques de collisions sur des ressources partagées. D’où l’usage d’outils de synchronisation comme :

mutex (exclusion mutuelle : un seul accès à la fois)
sémaphore (limiter le nombre d’accès simultanés)

14) Cybersécurité : identité, droits, confidentialité

Plus un système est connecté, plus la surface d’attaque grandit. Trois piliers reviennent sans cesse :

authentification : prouver qui on est (mot de passe, biométrie, OTP…)
autorisation : définir ce qu’on a le droit de faire/voir
chiffrement : rendre l’information illisible sans la clé

Deux grandes familles de chiffrement :

symétrique : même clé pour chiffrer et déchiffrer (ex. AES)
asymétrique : clé publique pour chiffrer, clé privée pour déchiffrer (ex. RSA)

15) Au-delà du “stack” classique : trois tendances qui repoussent les limites

Intelligence artificielle

L’idée : permettre à la machine d’apprendre à partir de données. Le machine learning est souvent présenté via :

apprentissage supervisé (données étiquetées)
non supervisé (découverte de structures, clustering)
par renforcement (essais/erreurs, récompenses)

Blockchain

Un registre distribué dont les enregistrements sont chaînés cryptographiquement, avec l’ambition d’apporter :

décentralisation
résistance à la modification des historiques
transparence
sécurité via la cryptographie

Informatique quantique

Ici, on ne manipule plus des bits, mais des qubits, capables de phénomènes comme :

superposition (plusieurs états possibles avant mesure)
intrication (corrélations fortes entre qubits)

L’objectif n’est pas de remplacer nos machines actuelles, mais d’accélérer certains calculs spécifiques : chimie, optimisation, et — potentiellement — remise en cause de certains schémas cryptographiques.