\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Mise au point et débogage}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Mise au point et débogage} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{terminaledebogageterminale}{
  \begin{question}{q01}
    Qu'est-ce qu'une \textbf{exception} en Python ?
    \begin{choices}
    \wrongchoice{Un type de variable particulier}
    \wrongchoice{Un simple avertissement qui n'interrompt pas le programme}
    \correctchoice{Une erreur signalée durant l'exécution, qui interrompt le flux normal du programme sauf si elle est capturée}
    \wrongchoice{Un commentaire spécial inséré dans le code}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q02}
    Comment \textbf{gérer} une exception sans que le
programme ne s'interrompe ?
    \begin{choices}
    \wrongchoice{Aucun moyen ne permet d'éviter l'arrêt du programme}
    \correctchoice{\begin{lstlisting}
try:
    risque()
except Exception as e:
    print("Erreur :", e)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
catch risque() {}
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
if risque() == error: ...
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q03}
    Quel module de la bibliothèque standard de
Python permet de déboguer interactivement ?
    \begin{choices}
    \wrongchoice{\texttt{fix}}
    \wrongchoice{\texttt{error}}
    \correctchoice{\texttt{pdb}}
    \wrongchoice{\texttt{debug}}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q04}
    Pourquoi préfère-t-on le module \texttt{logging} à
\texttt{print} pour le débogage en production ?
    \begin{choices}
    \correctchoice{Pour pouvoir activer ou désactiver les messages, choisir leur niveau de gravité (\texttt{debug}, \texttt{info}, \texttt{warning}, \texttt{error}, \texttt{critical}) et les rediriger vers un fichier}
    \wrongchoice{Parce que la fonction \texttt{print} n'existe pas en Python}
    \wrongchoice{Pour économiser de l'espace de stockage}
    \wrongchoice{Aucun avantage particulier}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q05}
    Que désigne-t-on par le \textbf{profilage} d'un
programme ?
    \begin{choices}
    \wrongchoice{Établir une description de son auteur}
    \correctchoice{Mesurer où le programme passe son temps et consomme la mémoire, afin d'identifier les parties les plus coûteuses}
    \wrongchoice{Compresser le code pour gagner de la place}
    \wrongchoice{Lancer le programme plusieurs fois pour vérifier sa stabilité}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q06}
    Qu'est-ce qu'un \textbf{test d'intégration} ?
    \begin{choices}
    \wrongchoice{Un test gratuit, sans contrepartie}
    \wrongchoice{Un test qui vérifie l'intégrité de la pile d'exécution}
    \wrongchoice{Un test qui ne déclenche jamais d'erreur}
    \correctchoice{Un test qui vérifie que plusieurs modules fonctionnent correctement ensemble, et pas seulement chacun isolément}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q07}
    Que représente la \textbf{trace d'erreur}
affichée par Python à la suite d'une
exception non capturée ?
    \begin{choices}
    \wrongchoice{Un fichier journal stocké sur le disque}
    \wrongchoice{Le code source complet du programme}
    \correctchoice{La suite des appels de fonctions au moment où l'exception a été levée, chaque ligne indiquant la fonction appelante}
    \wrongchoice{Un type de mémoire interne au système}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q08}
    À quoi sert un \textbf{point d'arrêt} dans un
débogueur ?
    \begin{choices}
    \wrongchoice{À empêcher d'écrire du code dans une certaine zone}
    \wrongchoice{À supprimer définitivement le programme}
    \correctchoice{À suspendre l'exécution à une ligne précise pour inspecter les variables et progresser pas à pas}
    \wrongchoice{À enregistrer automatiquement le programme}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q09}
    Pourquoi est-il \textbf{essentiel} de pouvoir
reproduire un bug avant de le corriger ?
    \begin{choices}
    \wrongchoice{Pour pouvoir le montrer à l'utilisateur final}
    \correctchoice{Parce qu'on ne peut pas vérifier qu'une correction est efficace si l'on n'arrive pas à redéclencher le bug}
    \wrongchoice{Pour s'amuser à le voir se produire}
    \wrongchoice{Aucune raison particulière}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q10}
    Quelle est l'une des techniques
systématiques pour \textbf{isoler la cause}
d'un bug dans un programme ?
    \begin{choices}
    \correctchoice{Réduire progressivement l'entrée problématique au cas le plus simple qui reproduit encore le bug, ce qui localise efficacement la zone fautive}
    \wrongchoice{Multiplier la taille de l'entrée jusqu'à observer un comportement régulier}
    \wrongchoice{Demander conseil à un collègue}
    \wrongchoice{Tout réécrire de zéro}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q11}
    Dans une fonction \texttt{racine\_carree(x)}, on
souhaite \textbf{signaler une erreur} lorsque
\texttt{x} est négatif. Quelle est la bonne
pratique ?
    \begin{choices}
    \correctchoice{Lever explicitement une exception, par
exemple avec :

\begin{lstlisting}
if x < 0:
    raise ValueError("x doit être positif")
\end{lstlisting}
}
    \wrongchoice{Renvoyer la valeur $-1$ pour signaler l'erreur}
    \wrongchoice{Afficher un message avec \texttt{print} puis renvoyer la valeur $0$}
    \wrongchoice{Continuer le calcul comme si de rien n'était}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q12}
    Dans quelles situations utilise-t-on
l'instruction \texttt{raise} en Python ?
    \begin{choices}
    \correctchoice{Pour lever explicitement une exception et signaler une erreur}
    \wrongchoice{Pour multiplier la valeur d'une variable}
    \wrongchoice{Pour incrémenter un compteur}
    \wrongchoice{Pour quitter un programme}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q13}
    Pourquoi le bloc \texttt{except:} sans
précision de type est-il \textbf{déconseillé} ?
    \begin{choices}
    \correctchoice{Parce qu'il capture toutes les exceptions, y compris \texttt{KeyboardInterrupt} (interruption clavier) et \texttt{SystemExit}, ce qui peut masquer des bugs et empêcher l'arrêt propre du programme}
    \wrongchoice{Parce qu'il est plus lent à l'exécution}
    \wrongchoice{Aucune raison ne justifie de l'éviter}
    \wrongchoice{Parce que la syntaxe \texttt{except:} n'existe pas en Python}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q14}
    À quoi sert le bloc \texttt{finally} dans une
structure \texttt{try / except} ?
    \begin{choices}
    \correctchoice{À exécuter du code dans tous les cas, qu'il y ait eu une exception ou non. Il est utile pour les opérations de nettoyage (fermeture de fichiers, libération de ressources)}
    \wrongchoice{À ralentir intentionnellement l'exécution}
    \wrongchoice{À empêcher la levée des exceptions}
    \wrongchoice{À exécuter du code uniquement en cas d'erreur}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q15}
    Comment \textbf{mesurer} où un script Python
passe le plus de temps ?
    \begin{choices}
    \wrongchoice{Avec un chronomètre}
    \wrongchoice{En le lançant plusieurs fois et en chronométrant}
    \wrongchoice{Il est impossible de mesurer cela en Python}
    \correctchoice{Avec la commande \texttt{python -m cProfile -s time script.py}}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q16}
    Qu'est-ce qu'un \textbf{test de régression} ?
    \begin{choices}
    \correctchoice{Un test ajouté après avoir corrigé un bug, afin de vérifier que ce bug ne réapparaisse pas lors de modifications ultérieures du code}
    \wrongchoice{Un test trop simple pour être utile}
    \wrongchoice{Un test exécuté sur l'ancienne version du code}
    \wrongchoice{Un test qui revient en arrière dans le code source}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q17}
    Que désigne la méthode dite \textbf{du canard
en plastique} en débogage ?
    \begin{choices}
    \wrongchoice{Une méthode de compression de code}
    \wrongchoice{Un type particulier de test automatique}
    \correctchoice{La technique consistant à expliquer son code à voix haute, à un objet ou à un interlocuteur, ce qui force à clarifier sa pensée et révèle souvent l'origine du bug}
    \wrongchoice{L'utilisation d'un canard en plastique magique pour résoudre les bugs}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q18}
    Que produit une \textbf{trace d'exécution} d'un
programme ?
    \begin{choices}
    \wrongchoice{Une optimisation du code}
    \correctchoice{Un journal des étapes effectivement exécutées par le programme, incluant les entrées et sorties de fonctions et les valeurs des variables clés}
    \wrongchoice{Une erreur d'exécution}
    \wrongchoice{Une simple copie du code source}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q19}
    Quelle est la différence entre une
\textbf{assertion} et la gestion d'exception ?
    \begin{choices}
    \wrongchoice{Aucune différence}
    \wrongchoice{Les assertions s'exécutent plus rapidement}
    \wrongchoice{Les exceptions n'existent pas en Python}
    \correctchoice{Les assertions vérifient des invariants (des conditions qui ne devraient jamais être fausses) et signalent un bug. Les exceptions, elles, gèrent des conditions exceptionnelles attendues (entrée invalide, fichier manquant) et peuvent être capturées et traitées}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q20}
    Quels \textbf{outils} d'un environnement de
développement intégré facilitent le
débogage ?
    \begin{choices}
    \correctchoice{L'inspecteur de variables, la navigation pas à pas, les points d'arrêt conditionnels, la console interactive et l'analyseur statique}
    \wrongchoice{Aucun outil particulier n'aide au débogage}
    \wrongchoice{Uniquement la coloration syntaxique}
    \wrongchoice{Le simple choix d'un clavier en disposition QWERTY}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q21}
    Qu'appelle-t-on un \textbf{bug fantôme} ou
\textit{Heisenbug}, en référence au principe
d'incertitude de Heisenberg ?
    \begin{choices}
    \wrongchoice{Un bug provenant d'un programme allemand}
    \wrongchoice{Un bug visible uniquement la nuit}
    \correctchoice{Un bug qui disparaît ou change lorsqu'on tente de l'observer (par exemple, en ajoutant des \texttt{print} ou en lançant le programme dans un débogueur). L'origine est souvent liée à des problèmes de synchronisation ou de mémoire non initialisée}
    \wrongchoice{Un bug que l'on ne parvient pas à reproduire}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q22}
    Qu'appelle-t-on une \textbf{fuite de mémoire} ?
    \begin{choices}
    \wrongchoice{De l'eau qui s'infiltre dans l'ordinateur}
    \wrongchoice{Une optimisation du programme}
    \correctchoice{Une situation dans laquelle le programme conserve des références à des données dont il n'a plus besoin, accumulant ainsi la mémoire utilisée jusqu'à un éventuel arrêt brutal}
    \wrongchoice{La perte d'un fichier sur le disque}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q23}
    Face à un programme qui écrit
régulièrement dans un journal
d'exécution, quelle stratégie
d'analyse est la plus efficace
lorsqu'un bug est signalé en
production ?
    \begin{choices}
    \wrongchoice{Lire l'intégralité du journal depuis le début, ligne par ligne}
    \wrongchoice{Effacer le journal et redémarrer le programme}
    \wrongchoice{Désactiver le journal et compter sur les utilisateurs pour signaler les erreurs}
    \correctchoice{Localiser dans le journal la fenêtre temporelle proche de l'erreur, puis remonter à rebours en cherchant le premier événement anormal qui a précédé l'erreur observée}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q24}
    Quelle est la \textbf{bonne méthodologie}
générale lorsqu'on est confronté à un
bug ?
    \begin{choices}
    \wrongchoice{Réécrire l'intégralité du programme}
    \wrongchoice{Demander la solution à un collègue}
    \wrongchoice{Modifier le code au hasard jusqu'à ce que le bug disparaisse}
    \correctchoice{Reproduire le bug, isoler la cause
(par réduction au cas minimal ou
avec un débogueur), corriger le
code, ajouter un test de
régression, puis documenter si
pertinent
}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q25}
    Parmi les affirmations suivantes sur la
mise au point des programmes, laquelle
est \textbf{fausse} ?
    \begin{choices}
    \correctchoice{La règle d'or consiste à corriger d'abord le bug, puis à essayer de le reproduire}
    \wrongchoice{La construction \texttt{try / except} permet de capturer des exceptions}
    \wrongchoice{Le profilage indique où, dans le code, le programme passe son temps}
    \wrongchoice{Une assertion qui échoue signale typiquement un bug dans le programme}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q26}
    Quel est l'avantage d'écrire
\begin{lstlisting}
with open("fichier.txt") as f:
    contenu = f.read()
\end{lstlisting}
par rapport à
\begin{lstlisting}
f = open("fichier.txt")
contenu = f.read()
f.close()
\end{lstlisting}
?
    \begin{choices}
    \wrongchoice{La construction \texttt{with} permet
d'écrire dans le fichier sans
ouvrir un mode d'écriture
}
    \wrongchoice{La construction \texttt{with} est
obligatoire en Python depuis la
version 3
}
    \wrongchoice{La construction \texttt{with} est plus
rapide à l'exécution
}
    \correctchoice{La construction \texttt{with} ferme
automatiquement le fichier à
la sortie du bloc, même si une
exception est levée pendant la
lecture, ce qui évite les fuites
de descripteurs de fichier
}
    \end{choices}
  \end{question}
}

\element{terminaledebogageterminale}{
  \begin{question}{q27}
    Donald Knuth a écrit en 1974 :
« \textbf{L'optimisation prématurée est la
racine de tous les maux} ». Quelle est
la signification pratique de cette
maxime pour le développement logiciel ?
    \begin{choices}
    \wrongchoice{Il faut optimiser dès la première
ligne de code écrite
}
    \wrongchoice{Cette maxime ne s'applique qu'aux
programmes anciens, pas aux
programmes modernes
}
    \wrongchoice{Il ne faut jamais optimiser un
programme
}
    \correctchoice{Il faut d'abord écrire un code
correct et lisible, puis,
seulement si nécessaire et
après mesure, optimiser les
parties effectivement coûteuses
identifiées par le profilage
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{terminaledebogageterminale}
  \insertgroup{terminaledebogageterminale}
}

\end{document}
