🧠 Qu’est-ce qu’un système d’exploitation ?

Un système d’exploitation est le logiciel de base qui orchestr[e] le matériel (CPU, mémoire, disque, réseau) et fournit des services aux programmes : gestion des processus, de la mémoire, des fichiers, des périphériques, du réseau et de la sécurité.
Il expose des appels système (system calls) et des API (p. ex. POSIX, Win32) pour que les applications interagissent avec la machine sans manipuler directement le matériel.

🕰️ Brève histoire — des cartes perforées à l’OS moderne

Années 1950 : proto-OS et traitement par lots

• GM-NAA I/O (≈1956) sur IBM 704 est souvent cité comme l’un des premiers « OS » : il automatise l’enchaînement de jobs et les E/S.

• Apparition des moniteurs et batch systems : on charge une pile de tâches sur cartes perforées, l’ordinateur les exécute séquentiellement.

Début 1960 : time-sharing, virtualisation naissante

• CTSS (1961–63) au MIT : pionnier du temps partagé (plusieurs utilisateurs interactifs).

• Atlas Supervisor (1962) à l’univ. de Manchester : mémoire virtuelle (pagination) — jalon fondamental.

• OS/360 (1964–66) chez IBM : première famille d’OS à grande échelle, normalise des concepts (fichiers, périphériques, catalogues).

Fin 1960 – 1970 : MULTICS, UNIX, CP/M

• MULTICS (1964–69) : sécurité à anneaux, segmentation+paging, système de fichiers hiérarchique, idées qui marqueront tout le secteur.

• UNIX (1969–1971) par Thompson & Ritchie (Bell Labs) : petit, portable en C, philosophie « tout est fichier », pipelines, shell.

• CP/M (1974) de Gary Kildall : OS micro-ordinateurs 8/16 bits, inspire MS-DOS.

1980–1990 : PC, GUI et réseaux

• MS-DOS (1981) → Windows (1985–95) : l’interface graphique se généralise.

• Mac System Software (1984) : GUI intégrée, souris.

• BSD popularise les sockets (réseau TCP/IP).

• Mach et micro-noyaux (fin 80s) : séparation stricte noyau/serveurs.

1990–2000 : NT, Linux, Unix modernes

• Windows NT (1993) : design hybride (micro-noyau modulaire), modèle sécurité avancé, domaine d’entreprise.

• Linux (1991) + GNU : OS libre type Unix, modèle noyau monolithique modulaire.

• Solaris, AIX, HP-UX : Unix propriétaires en entreprise.

2000–aujourd’hui : mobile, virtualisation, cloud & conteneurs

• iOS (2007), Android (2008) : OS mobiles grand public.

• Virtualisation : hyperviseurs type 1 (bare-metal) et type 2 (hébergés).

• Conteneurs : cgroups/namespaces (Linux), Docker (2013), orchestration (Kubernetes).

• Sécurité : sandboxing, SELinux, AppArmor, Secure Enclave, Verified Boot.

• Systèmes de fichiers modernes : NTFS, ext4, APFS, ZFS (intégrité, snapshots).

⚙️ Anatomie technique d’un OS

Noyau (kernel)

• Planification (scheduler) : répartit le CPU entre processus/threads (priorités, MLFQ, temps réel).

• Gestion de mémoire : mémoire virtuelle, paging, TLB, mmap, NUMA.

• Système de fichiers : hiérarchie, inodes, journaling (ext4, NTFS), snapshots (ZFS, Btrfs).

• Pilotes (drivers) : abstraient les périphériques (disques, GPU, NIC, USB).

• Réseau : pile TCP/IP, pare-feu (iptables/nftables), QoS.

• Sécurité : comptes, groupes, permissions rwx, ACLs, capabilities, SELinux/AppArmor, sandboxing.

Styles d’architecture

• Monolithique (Linux) : performances, moins de changement de contexte, mais gros noyau.

• Micro-noyau (Minix, seL4) : services en espace utilisateur → isolation accrue, plus de messages IPC.

• Hybride (Windows NT, XNU d’Apple) : compromis performances/isolement.

Espace utilisateur (userland)

• Bibliothèques (libc), shells (bash, zsh, PowerShell).

• Services systèmes (daemons), gestion des logs, init/gestion d’unités (systemd, launchd).

Démarrage et firmware

• Bootloader (BIOS/UEFI → GRUB, Windows Boot Manager).

• Chaîne de confiance (Secure Boot), chiffrement disque complet (BitLocker, FileVault, LUKS).

🗂️ Grandes familles d’OS (et traits distinctifs)

• Unix & Unix-like : UNIX historiques, BSD, Linux (serveurs, embarqué, supercalcul).

• Windows : compatibilité applicative, AD/Group Policy, écosystème entreprise & gaming.

• Apple (macOS, iOS, iPadOS, watchOS, tvOS) : noyau XNU (Mach + BSD), APFS, sandboxing poussé.

• Mobiles : Android (Linux + ART), iOS (sandbox, entitlements).

• Embarqués & temps réel (RTOS) : VxWorks, FreeRTOS, QNX (déterminisme temporel, fiabilité).

• Systèmes distribués : GFS/HDFS comme « OS du cluster », orchestrateurs (K8s) gèrent processus → pods.

🧩 Concepts clés qui ont façonné les OS

• Temps partagé : multi-utilisateurs interactifs (CTSS, MULTICS).

• Mémoire virtuelle : illusion d’un espace mémoire vaste & isolé (Atlas, MULTICS, puis tous les OS modernes).

• Fichiers & permissions : hiérarchie, liens symboliques/durs, journaling, quotas.

• GUI : du Xerox Alto (1973) à macOS/Windows actuels (fenêtres, pointeur, WIMP).

• Réseau : intégration TCP/IP (BSD) → Internet ubiquitaire.

• Virtualisation : dès CP/CMS chez IBM, puis VMware/Xen/KVM ; isolation forte, consolidation serveurs.

• Conteneurs : chroot (1979) → namespaces/cgroups → Docker/OCI (déploiement portable).

• Sécurité moderne : ASLR, DEP, sandbox, codesigning, SELinux, Zero Trust.

🧪 Étude de cas (évolution)

• UNIX → Linux : portabilité (C), simplicité d’objets « fichier », pipelines, outils réutilisables → fondation du cloud.

• Windows NT : modèle objet du noyau, sécurité, I/O asynchrones, registre, compatibilité binaire.

• macOS : XNU (Mach+BSD), frameworks Cocoa, APFS (instantanés, clones, chiffrement natif).

• Android : noyau Linux + runtime ART, sandbox par application, modèle de permissions fin.

🔐 Défis actuels

• Sécurité : menaces 0-day, chaîne d’approvisionnement, durcissement (sandbox, isolation matériel, enclaves).

• Confidentialité : contrôle fin des permissions (caméra, micro, localisation).

• Performance & efficacité énergétique : hétérogénéité CPU/GPU/NPU, scheduling « aware ».

• Fiabilité à grande échelle : mises à jour atomiques, live-patching, tolérance aux pannes.

• Interopérabilité : conteneurs multi-plateformes, ABI, standardisation (OCI, POSIX).

🔭 Tendances & futur des OS

• Micro-noyaux vérifiés formellement (ex. seL4) pour une sécurité prouvable.

• Unikernels : image applicative + noyau minimal → surface d’attaque réduite, démarrage ultra-rapide.

• **OS centrés sur le sandboxing & le least privilege par défaut (mobile-like sur desktop).

• Planification pilotée par l’IA (co-design matériel/logiciel) : allocations prédictives, optimisation énergétique.

• Mémoire persistante (NVRAM) et stockage vérifiable (ZKP) intégrés au cœur de l’OS.

• Sécurité matérielle : enclaves (SGX/SEV/TEE), démarrage mesuré, attestation distante.

• Edge/IoT : OS ultra-légers, mises à jour OTA sûres, runtime WebAssembly.

✅ Conclusion

L’invention du système d’exploitation n’est pas l’œuvre d’une seule personne ni d’une seule date, mais l’aboutissement d’innovations successives : du batch au time-sharing, d’UNIX à NT, des PC aux mobiles, des hyperviseurs aux conteneurs.
L’OS moderne est un médiateur de confiance entre applications et matériel, un planificateur de ressources, et un gardien de sécurité. Son évolution continue — vers plus d’isolation, d’efficacité, d’observabilité et d’automatisation — déterminera la fiabilité de tout le numérique de demain.