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.
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.
- Enquêter : d’une date isolée à une affirmation contrôlable8 à 16 min
- Matériel et logiciel : modifier une instruction, pas seulement câbler une fonction8 à 15 min
- Données : relier des faits sans confondre modèle, fichier et transaction8 à 15 min
- Internet et Web : lire une RFC, une proposition et un déploiement8 à 16 min
- Logiciels et collectifs : attribuer un rôle sans écrire une galerie de héros8 à 15 min
- 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.
É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.
| Repère | Objet | Conclusion bornée |
|---|---|---|
| 21 juin 1948 | Date portée par la notice | La notice situe une exécution |
| Manchester Baby | Machine expérimentale | La 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
- 1936 désigne ici un article : l’objet est un texte qui présente un modèle.
- Le 21 juin 1948 désigne une exécution documentée sur une machine expérimentale.
- Les repères éclairent le lien entre théorie et réalisation sans prouver une causalité unique.
- 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.
É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.
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.
Exemples résolus et erreurs expliquées
Suivre ADD 3
- Le compteur sélectionne ADD 3.
- 3 est une adresse et mène à la valeur 7.
- L’accumulateur devient 5 + 7 = 12.
- 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.
É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.
- 1Sourceid unique ; titre associé
- 2Affirmationid, texte, source_id
- 3Validationtypes, doublons, référence
- 4Ré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
- Vérifier les identifiants entiers stricts et uniques.
- Construire l’index des sources après validation.
- Associer à l’affirmation le titre Notice sans modifier les listes.
- 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.
É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.
| Repère | Objet | Ce que le document permet de dire |
|---|---|---|
| Mars 1989 | Proposition au CERN | Une solution est envisagée |
| Mai 1990 | Date ajoutée au document | Le texte est redistribué avec cette date |
| 1990 | Écriture du code | Le 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é
- Les versions communes sont 2 et 3.
- Le minimum 2 conserve les deux.
- La règle choisit 3.
- 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.
É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.
- 1Tracedocument consulté
- 2Fichepersonne, rôle, objet
- 3RéférenceURL et portée
- 4Indexretrouver 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
- Les deux rôles de p-1 sont conservés.
- p-2 est signalé mais non indexé comme fait sourcé.
- Aucun score ne compare p-1 et p-2.
- 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.
É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.
- 1Sourcefait situé et portée
- 2Testfonction fictive
- 3Capturerendu observé
- 4Revuelecture 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
- La fonction vérifie chaque exigence attendue.
- Chaque preuve porte une URL HTTPS, une date ISO et un périmètre.
- True signifie seulement prêt pour revue.
- 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 TrueTests
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 Déjà abonné ? Se connecterVérifier et prolonger
Sources du cours
Édition Maxdecours · Vérifié le .
Spécialité numérique et sciences informatiques, Terminale générale
- Programme de l’enseignement de spécialité NSI de Terminale · consulté le 2026-09-06
- Vade-mecum SNT et NSI · consulté le 2026-09-06
- Birth of the Baby · consulté le 2026-09-06
- A Relational Model of Data for Large Shared Data Banks · consulté le 2026-09-06
- RFC 1: Host Software · consulté le 2026-09-06
- Information Management: A Proposal · consulté le 2026-09-06
- About Version Control · consulté le 2026-09-06
© 2026 Maxdecours.com · Comprendre et progresser