NSI · Terminale

Histoire de l’informatique et projet transversal : enquêter, relier, construire et prouver

L’histoire de l’informatique relie un objet daté, sa fonction, une source et une limite. Un modèle Python rend un mécanisme testable, sans prouver l’authenticité d’une archive ni l’adoption d’une technique. Le projet transforme une question étroite en dossier de preuves et prototype local dont le contrat est explicite.

Explications et exemples en accès libre. Ateliers, quiz et cartes avec l’abonnement.

Étude en accès libre
Environ 50 min à 1 h 35
Progression
6 étapes guidées
Vérification
12 questions
Rappel actif
12 cartes
Prévoir mon tempsExplications et exemples en accès libre

Une première étude des explications, schémas, exemples résolus et erreurs expliquées. Les activités, productions, quiz et cartes réservés à l’abonnement ne sont pas comptés ici.

Comprendre2040 mots d’explication et 6 schémas
15 à 25 min
Étudier les exemples et les erreurs18 cas, exemples et activités guidés
36 à 66 min

Étude du cours en accès libre, environ50 min à 1 h 35

Voir le calcul et le temps par étape

Le calcul suit automatiquement les explications et les tâches présentes dans le cours. Ses coefficients sont des repères de planification, pas des temps mesurés auprès d’élèves.

  • Lecture active : 2040 mots, à raison de 160 à 220 mots par minute.
  • Schémas : 6, avec 1 à 2 min pour lire chacun.
  • Exemple guidé : 6 × 2 à 4 min.
  • Suivre le code résolu et ses tests : 6 × 3 à 5 min.
  • Comprendre une erreur expliquée : 6 × 1 à 2 min.
  1. Enquêter : d’une date isolée à une affirmation contrôlable8 à 16 min
  2. Matériel et logiciel : modifier une instruction, pas seulement câbler une fonction8 à 15 min
  3. Données : relier des faits sans confondre modèle, fichier et transaction8 à 15 min
  4. Internet et Web : lire une RFC, une proposition et un déploiement8 à 16 min
  5. Logiciels et collectifs : attribuer un rôle sans écrire une galerie de héros8 à 15 min
  6. Projet de Terminale : une question, une preuve, un prototype et une présentation8 à 15 min

Les sous-totaux sont arrondis à la minute, puis additionnés. La fourchette totale est élargie aux cinq minutes voisines. Les étapes ci-dessus comprennent leurs explications et exemples ; elles ne s’ajoutent pas une seconde fois au total.

Adapte ce repère à tes acquis et au soin apporté aux exercices. Les pauses, les reprises, la consultation des sources externes et les révisions suivantes s’ajoutent selon tes besoins.

Avec les ateliers, le projet, le quiz et les cartes : environ 4 h 35 à 8 h, à répartir sur plusieurs séances.

Objectifs du cours

Ce que tu vas savoir faire

  • Qualifier une affirmation par son objet, sa source, sa date et sa portée.
  • Distinguer programme enregistré, circuit câblé, modèle relationnel, Internet et Web.
  • Lire une proposition ou une RFC sans la confondre avec un déploiement.
  • Tester un modèle borné et formuler ce qu’il ne prouve pas.
  • Présenter une enquête et un prototype en séparant source, test, observation et décision.
01

Étape du cours · 8 à 16 min

Enquêter : d’une date isolée à une affirmation contrôlable

Une frise n’est pas encore une explication. Pour chaque ligne, demande quel est l’objet, qui produit la trace, quelle date porte-t-elle et quelle conclusion autorise-t-elle. « 1936 : Turing » ne suffit pas. Dans le programme de Terminale, l’article de 1936 sert à situer un modèle théorique de calcul. Il ne prouve ni qu’une machine identique est alors construite, ni que toute l’informatique découle d’un seul texte.

Le Manchester Baby fournit une trace différente. La notice de conservation consultée date au 21 juin 1948 l’exécution d’un programme par cette machine expérimentale. Cette source répond à une question précise : une machine à programme enregistré a-t-elle exécuté un programme à cette date ? Elle ne permet pas de transformer cette machine en origine unique de tous les ordinateurs ni d’effacer les autres projets.

Écris une affirmation atomique : « La notice consultée attribue au Baby l’exécution d’un programme le 21 juin 1948. » Attache une URL, une date d’accès, le type de document et une portée. Une phrase telle que « le programme enregistré a remplacé les circuits » mélange au contraire une comparaison technique, une histoire longue et un jugement sans source unique. Les mots « premier », « inventeur » et « a rendu possible » exigent une vigilance accrue.

Le laboratoire n’authentifie pas une archive : il vérifie seulement la forme d’un registre fictif. Une entrée comporte une revendication, un objet, une date ISO, une URL HTTPS et une portée. Les doublons deviennent des alertes au lieu d’écraser une entrée ; une référence absente n’est jamais inventée. Les booléens sont refusés quand le contrat demande un entier strict.

Les autres chapitres de NSI donnent les outils de cette enquête : algorithmique pour traiter une liste, structures pour organiser le registre, bases de données pour les contraintes, réseaux pour l’URL, langages pour exécuter le contrôle. Aucune de ces opérations ne décide de la vérité historique. Elles rendent seulement le raisonnement vérifiable et obligent à nommer les lacunes du dossier.

Voir pour comprendre

Lire une notice de conservation

Trois niveaux de lecture du même repère, tous couverts par la notice du Baby.

Lire une notice de conservation
RepèreObjetConclusion bornée
21 juin 1948Date portée par la noticeLa notice situe une exécution
Manchester BabyMachine expérimentaleLa notice décrit cet objet
Programme exécutéÉvénement rapportéCette exécution est attribuée à cette machine

Lis le schéma. Quelle conclusion concerne l’objet, laquelle concerne l’événement ?

La portée d’une source dépend du lien entre son objet et l’événement qu’elle rapporte.

Exemples résolus et erreurs expliquées

Lire deux repères sans les confondre

  1. 1936 désigne ici un article : l’objet est un texte qui présente un modèle.
  2. Le 21 juin 1948 désigne une exécution documentée sur une machine expérimentale.
  3. Les repères éclairent le lien entre théorie et réalisation sans prouver une causalité unique.
  4. La conclusion sûre reste limitée aux documents et aux objets cités.

Conclusion. Situer le type de trace évite de convertir une date en récit automatique.

Laboratoire de code

Languepython

Butnormaliser un registre fictif d’affirmations sans fabriquer de preuve

Code solution
from datetime import date
from urllib.parse import urlparse

PORTEES = {'documente', 'a-confirmer'}

def date_iso(texte):
    if type(texte) is not str or len(texte) != 10 or texte[4:5] != '-' or texte[7:8] != '-': return False
    try: date.fromisoformat(texte)
    except ValueError: return False
    return True

def url_https(texte):
    analyse = urlparse(texte) if type(texte) is str else None
    return bool(analyse and analyse.scheme == 'https' and analyse.hostname)

def normaliser_affirmations(entrees):
    if type(entrees) is not list or len(entrees) > 50: raise ValueError('liste bornée attendue')
    gardees, alertes, vus = [], [], set()
    for e in entrees:
        if type(e) is not dict or set(e) != {'id','affirmation','objet','date','accessedAt','url','portee'}: raise ValueError('champs exacts attendus')
        if type(e['id']) is not int or type(e['id']) is bool or e['id'] < 1: raise ValueError('id entier positif attendu')
        if any(type(e[k]) is not str or not e[k] for k in ('affirmation','objet','date','accessedAt','url','portee')): raise ValueError('texte attendu')
        if not date_iso(e['date']) or not date_iso(e['accessedAt']) or not url_https(e['url']) or e['portee'] not in PORTEES: raise ValueError('date, URL ou portée invalide')
        if e['id'] in vus: alertes.append((e['id'],'doublon')); continue
        vus.add(e['id']); gardees.append(dict(e))
    return gardees, tuple(alertes)

Tests

E=[{'id':1,'affirmation':'Programme exécuté','objet':'Baby','date':'1948-06-21','accessedAt':'2026-09-06','url':'https://exemple.test/baby','portee':'documente'}]
assert normaliser_affirmations(E) == (E, ())
assert normaliser_affirmations(E + [dict(E[0])])[1] == ((1,'doublon'),)
assert normaliser_affirmations([]) == ([], ())
for mauvais in ([{'id':True,'affirmation':'x','objet':'x','date':'2026-09-06','accessedAt':'2026-09-06','url':'https://x.test','portee':'documente'}],[{'id':2,'affirmation':'x','objet':'x','date':'2026-99-99','accessedAt':'2026-09-06','url':'https://x.test','portee':'documente'}],[{'id':2,'affirmation':'x','objet':'x','date':'2026-09-06','accessedAt':'2026-09-06','url':'https://','portee':'documente'}]):
    try: normaliser_affirmations(mauvais)
    except ValueError: pass
    else: raise AssertionError('entrée invalide acceptée')

Trace

  • L’entrée 1 est conservée avec les deux dates et son URL.
  • Le même identifiant devient une alerte sans écraser l’entrée initiale.
  • Un booléen, une date impossible ou une URL HTTPS sans hôte est refusé avant tout résultat.

Clinique de bogue

Indice observéDeux entrées de même identifiant font disparaître la première.

CauseUn dictionnaire indexé par identifiant écrase une valeur antérieure. La politique annoncée est de conserver la première et de signaler le doublon.

02

Étape du cours · 8 à 15 min

Matériel et logiciel : modifier une instruction, pas seulement câbler une fonction

Un circuit câblé réalise une fonction par ses connexions : changer la fonction impose de modifier le dispositif. Une machine à programme enregistré place instructions et données dans une mémoire lue par le processeur. Le programme n’est pas une explication complète : il faut encore du matériel, un jeu d’instructions et une convention de lecture. La distinction utile est la possibilité de changer une suite d’instructions sans recâbler chaque opération.

La démonstration du Baby en 1948 est un repère historique situé. Elle ne signifie pas que toutes les machines sont identiques, ni que les circuits cessent d’exister. Une architecture combine composants, mémoire, entrées-sorties et logiciels. L’histoire est donc une coévolution : les composants ouvrent certaines réalisations ; les logiciels organisent des opérations et créent de nouveaux besoins matériels.

Le schéma suit un pas de mini-machine fictive. Une case contient ADD 3, une autre le nombre 7 ; le compteur lit l’instruction, l’adresse mène à la donnée et l’accumulateur passe de 5 à 12. Cette géométrie montre que la mémoire contient ici un encodage d’instruction et une donnée. Ce n’est ni une photographie du Baby ni la description entière d’un processeur réel.

Le modèle est fermé : mémoire de trois à huit cases, entiers stricts et une instruction ADD observée. Il valide la forme avant de calculer afin qu’un booléen, une adresse négative ou une instruction inconnue ne deviennent pas un résultat vraisemblable. Il rend un instantané sous forme de tuple : une mutation de la liste d’appel ne change pas la trace déjà produite.

Architecture, algorithmique et langages apportent chacun une vue : composants, procédure et notation. L’histoire relie ces objets sans les ordonner en un progrès automatique. Dis toujours si tu décris un mécanisme du modèle, une propriété du document ou une hypothèse sur le changement technique.

Voir pour comprendre

Une instruction lit une donnée dans la mémoire

Géométrie d’un pas ADD dans une mini-machine fictive.

Lire une instruction et sa donnée dans la même mémoire Avant ADD : compteur 0, accumulateur 5. L’instruction lit l’adresse 3, qui contient 7. Après : accumulateur 12, compteur 1. La mémoire est inchangée pendant ce pas. Mémoire communeAdresseContenu 0 ADD 3 1 HALT 0 2 0 3 7 Processeur PC = 0 ACC = 5 5 + 7 = 12 · PC devient 1

Le compteur sélectionne ADD 3. L’argument 3 est une adresse ; la valeur ajoutée est 7. ADD ne modifie aucune cellule de mémoire.

Lis le schéma. Suis le compteur vers ADD 3, puis l’adresse 3 vers la donnée 7.

Le nombre 3 est une adresse ; le nombre ajouté est 7.

Schéma original Maxdecours ; modèle fictif du cours. · Source du repère · 06/09/2026

Exemples résolus et erreurs expliquées

Suivre ADD 3

  1. Le compteur sélectionne ADD 3.
  2. 3 est une adresse et mène à la valeur 7.
  3. L’accumulateur devient 5 + 7 = 12.
  4. La mémoire n’est pas modifiée dans ce pas.

Conclusion. Instruction, adresse et donnée doivent être distinguées.

Laboratoire de code

Languepython

Butexécuter un pas ADD sur une mémoire fictive et conserver un instantané

Code solution
def pas_add(memoire, pc, acc):
    if type(memoire) is not list or not 3 <= len(memoire) <= 8: raise ValueError('mémoire bornée attendue')
    if type(pc) is not int or type(acc) is not int or not 0 <= pc < len(memoire): raise ValueError('pc et acc entiers attendus')
    for case in memoire:
        if type(case) is int: continue
        if type(case) not in (tuple,list) or len(case) != 2 or type(case[0]) is not str or case[0] not in {'ADD','HALT'} or type(case[1]) is not int: raise ValueError('cellule entière ou instruction ADD/HALT attendue')
        if case[0] == 'ADD' and not 0 <= case[1] < len(memoire): raise ValueError('adresse ADD bornée attendue')
        if case[0] == 'HALT' and case[1] != 0: raise ValueError('HALT 0 attendu')
    copie = [tuple(case) if type(case) in (tuple,list) else case for case in memoire]; instruction = copie[pc]
    if type(instruction) not in (tuple,list) or len(instruction) != 2 or instruction[0] != 'ADD' or type(instruction[1]) is not int: raise ValueError('ADD adresse attendu')
    adresse = instruction[1]
    if not 0 <= adresse < len(copie) or type(copie[adresse]) is not int: raise ValueError('donnée entière attendue')
    return acc + copie[adresse], pc + 1, tuple(copie)

Tests

M=[('ADD',3),('HALT',0),0,7]
assert pas_add(M,0,5) == (12,1,tuple(M))
F=[['ADD',3],['HALT',0],0,7]
INSTANTANE = pas_add(F,0,5)
F[0][1], F[3] = 2, 99
assert INSTANTANE == (12,1,(('ADD',3),('HALT',0),0,7))
assert M[3] == 7
assert all(type(case) is int or (type(case) is tuple and len(case) == 2 and type(case[1]) is int) for case in INSTANTANE[2])
for args in [([('ADD',4),0,0],0,0),([('ADD',True),0,0],0,0),([['SUB',2],0,7],0,0),([('ADD',1),0,True],0,0),([('HALT',1),0,7],0,0),([('ADD',2),'opaque',7],0,0),([('ADD',2),0,True],0,0)]:
    try: pas_add(*args)
    except ValueError: pass
    else: raise AssertionError('mémoire invalide acceptée')

Trace

  • Le compteur sélectionne ADD 3.
  • L’adresse 3 désigne 7.
  • L’accumulateur passe de 5 à 12 et la mémoire est figée.

Clinique de bogue

Indice observéUne adresse négative lit la dernière case Python.

CauseLes indices négatifs Python ne font pas partie du contrat de cette mémoire pédagogique. Sans contrôle, -1 lit la dernière case et produit une valeur plausible au lieu de signaler que l’adresse est hors du domaine du modèle.

03

Étape du cours · 8 à 15 min

Données : relier des faits sans confondre modèle, fichier et transaction

Un fichier aligne des enregistrements selon une convention. Un modèle relationnel organise relations, attributs et contraintes pour raisonner sur des données partagées. L’article de Codd publié en juin 1970 est une proposition de modèle : cite-le comme telle. Il ne date pas l’usage de chaque SGBD et ne transforme pas un dictionnaire Python en base de données.

Notre modèle possède une liste d’affirmations et une liste de sources. La fonction vérifie d’abord les clés et construit ensuite une jointure locale. Cette opération est utile pour faire voir identifiant, référence et contrainte d’unicité. Un SGBD ajoute toutefois stockage durable, requêtes, concurrence, journalisation et reprise selon son implantation.

Ici, la fonction valide les deux listes avant de construire son tuple de résultat local. Si une référence est inconnue, elle lève une erreur et ne renvoie pas une jointure partielle. Ce choix rend le contrat lisible, mais ne modélise ni transaction, ni atomicité de SGBD, ni verrouillage concurrent, ni journalisation, ni reprise après panne.

Deux affirmations de même id ne doivent pas être remplacées par la dernière. Une clé étrangère inconnue ne devient pas une chaîne vide. True n’est pas l’identifiant 1 dans ce contrat, même si Python traite souvent le booléen comme entier. Ces cas frontières départagent une fonction qui conserve les contraintes d’une fonction qui produit une réponse apparemment plausible.

Les cours de structures et bases de données donnent les outils de liste, clé, dictionnaire, jointure et contrainte. L’histoire pose une question supplémentaire : quel problème un texte cherchait-il à formuler ? Relier un extrait, un mécanisme et une limite vaut mieux qu’une chronologie de mots-clés.

Voir pour comprendre

Du document à une relation vérifiée

Les contrôles précèdent la jointure.

  1. Sourceid unique ; titre associé
  2. Affirmationid, texte, source_id
  3. Validationtypes, doublons, référence
  4. Résultataffirmation reliée au document

Lis le schéma. Quel contrôle intervient avant la jointure ?

La cohérence d’un modèle est testable ; la vérité d’une archive se lit dans la source.

Exemples résolus et erreurs expliquées

Joindre une affirmation à sa source

  1. Vérifier les identifiants entiers stricts et uniques.
  2. Construire l’index des sources après validation.
  3. Associer à l’affirmation le titre Notice sans modifier les listes.
  4. Une source 9 provoquerait un refus avant le résultat.

Conclusion. La fonction établit une cohérence de références fictives.

Laboratoire de code

Languepython

Butjoindre des affirmations fictives à leurs sources avec validation préalable

Code solution
def joindre_sources(affirmations, sources):
    if type(affirmations) is not list or type(sources) is not list: raise ValueError('listes attendues')
    index = {}
    for s in sources:
        if type(s) is not dict or set(s) != {'id','titre'} or type(s['id']) is not int or type(s['id']) is bool or type(s['titre']) is not str or not s['titre']: raise ValueError('source invalide')
        if s['id'] in index: raise ValueError('source dupliquée')
        index[s['id']] = s['titre']
    resultat, ids = [], set()
    for a in affirmations:
        if type(a) is not dict or set(a) != {'id','texte','source_id'} or type(a['id']) is not int or type(a['id']) is bool or type(a['source_id']) is not int or type(a['source_id']) is bool or type(a['texte']) is not str or not a['texte']: raise ValueError('affirmation invalide')
        if a['id'] in ids or a['source_id'] not in index: raise ValueError('référence incohérente')
        ids.add(a['id']); resultat.append((a['id'],a['texte'],index[a['source_id']]))
    return tuple(resultat)

Tests

A=[{'id':4,'texte':'Exécution documentée','source_id':2}]; S=[{'id':2,'titre':'Notice'}]
assert joindre_sources(A,S) == ((4,'Exécution documentée','Notice'),)
assert joindre_sources([],[]) == ()
assert joindre_sources([{'id':5,'texte':'Objet','source_id':3}],[{'id':3,'titre':'Catalogue'}]) == ((5,'Objet','Catalogue'),)
for a,s in [([{'id':True,'texte':'x','source_id':2}],S),(A,[{'id':2,'titre':'a'},{'id':2,'titre':'b'}]),([{'id':4,'texte':'x','source_id':9}],S)]:
    try: joindre_sources(a,s)
    except ValueError: pass
    else: raise AssertionError('contrat invalide accepté')

Trace

  • L’index associe 2 à Notice.
  • L’affirmation 4 retrouve le titre sans modifier les entrées.
  • Une clé dupliquée ou inconnue arrête le traitement.

Clinique de bogue

Indice observéLa dernière source de même id remplace la première sans signal.

CauseLa compréhension de dictionnaire masque les doublons : la dernière valeur remplace la première sans trace. L’unicité doit être contrôlée avant l’index, sinon la jointure présente un dossier modifié comme cohérent.

04

Étape du cours · 8 à 16 min

Internet et Web : lire une RFC, une proposition et un déploiement

Internet et Web ne désignent pas le même objet. Internet relie des réseaux par des protocoles ; le Web relie des ressources par identifiants, protocole de transfert et documents hypertextes au-dessus de réseaux existants. Le document RFC 1 porte la date du 7 avril 1969 et le titre Host Software. Son existence renseigne un document de travail du réseau ARPA ; elle ne suffit pas à établir une adoption immédiate par tous les hôtes.

La proposition de Tim Berners-Lee est intitulée Information Management: A Proposal, attribuée au CERN et datée de mars 1989, avec une date de mai 1990 dans la version consultée. Lis le mot proposal : le document cherche une solution à un problème de circulation de l’information. La page explique que le nom World Wide Web est choisi lors de l’écriture du code en 1990. Proposition, version du texte et logiciels sont donc des repères différents.

Un protocole est un contrat de communication, pas une date décorative. Le laboratoire réduit une négociation à des entiers positifs : il prend la plus haute version commune au-dessus d’un minimum. Le modèle n’est ni TLS, ni HTTP, ni une preuve de sécurité. Il rend visibles seulement une intersection, une politique minimale et un refus explicite.

Les frontières évitent les conclusions faciles : True n’est pas une version ; une liste vide ne doit pas provoquer max sur un ensemble vide ; un seuil supérieur aux versions communes donne None. La trace décrit les candidats du modèle. Elle ne démontre pas qu’un protocole réel a été déployé, ce qui demanderait d’autres documents ou observations.

Réseaux, architecture et langages se rejoignent : définir un format, l’implémenter et le tester. L’histoire ajoute contexte et prudence. Écris « ce document propose », « ce modèle calcule » ou « cette source rapporte », sans laisser croire qu’une date prouve adoption, sécurité ou causalité globale.

Lecture guidée. Ouvre la proposition conservée par le W3C et lis son en-tête : « Information Management: A Proposal », « Tim Berners-Lee, CERN », puis les repères « March 1989 » et « May 1990 ». Question : que permet d’affirmer le repère de mai ? Correction : la page consultée présente une version du texte rediffusée en mai 1990 ; ce repère ne prouve pas à lui seul un déploiement du Web.

Voir pour comprendre

Lire le statut de la proposition Web

Les trois lignes sont tirées du document historique présenté par le W3C.

Lire le statut de la proposition Web
RepèreObjetCe que le document permet de dire
Mars 1989Proposition au CERNUne solution est envisagée
Mai 1990Date ajoutée au documentLe texte est redistribué avec cette date
1990Écriture du codeLe nom World Wide Web est choisi à ce moment

Lis le schéma. Quelle ligne parle du texte, laquelle parle de l’écriture du code ?

Proposition, version du document et logiciels sont des repères distincts.

Exemples résolus et erreurs expliquées

Négocier dans un modèle borné

  1. Les versions communes sont 2 et 3.
  2. Le minimum 2 conserve les deux.
  3. La règle choisit 3.
  4. Cette sortie ne décrit pas TLS ni HTTP.

Conclusion. Compatibilité et politique minimale sont deux contrôles distincts.

Laboratoire de code

Languepython

Butsélectionner une version commune dans un modèle sans réseau

Code solution
def versions_valides(vs):
    if type(vs) is not list or len(vs) > 20 or any(type(v) is not int or v < 1 for v in vs): raise ValueError('versions entières positives attendues')
    return tuple(vs)

def version_commune(client, serveur, minimum):
    client, serveur = versions_valides(client), versions_valides(serveur)
    if type(minimum) is not int or minimum < 1: raise ValueError('minimum entier attendu')
    trace = []
    for v in sorted(set(client) & set(serveur), reverse=True):
        trace.append((v,v >= minimum))
        if v >= minimum: return v, tuple(trace)
    return None, tuple(trace)

Tests

assert version_commune([1,3,2],[2,3,4],2)[0] == 3
assert version_commune([1,2],[1,2],3)[0] is None
assert version_commune([],[],1) == (None,())
for c,s,m in [([True],[1],1),([1],[1],True),([1]*21,[1],1)]:
    try: version_commune(c,s,m)
    except ValueError: pass
    else: raise AssertionError('version invalide acceptée')

Trace

  • Les versions communes sont triées de la plus haute à la plus basse.
  • La première autorisée est retournée.
  • Aucune version autorisée rend None et une trace finie.

Clinique de bogue

Indice observé[1,3,2] choisit 1 au lieu de 3.

CauseL’ordre d’entrée est confondu avec le contrat de ce diagnostic. Ici, il faut déterminer l’intersection puis choisir son maximum. Le seuil minimal appartient au laboratoire version_commune, pas à cette fonction choisir à deux arguments. Sans cette distinction, une liste permutée change arbitrairement la décision.

05

Étape du cours · 8 à 15 min

Logiciels et collectifs : attribuer un rôle sans écrire une galerie de héros

Un logiciel durable rassemble conception, programmation, test, exploitation, documentation, traduction, maintenance et gouvernance. Ces rôles ne se déduisent pas d’un seul nom visible. Une archive peut mieux conserver le code que les essais, manuels ou tâches d’opération. L’enquête commence donc par les traces disponibles et leurs lacunes.

Dans un dossier complet, une contribution relie une personne ou un collectif, un rôle, un objet, une période et une référence. Le laboratoire se borne volontairement au sous-contrat personne_id, rôle, objet et reference : il ne prétend donc pas dater une contribution. Ne transforme pas l’absence de référence en absence de travail : écris plutôt « rôle non attribué par les documents consultés ». Cette formule évite de qualifier sans cas sourcé un travail de féminin, subalterne ou invisible, tout en gardant ouverte la recherche de nouvelles traces.

Le laboratoire manipule des entrées fictives. Une entrée sans URL de référence est signalée et n’entre pas dans l’index. Il ne classe personne et ne fusionne pas les homonymes : personne_id est distinct du nom affiché. Les sorties répondent seulement aux rôles et objets attestés par les données fournies.

Un historique de versions et une documentation donnent des prises pour maintenir un projet. Le chapitre About Version Control de Pro Git compare les modèles local, centralisé et distribué et rappelle l’intérêt de conserver les versions ; il ne décrit pas à lui seul les branches ni l’organisation de tous les collectifs. Licence, gouvernance et revue sont des documents à lire, non des étiquettes qui prouvent automatiquement une pratique.

Cette section rejoint langages et projet : un module compréhensible a un contrat, des noms et des tests ; une équipe doit aussi rendre ses décisions et contributions lisibles. Ton dossier peut reconnaître une lacune documentaire. Cette prudence protège les personnes citées et permet de corriger le dossier lorsqu’une nouvelle source apparaît.

Voir pour comprendre

Attribuer sans surinterpréter

Une contribution n’entre dans l’index qu’avec une référence.

  1. Tracedocument consulté
  2. Fichepersonne, rôle, objet
  3. RéférenceURL et portée
  4. Indexretrouver sans classer

Lis le schéma. À quel moment une lacune est-elle signalée ?

Le code organise des références ; il ne complète pas les archives.

Exemples résolus et erreurs expliquées

Index fictif sans classement

  1. Les deux rôles de p-1 sont conservés.
  2. p-2 est signalé mais non indexé comme fait sourcé.
  3. Aucun score ne compare p-1 et p-2.
  4. L’index répond seulement aux contributions documentées dans ce jeu.

Conclusion. Un index aide à chercher, il ne juge pas les personnes.

Laboratoire de code

Languepython

Butindexer des contributions fictives seulement avec une référence

Code solution
from urllib.parse import urlparse

def url_https(texte):
    analyse = urlparse(texte) if type(texte) is str else None
    return bool(analyse and analyse.scheme == 'https' and analyse.hostname)

ROLES = {'conception','programmation','test','documentation','maintenance','operation'}

def indexer_contributions(entrees):
    if type(entrees) is not list or len(entrees) > 50: raise ValueError('liste bornée attendue')
    resultat, alertes = {}, []
    for e in entrees:
        if type(e) is not dict or set(e) != {'personne_id','role','objet','reference'}: raise ValueError('champs exacts attendus')
        if any(type(e[k]) is not str or not e[k] for k in ('personne_id','role','objet')) or type(e['reference']) is not str: raise ValueError('textes attendus')
        if e['role'] not in ROLES or not url_https(e['reference']): alertes.append((e['personne_id'],'non-indexee')); continue
        resultat.setdefault(e['personne_id'],[]).append((e['role'],e['objet'],e['reference']))
    return resultat, tuple(alertes)

Tests

E=[{'personne_id':'p-1','role':'test','objet':'module','reference':'https://exemple.test/a'},{'personne_id':'p-1','role':'documentation','objet':'manuel','reference':'https://exemple.test/b'},{'personne_id':'p-2','role':'test','objet':'outil','reference':''}]
R,A=indexer_contributions(E)
assert len(R['p-1']) == 2
assert A == (('p-2','non-indexee'),)
assert indexer_contributions([]) == ({},())
try: indexer_contributions([{'personne_id':'p','role':'test','objet':'x','reference':True}])
except ValueError: pass
else: raise AssertionError('booléen accepté')

Trace

  • p-1 reçoit deux fiches sourcées.
  • p-2 est signalé mais absent de l’index.
  • La sortie ne contient aucun classement.

Clinique de bogue

Indice observéLes homonymes fusionnent et seule la dernière contribution reste visible.

CauseLe nom n’est pas un identifiant unique et une valeur scalaire ne conserve pas plusieurs rôles. Les homonymes fusionnent et les contributions antérieures sont perdues : l’index doit utiliser un identifiant documenté et accumuler les fiches au lieu de les remplacer.

06

Étape du cours · 8 à 15 min

Projet de Terminale : une question, une preuve, un prototype et une présentation

Un projet transversal ne juxtapose pas API, authentification, interface et base de données. Commence par une question étroite : « Comment la proposition Web de 1989 distingue-t-elle liens et hiérarchie dans le problème décrit au CERN ? » Choisis deux sources consultables, note auteurs, dates et limites, puis formule ce que ton dossier cherchera à établir. Les données du prototype restent fictives : aucune identité réelle ni donnée de mineur.

Le prototype contrôle la forme d’un dossier. Il reçoit une liste d’exigences et un dictionnaire de preuves. Une preuve est recevable si son statut est réussite, sa référence HTTPS, sa date ISO et son périmètre sont présents. Il peut alors retourner True pour prêt pour revue. Il ne dit ni qu’un fait historique est vrai, ni qu’une interface a été observée, ni qu’une personne a approuvé.

Tests, capture et lecture de source établissent des choses différentes. Un test montre un comportement sur des données synthétiques. Une capture montre un rendu à un instant. Une source justifie un fait dans son champ. La présentation doit donc montrer, pour chaque conclusion, la pièce correspondante et la limite qui l’accompagne.

Les frontières sont concrètes. Une liste d’exigences vide est refusée : un dossier sans attente ne peut pas être prêt. Un booléen ne devient pas identifiant. Une preuve non HTTPS ou sans date est refusée avant l’annonce de revue possible. Cette règle corrige l’erreur où pret_pour_revue([], {}) renvoie True par effet de all sur une collection vide.

Ta production rassemble les sources consultées, les données fictives du prototype, un module Python, ses tests, une sortie textuelle et une présentation individuelle. Elle relie les six thèmes du cours sans confondre le contrôle de forme avec la lecture des archives ou la décision d’une personne.

Voir pour comprendre

Une preuve selon ce qu’elle établit

Le dossier relie des pièces de nature différente.

  1. Sourcefait situé et portée
  2. Testfonction fictive
  3. Capturerendu observé
  4. Revuelecture et décision

Lis le schéma. Quelle pièce peut établir le rendu, laquelle peut établir un contrat ?

Une preuve ne remplace pas toutes les autres.

Exemples résolus et erreurs expliquées

Trois preuves, un état prudent

  1. La fonction vérifie chaque exigence attendue.
  2. Chaque preuve porte une URL HTTPS, une date ISO et un périmètre.
  3. True signifie seulement prêt pour revue.
  4. Une lecture distincte reste nécessaire pour toute décision.

Conclusion. Le nom de l’état évite de confondre contrôle automatique et validation.

Laboratoire de code

Languepython

Butcontrôler la forme d’un dossier fictif avant une revue

Code solution
from datetime import date
from urllib.parse import urlparse

def date_iso(texte):
    try: date.fromisoformat(texte)
    except (TypeError, ValueError): return False
    return type(texte) is str and len(texte) == 10

def url_https(texte):
    analyse = urlparse(texte) if type(texte) is str else None
    return bool(analyse and analyse.scheme == 'https' and analyse.hostname)

def pret_pour_revue(exigences, preuves):
    if type(exigences) is not list or not exigences or len(exigences) > 12: raise ValueError('une à douze exigences attendues')
    if type(preuves) is not dict: raise ValueError('preuves attendues')
    vus = set()
    for exigence in exigences:
        if type(exigence) is not str or not exigence or exigence in vus: raise ValueError('exigences distinctes attendues')
        vus.add(exigence); p = preuves.get(exigence)
        if type(p) is not dict or set(p) != {'statut','reference','date','perimetre'}: return False
        if any(type(p[k]) is not str or not p[k] for k in p): return False
        if p['statut'] != 'reussite' or not url_https(p['reference']) or not date_iso(p['date']): return False
    return True

Tests

E=['tests','source']; P={k:{'statut':'reussite','reference':'https://exemple.test/'+k,'date':'2026-09-06','perimetre':'fictif'} for k in E}
assert pret_pour_revue(E,P)
assert not pret_pour_revue(E,{'tests':P['tests']})
assert not pret_pour_revue(['tests'],{'tests':{'statut':'reussite','reference':'http://x','date':'2026-09-06','perimetre':'x'}})
assert not pret_pour_revue(['tests'],{'tests':{'statut':'reussite','reference':'https://','date':'2026-09-06','perimetre':'x'}})
assert not pret_pour_revue(['tests'],{'tests':{'statut':'reussite','reference':'https://x.test','date':'2026-99-99','perimetre':'x'}})
for mauvais in [([],{}),([True],{}),(['tests','tests'],P)]:
    try: pret_pour_revue(*mauvais)
    except ValueError: pass
    else: raise AssertionError('dossier invalide accepté')

Trace

  • Chaque exigence trouve une preuve complète.
  • Une preuve absente rend False sans mutation.
  • Un ensemble vide est refusé avant all.

Clinique de bogue

Indice observépret_pour_revue([], {}) renvoie True et une preuve incomplète est acceptée.

Causeall sur une liste vide vaut vrai et le code ne vérifie ni statut, ni référence, ni date, ni périmètre. Le contrat doit refuser le vide, exiger des exigences distinctes et contrôler les quatre champs exacts de chaque preuve.

Poursuivre avec l’abonnement

Lire les preuves, puis construire ton dossier

Les explications, six schémas et six exemples résolus sont en accès libre.

L’abonnement ouvre les ateliers, diagnostics, transferts, douze questions corrigées, cartes et projet documentaire.

12 questions · 12 cartes. La reprise des ateliers, du quiz et des cartes reste enregistrée dans ce navigateur.

Voir les formules

Vérifier et prolonger

Sources du cours

Édition Maxdecours · Vérifié le .

Spécialité numérique et sciences informatiques, Terminale générale

  1. Programme de l’enseignement de spécialité NSI de Terminale · consulté le 2026-09-06
  2. Vade-mecum SNT et NSI · consulté le 2026-09-06
  3. Birth of the Baby · consulté le 2026-09-06
  4. A Relational Model of Data for Large Shared Data Banks · consulté le 2026-09-06
  5. RFC 1: Host Software · consulté le 2026-09-06
  6. Information Management: A Proposal · consulté le 2026-09-06
  7. About Version Control · consulté le 2026-09-06