Quelle est la différence entre un programme et un processus en NSI ?

Un programme est un fichier contenant des instructions stockées sur le disque. Un processus est l'exécution de ce programme en mémoire, avec un identifiant (PID), un état et des ressources. Un même programme peut donner plusieurs processus simultanés.

Quels sont les trois états principaux d'un processus ?

Un processus peut être élu (en cours d'exécution sur le processeur), prêt (il pourrait s'exécuter mais attend son tour) ou bloqué (il attend une ressource comme une entrée clavier ou un fichier). L'ordonnanceur gère les transitions entre ces états.

Quel est le rôle du shell dans un système d'exploitation ?

Le shell est l'interpréteur de commandes : il lit les commandes tapées par l'utilisateur (ls, cd, ps, kill...) et demande au système d'exploitation de les exécuter. C'est l'interface en ligne de commande entre l'humain et l'OS.

Comment créer un processus en Python ?

On peut utiliser os.fork() (sous Unix), subprocess.Popen() ou le module multiprocessing. Appeler une fonction classique ne crée pas de processus : il faut explicitement demander au système de lancer une nouvelle exécution.

Qu'est-ce que l'ordonnancement des processus ?

C'est le mécanisme par lequel le système d'exploitation choisit quel processus utiliser le processeur à chaque instant. Les algorithmes courants sont FIFO (premier arrivé, premier servi) et round-robin (tourniquet), qui donnent à chacun un temps de processeur équitable.

Comment réviser efficacement le chapitre sur le système d'exploitation en NSI ?

Manipule un terminal (commandes ls, ps, kill), écris et modifie des scripts Python utilisant os et subprocess, puis explique chaque notion à voix haute. Combine cours, fiches et pratique pour ancrer les notions durablement.

Système d'exploitation NSI : les pièges à éviter

Tu révises le chapitre sur les systèmes d'exploitation en NSI et tu as l'impression que « ça va », mais les questions du bac te font douter ? Bonne nouvelle : les pièges sont toujours les mêmes, et une fois repérés, ils ne te piègeront plus. Dans cet article, on passe en revue les erreurs les plus fréquentes sur le système d'exploitation en NSI, avec des exemples concrets en Python et des méthodes pour ne plus te tromper. À la fin, tu sauras exactement ce qu'on attend de toi à l'écrit comme à l'oral.

Pourquoi le système d'exploitation est un chapitre piégeux

Le système d'exploitation (souvent abrégé OS, pour Operating System) est le logiciel qui fait le lien entre le matériel de la machine et les programmes que tu utilises. Windows, Linux, macOS ou Android en sont des exemples. En NSI, on l'étudie sous quatre angles : la gestion des processus, la gestion de la mémoire, la gestion des fichiers et les interactions avec les utilisateurs (shell, commandes).

Pourquoi tant d'élèves perdent des points ? Parce que ce chapitre mélange trois niveaux :

un niveau conceptuel (qu'est-ce qu'un processus, un ordonnanceur ?) ;
un niveau pratique (lancer des commandes, écrire un script Python qui crée des processus) ;
un niveau vocabulaire (ne pas confondre programme, processus, thread, tâche).

Si tu confonds ces niveaux, tu réponds à côté. La suite te donne les pièges un par un, avec la bonne façon de raisonner.

Piège n°1 : confondre programme, processus et thread

C'est le piège numéro un. Un programme est un fichier sur le disque : du code, des instructions, mais rien qui s'exécute. Un processus est ce même programme en cours d'exécution, chargé en mémoire, avec un identifiant (PID), un état et des ressources. Un thread (fil d'exécution) est une unité plus fine : plusieurs threads peuvent partager la mémoire d'un même processus.

Retiens la formule : programme = recette de cuisine, processus = plat en train de cuire, thread = plusieurs cuisiniers qui utilisent la même cuisine. Une même recette peut donner plusieurs plats (plusieurs processus), et un plat peut être préparé par plusieurs cuisiniers (plusieurs threads).

Le test qui te sauve à l'écrit

Quand on te demande « combien de processus sont créés ? », demande-toi toujours : est-ce que le code lance une nouvelle exécution ou juste une fonction ? En Python, appeler une fonction ne crée pas de processus. Utiliser os.fork() ou subprocess.Popen en crée un. C'est cette distinction qui fait la différence entre 2 et 4 points sur une question.

Piège n°2 : croire qu'un processus s'exécute en continu

Beaucoup d'élèves imaginent qu'un processus « tourne » sans interruption jusqu'à sa fin. Faux. Sur une machine avec un seul cœur, un seul processus s'exécute à un instant donné. L'ordonnanceur du système alterne très rapidement entre les processus : c'est le temps partagé. Chaque processus passe par plusieurs états :

élu (en cours d'exécution sur le processeur) ;
prêt (il pourrait s'exécuter, mais le processeur est occupé) ;
bloqué (il attend une ressource : entrée clavier, fichier, réseau).

Un processus bloqué ne consomme pas de temps processeur. C'est pour ça qu'on peut avoir 200 processus ouverts sans que la machine rame : la plupart sont bloqués ou prêts, pas élus.

Exemple Python : observer un processus

Voici un petit script qui montre qu'un processus a bien un identifiant et un processus parent. Tu peux le tester sur une machine Linux ou dans un environnement Python adapté :

import os

print("PID du processus courant :", os.getpid())
print("PID du processus parent :", os.getppid())

# On lance une commande externe : un nouveau processus est créé
os.system("echo Bonjour depuis un autre processus")

Chaque exécution te donne des PID différents : c'est normal, ils sont attribués par le système au moment du lancement. Ne t'étonne pas si le résultat change à chaque fois, c'est justement la preuve qu'un processus est une instance vivante, pas un fichier figé.

Piège n°3 : mal comprendre l'ordonnancement

Au bac, on te demande parfois de simuler un ordonnancement simple, par exemple premier arrivé, premier servi (FIFO) ou tourniquet (round-robin). Les erreurs classiques :

oublier qu'un processus bloqué sort de la file des prêts ;
ne pas remettre un processus préempté à la fin de la file (round-robin) ;
confondre temps d'attente et temps d'exécution.

Astuce : fais toujours un petit tableau avec les colonnes processus, arrivée, durée, début, fin, attente. Tu remplis ligne par ligne en respectant la règle. C'est mécanique, et ça rapporte tous les points.

Mini-simulation en Python

Tu peux même coder un ordonnanceur FIFO pour vérifier tes calculs à la main :

# Ordonnancement FIFO simple
processus = [("P1", 0, 4), ("P2", 1, 3), ("P3", 2, 2)]  # (nom, arrivée, durée)

# On trie par temps d'arrivée
processus.sort(key=lambda p: p[1])

temps = 0
for nom, arrivee, duree in processus:
    if temps < arrivee:
        temps = arrivee  # le processeur attend
    debut = temps
    temps += duree
    print(f"{nom} : début={debut}, fin={temps}, attente={debut - arrivee}")

Ce code t'entraîne à la fois à la programmation et à la compréhension des états d'un processus. Garde-le sous la main pour tes révisions : c'est typique de ce qu'on peut te demander d'adapter.

Piège n°4 : négliger les commandes du shell

Le shell est l'interpréteur de commandes : c'est ton interface avec le système d'exploitation. En NSI, on attend que tu connaisses quelques commandes de base, notamment sous Linux :

ls : lister le contenu d'un dossier ;
cd : changer de dossier ;
pwd : afficher le dossier courant ;
cp, mv, rm : copier, déplacer, supprimer ;
ps : lister les processus ;
kill : terminer un processus par son PID.

Le piège fréquent : croire que ces commandes sont « de la culture générale ». Non : on peut te demander d'écrire une commande précise, ou d'expliquer ce qu'elle fait. Entraîne-toi à les taper dans un terminal (ou une machine virtuelle) plutôt qu'à les relire passivement.

Un lien avec Python

Python peut exécuter des commandes du shell grâce au module subprocess. C'est un bon exemple de pont entre les deux parties du programme :

import subprocess

resultat = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(resultat.stdout)

Tu vois ici qu'un programme Python peut demander au système d'exécuter une autre commande. C'est ainsi que fonctionnent beaucoup d'outils réels.

Piège n°5 : oublier la gestion des fichiers et des droits

Un système d'exploitation organise le stockage en une arborescence de dossiers et de fichiers. Deux pièges reviennent souvent :

confondre chemin absolu (commence par / sous Linux, par C:\ sous Windows) et chemin relatif (part du dossier courant) ;
ignorer la notion de droits (lecture, écriture, exécution) associés à un utilisateur et un groupe.

Sous Linux, la commande chmod modifie ces droits. Par exemple, chmod 755 script.py donne tous les droits au propriétaire et la lecture/exécution aux autres. Ce n'est pas à mémoriser par cœur, mais tu dois comprendre la logique : le système protège les fichiers en vérifiant qui demande quoi.

Exemple en Python

Le module os permet de manipuler l'arborescence :

import os

print("Dossier courant :", os.getcwd())
print("Contenu :", os.listdir("."))

# Créer un dossier s'il n'existe pas
if not os.path.exists("mon_dossier"):
    os.mkdir("mon_dossier")

Attention : os.getcwd() renvoie le dossier courant, pas le dossier du script. C'est une confusion classique quand on exécute un fichier depuis un autre dossier.

Piège n°6 : réviser passivement

Le chapitre sur le système d'exploitation se retient mal par simple lecture. Trois méthodes marchent vraiment :

manipuler : ouvre un terminal, lance des commandes, regarde ps évoluer ;
écrire : recopie et adapte les scripts Python, modifie-les, casse-les, répare-les ;
expliquer : reformule chaque notion à voix haute, comme si tu la présentais à l'oral du bac.

Pour t'entraîner, appuie-toi sur les cours NSI et les fiches de révision du site. Si tu veux consolider les bases en programmation avant d'attaquer les processus, la référence Python est un bon point de départ.

Et si tu as besoin d'un accompagnement plus personnalisé pour préparer l'épreuve, tu peux aussi jeter un œil aux ressources du réseau Allo Education, comme Allolycee pour le lycée ou Allobac pour le bac.

Ce qu'on attend de toi à l'épreuve

À l'écrit du bac NSI, les questions sur le système d'exploitation sont souvent :

une question de cours courte (définir un processus, citer un rôle de l'OS) ;
un exercice d'application (simuler un ordonnancement, lire un script) ;
une question de culture informatique (comparer deux OS, expliquer le rôle du shell).

À l'oral, on peut te demander d'expliquer un script que tu as écrit, ou de justifier un choix technique. Entraîne-toi à parler sans notes, en utilisant le vocabulaire exact. C'est ce qui distingue une réponse correcte d'une réponse excellente.

Conclusion : transforme les pièges en réflexes

Le système d'exploitation en NSI n'est pas un chapitre difficile : c'est un chapitre précis. Les pièges viennent presque toujours des mêmes confusions : programme/processus/thread, processus élu/prêt/bloqué, chemin absolu/relatif, commande tapée/commande comprise. Si tu fais l'effort de manipuler, d'écrire du Python et d'expliquer à voix haute, tu transformeras ces pièges en réflexes. Et le jour du bac, tu répondras avec assurance, parce que tu auras compris, pas seulement mémorisé. Allez, ouvre un terminal et lance ta première commande : c'est en pratiquant qu'on progresse vraiment.