Programme Leçon 152 sur 156 · Projet final : choisis un projet
Projet final : choisis un projet

Comment le monde caché te note

Pourquoi c'est important Si tu sais exactement ce qui est vérifié, tu peux concentrer tes efforts dessus au lieu de deviner. Savoir comment marche la vérification te dit aussi pourquoi elle est juste : personne ne peut réussir en copiant des réponses, donc une réussite veut dire que tu as vraiment construit la chose.

Pense à l'examen du permis de conduire. Tu t'entraînes dans les rues près de chez toi jusqu'à en connaître chaque virage. Le jour J, l'examinateur choisit un trajet que tu n'as jamais fait. Le code de la route est le même, mais les rues sont nouvelles, donc la seule façon de réussir est de vraiment savoir conduire.

Plusieurs de tes projets d'étape ont été notés exactement ainsi : le labo de traqueurs de l'étape 2, le rapport sur l'appareil de l'étape 5 et la batterie cachée de traqueurs de l'étape 6 ont fait tourner ton code sur un monde caché avec les mêmes règles mais d'autres sites, noms, traqueurs et visiteurs. Quand tu pousses ton projet vitrine une étape plus loin, teste cette étape de la même façon : sur un monde sur lequel tu ne l'as pas réglé.

Monde caché : un monde d'entraînement que tu n'as pas vu, construit par le même générateur que celui sur lequel tu t'es entraîné, mais à partir d'une autre graine. Il ne sert qu'à la notation.

Graine (seed) : le nombre de départ d'un générateur aléatoire. La même graine construit toujours le même monde, et une autre graine en construit un autre. C'est ainsi que la notation peut être juste pour tous tout en restant nouvelle pour toi.

Deux types de vérification

  • Un rapport vérifié face à un monde caché (les projets des étapes 2 et 5). Ton code examine le monde caché et écrit un rapport JSON ; la vérification le compare avec ce qu'elle sait vraiment présent.
  • Des tests cachés (la plupart des labos, et les projets des étapes 3, 4, 6 et 7). La vérification appelle tes fonctions avec des entrées que tu n'as pas vues et contrôle les résultats.

La présentation écrite de ton projet final (leçon suivante) n'est pas notée par une machine : c'est la partie que tu montres à une personne. Ça garde les vérifications automatiques sur ce qu'une machine peut juger équitablement.

JSON : un format texte simple pour les données, fait de listes entre crochets et de valeurs étiquetées entre accolades. Un dict et une liste Python se transforment en JSON presque à l'identique.

À quoi ressemble la vérification d'un rapport

Un rapport, c'est juste des constats structurés. Si tu pousses le projet de l'étape 3 une étape plus loin jusqu'à un audit complet d'une boutique d'entraînement, un rapport pourrait ressembler à ceci :

{
  "site": "shopa.example",
  "third_parties": ["adco.example", "cdn.example"],
  "trackers": ["adco.example"],
  "cookies": [{"name": "uid", "domain": "adco.example", "third_party": true}],
  "csp_present": false
}

Le correcteur lui pose quelques questions simples. Est-ce du JSON valide ? Les champs exigés sont-ils là, avec les bons types ? Et pour chaque constat : est-il vraiment présent dans le monde caché ?

Réussites, ratés et fausses alertes

Un détecteur de fumée peut avoir raison ou tort de deux façons différentes. Il peut rester silencieux pendant un vrai incendie (un raté), ou sonner alors que tu as juste fait griller du pain (une fausse alerte). Un bon détecteur garde les deux au plus bas. Tes constats sont jugés de la même façon.

Vrai positif : tu as signalé quelque chose et c'est vraiment là. Faux positif : tu as signalé quelque chose qui n'est pas là (une fausse alerte). Faux négatif : quelque chose est là et tu ne l'as pas signalé (un raté).

Imagine que ton bloqueur, sur le monde caché, voit 20 requêtes de traqueurs et 80 requêtes ordinaires. Il bloque 19 des traqueurs et aussi, par erreur, 1 requête ordinaire dont une page avait besoin. Ça fait 19 réussites, 1 raté et 1 fausse alerte. À l'étape 2, tu as transformé des comptes comme ceux-là en précision (quelle part de ce que tu as bloqué était vraiment des traqueurs) et en rappel (quelle part des vrais traqueurs tu as attrapée).

Une règle de réussite pour un projet pourrait ressembler à celle du plan du cours : « au moins 95 % des requêtes de traqueurs bloquées, aucun faux positif ». Ici, 19 sur 20 fait exactement 95 %, mais l'unique requête bloquée à tort la fait quand même échouer. Dans les outils de vie privée, les deux erreurs comptent : un raté laisse passer le pistage, et une fausse alerte casse la page et apprend aux gens à désactiver l'outil.

Même code, même score

La notation est déterministe : fais tourner le même code sur le même monde caché et tu obtiens toujours le même résultat. Quand un projet vérifie la vitesse, il compte les opérations face à un budget, jamais le temps sur une horloge, donc un ordinateur portable lent n'est pas pénalisé.

Vérifie ton propre rapport avant de l'envoyer

La plupart des envois ratés ne sont pas des idées fausses ; ce sont un champ manquant ou une faute de frappe. Une toute petite vérification les attrape :

import json

report = {"site": "shopa.example", "trackers": ["adco.example"], "csp_present": False}

def missing_fields(report, required):
    # return the required field names that the report does not have
    return [name for name in required if name not in report]

print(missing_fields(report, ["site", "third_parties", "trackers", "csp_present"]))
# ['third_parties']  -> add it before you submit
print(json.dumps(report, indent=2, sort_keys=True))
Dans d'autres langages

C'est le rapport qui est noté, pas le code, donc n'importe quel langage qui écrit du JSON convient (tu peux donc réécrire ta vitrine dans le langage que tu utilises au travail).

JavaScript:

const report = { site: "shopa.example", trackers: ["adco.example"], csp_present: false };
const required = ["site", "third_parties", "trackers", "csp_present"];
console.log(required.filter(name => !(name in report)));  // [ 'third_parties' ]
console.log(JSON.stringify(report, null, 2));

Go:

type Report struct {
    Site       string   `json:"site"`
    Trackers   []string `json:"trackers"`
    CSPPresent bool     `json:"csp_present"`
}
out, _ := json.MarshalIndent(Report{Site: "shopa.example", Trackers: []string{"adco.example"}}, "", "  ")
fmt.Println(string(out))

C#:

var report = new { site = "shopa.example", trackers = new[] { "adco.example" }, csp_present = false };
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(report));

Une idée reçue

« Mon score sur le monde d'entraînement est de 100 %, donc le score caché le sera aussi. » Pas toujours. Si ton code dépend discrètement de détails du monde d'entraînement, comme une liste de noms de traqueurs que tu y as copiée, il ratera des traqueurs dans le monde caché. Ça s'appelle le surapprentissage : coller aux exemples vus au lieu de la règle qui est derrière. Teste ta logique sur quelques mondes d'entraînement construits à partir de graines différentes (par exemple build_world(seed=2) en plus de l'habituel) avant d'envoyer.

Récap

  • La notation sur un monde caché fait tourner ton travail sur un monde issu d'une graine que tu n'as pas vue, donc les réponses copiées échouent et la vraie compétence réussit.
  • Certains projets sont notés par un rapport JSON sur un monde caché, la plupart par des tests cachés ; la présentation écrite du projet final est pour des personnes, pas pour un correcteur.
  • Les constats sont jugés sur les réussites, les ratés et les fausses alertes ; les deux types d'erreur comptent.
  • La notation est déterministe et compte les opérations, pas le temps d'horloge. Vérifie toi-même les champs de ton rapport avant de l'envoyer.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.