\chapter{Architectures matérielles et systèmes d'exploitation}

\begin{exointro}{\null}
Sur un ordinateur, ouvrir un terminal.
\begin{questions}
\item  Trouvez l'adresse MAC d'une carte réseau (avec la commande \texttt{ipconfig /all} sous Windows ou \texttt{ifconfig} sous Linux ou macOS).
\item À l'aide de la commande \texttt{ping} suivie de l'adresse Internet du site,\linebreak trouver l'adresse IP des sites bsky.app et www.google.fr. 

Y a-t-il des différences d'affichage ?
\item À l'aide de la commande \texttt{traceroute} (Linux/macOS) ou \texttt{tracert} (Windows), suivie de l'adresse IP du site, trouver les routeurs rencontrés pour accéder au site bsky.app.
\end{questions}
\end{exointro}

\section{Architecture séquentielle}

\subsection{Schéma de référence}

En 1834, Charles Babbage eut l'idée d'incorporer dans la machine à calculer des
cartes perforées pour donner la suite d'instructions à exécuter. Il ne put jamais réaliser sa machine la plus performante, faute de fonds suffisants. 

\newpage

Ada Lovelace, qui travailla avec Babbage, écrivit le premier véritable programme informatique de l'histoire. Son portrait figure d'ailleurs sur les hologrammes\linebreak d'authentification des produits Microsoft.

Depuis cette époque, le schéma qui sert de référence est celui-ci :

\Par

\begin{center}
\includegraphics{188_144_05-schema}
\end{center}


\subsection{L'architecture de Von Neumann}

L'architecture générale des ordinateurs a été imaginée par John Von Neumann, mathématicien et physicien américano-hongrois, en 1945. 

L'architecture de Von Neumann décompose l'ordinateur en 4 parties distinctes :

\begin{itemize}
\item l'\textit{unité arithmétique et logique} (UAL ou ALU en anglais) ou \textit{unité de traitement} : son rôle est d'effectuer les opérations de base;
\item l'\textit{unité de contrôle}, chargée de la partie séquentielle des opérations;
\item la \textit{mémoire} qui contient à la fois les données et le programme qui indiquera à l'unité de contrôle quels sont les calculs à faire sur ces données. La mémoire se divise entre mémoire volatile (programmes et données en cours de fonctionnement) et mémoire permanente (programmes et données de base de la machine);
\item les dispositifs d'entrée-sortie, qui permettent de communiquer avec le monde extérieur.
\end{itemize}

L'UAL et l'unité de commande sont regroupés dans le processeur, qui communique avec la mémoire par un bus. Ces composants constituent l'\textit{unité centrale}, située sur la carte mère d'un ordinateur.

Le tout est rythmé par une horloge interne qui détermine la \textit{fréquence} du processeur.

\begin{Exemple}
le processeur Intel Core i7-9700 K peut atteindre 4,9 GHz (selon le constructeur), c'est-à-dire \numprint{4900000000} cycles d'horloge par seconde.
\end{Exemple}

\subsubsection{UAL}

L'unité arithmétique et logique est le cœur de l'ordinateur.

On la représente habituellement par ce schéma :

\Par

\begin{center}
\begin{minipage}{5cm}
\includegraphics{189_145_05-UAL}
\end{minipage}
\begin{minipage}{6cm}
\begin{itemize}
\item A et B sont les opérandes (les entrées);
\item R est le résultat;
\item F est une fonction binaire (l'opération à effectuer);
\item D est un drapeau indiquant un résultat secondaire de la fonction (signe, erreur,\linebreak division par zéro, ...).
\end{itemize}
\end{minipage}
\end{center}

Les opérations que peuvent réaliser une UAL de base sont :
\begin{itemize}
\item les additions, soustractions, multiplications et divisions;
\item les opérations logiques (ET, OU, NON);
\item les opérations de comparaison ($>$, $<$ et $=$).
\end{itemize}

Certaines UAL sont spécialisées (calcul sur les nombres en virgule flottante, cartes graphiques, cartes sons...). Un même processeur peut comporter plusieurs UAL. Dans certaines architectures, les UAL sont spécialisées et ne fonctionnent pas simultanément, dans d'autres les UAL fonctionnent en parallèle (architectures multi-cœur). Les architectures multi-cœur permettent d'augmenter la puissance de calcul.

Les UAL fonctionnent à l'aide de circuits électroniques qui exécutent des\linebreak fonctions binaires.

\subsubsection{Mémoire}

La mémoire est un composant qui peut être vu comme un tableau dans lequel seront stockés aussi bien les variables que les programmes. Chaque case de ce tableau possède une adresse X et la valeur de chaque case est notée M[X]. Les mémoires qui existent sont :
\begin{itemize}
\item la mémoire interne vive (RAM) : elle se présente le plus souvent sous forme de barrettes que l'on peut retirer ou ajouter dans un ordinateur;
\item la mémoire interne morte (ROM) : elle sert au démarrage de l'ordinateur;
\item la mémoire externe (de masse) : ce sont les disques durs, les clés USB, etc.
\end{itemize}

\newpage

\subsubsection{L'unité de commande}

C'est elle qui donne les ordres à toutes les autres parties de l'ordinateur.

Elle dispose d'emplacements de mémoire interne, de la taille d'un mot (souvent 32 ou 64 bits suivant le processeur), accessibles très rapidement. On distingue principalement quatre registres :
\begin{itemize}
\item CO : le compteur ordinal, qui contient l'adresse de la prochaine instruction à exécuter;
\item RI : le registre d'instructions qui contient l'instruction en cours d'exécution;
\item AC : l'accumulateur chargé de stocker des opérandes intermédiaires;
\item CC : le code condition, utilisé pour les instructions de rupture conditionnelle (saut).
\end{itemize}
Son algorithme de fonctionnement est le suivant :
\begin{algorithme}{}
Répéter indéfiniment :
\quad	RI $\leftarrow$ M[CO]
\quad	CO $\leftarrow$ CO + 1
\quad	R.OP(RI.AD)
Fin du Répéter
\end{algorithme}
Autrement dit:
\begin{itemize}
\item l'instruction désignée par le compteur ordinal M[CO] est chargée dans le\linebreak registre d'instructions RI;
\item le compteur ordinal CO est incrémenté pour désigner l'instruction suivante;
\item l'opération chargée dans RI se décompose en deux parties : la fonction proprement dite désignée par OP, et l'opérande sur lequel cette fonction est exécutée, désignée par AD. L'opération désignée par OP est exécutée avec l'opérande AD.

En cas de rupture conditionnelle, le contenu du compteur ordinal CO est\linebreak remplacé par l'adresse du saut.
\end{itemize}

\subsection{Aspect séquentiel des opérations}

Le langage de base d'une machine est son langage machine, lequel est ensuite traduit en assembleur pour le rendre lisible par l'humain. Il existe presque autant de langages assembleur que de processeurs : un programme écrit en assembleur ne sera compris que par le processeur destinataire contrairement à un programme écrit dans un langage comme Python, qui sera compris par plusieurs machines.

En assembleur, dans sa forme la plus simple, une instruction est stockée dans une cellule mémoire désignée par une adresse. Elle est constituée de 2 parties :
\begin{itemize}
\item un code opération (CO) qui indique quelle opération doit être effectuée;
\item une adresse (ADR) désignant l'opérande de cette opération (son argument).
\end{itemize}

\begin{Exemple}
un algorithme de calcul d'une addition décrit par l'expression
arithmétique $z=x+y$ donnera naissance à une suite de trois instructions telles que :
\begin{itemize}
\item LD X : chargement (load) du contenu de la cellule mémoire X dans une cellule appelée accumulateur (c'est un des \textit{registres}). On note ce registre A ici;
\item ADD Y : addition du contenu de la cellule mémoire Y avec le contenu de\linebreak l'accumulateur;
\item STO Z : stockage (STO pour \textit{store}) du contenu de l'accumulateur dans la cellule mémoire Z.
\end{itemize}
LD, ADD, STO sont des codes opération, et X, Y, Z les adresses des opérandes.
\end{Exemple}

Toute expression arithmétique ou logique va être décomposée en une suite d'instructions de cette nature. L'unité de commande va alors se
charger d'enchaîner séquentiellement la suite de ces instructions calculant cette expression.

\begin{Remarque}
ce seul mécanisme ne suffit pas pour exécuter des instructions venant de langages de haut niveau (comme Python). Il faut introduire d'autres instructions dites \textit{ruptures de séquence}.
\end{Remarque}

\section{Systèmes d'exploitation}

\subsection{Fonction d'un système d'exploitation}

Programmer en assembleur n'est pas chose aisée; pourtant, c'est le langage que comprend la machine. Il est donc nécessaire d'avoir un intermédiaire entre\linebreak l'humain et la machine.


C'est le rôle principal d'un système d'exploitation (OS en anglais, pour \textit{Operating System}) : il va \og traduire \fg{} ce que nous voulons faire en langage machine afin que l'ordinateur comprenne et exécute l'action.

Le système d'exploitation va donc :

\begin{itemize}
\item fournir une interface entre l'humain et la machine;

\item gérer les ressources de l'ordinateur, à savoir sa mémoire, son processeur, ses périphériques (écrans, imprimantes, etc.), la gestion d'énergie...;


\item gérer les utilisateurs ainsi que leurs droits d'accès à certains fichiers;

\item être indépendant du matériel (un même OS peut être exécuté sur des ordinateurs n'ayant pas les mêmes composants);

\item faire en sorte de rendre concret ce qui ne l'est pas (un fichier est par essence abstrait mais nous le considérons bel et bien comme une entité concrète).
\end{itemize}

\subsection{Ligne de commande}

Chaque système d'exploitation possède un \og terminal \fg{} : c'est un sous-programme qui permet d'exécuter des tâches en écrivant les commandes (et non en cliquant sur des icônes). 
\begin{itemize}
\item Sous Windows 11, on peut lancer le terminal en faisant :
\begin{center}
[Touche Windows]+[R], puis en entrant \og cmd \fg{} et en validant.
\end{center}
Une alternative plus moderne sous Windows est PowerShell, qui permet des commandes plus avancées. Pour le lancer :
\begin{center}
[Touche Windows]+[R], puis en entrant \og powershell \fg{} et en validant.
\end{center}
\item Sous Ubuntu (distribution Linux), il est accessible en cliquant sur l'icône\linebreak adéquat (représentant un écran d'ordinateur noir).

\item Sous macOS, dans le dock, cliquer sur l'icône Finder, puis cliquer sur \textit{Applications}, puis \textit{Utilitaires}, et enfin \textit{Terminal} (représenté par un icône d'écran d'ordinateur noir).
\end{itemize}

\vspace*{-1.5em}
\begin{Remarque}
on trouvera les mêmes commandes sous Linux et macOS... Ce n'est pas un hasard car Unix est à l'origine de macOS et de Linux.
\end{Remarque}

Quelques commandes de base communes aux OS  que l'on peut utiliser dans un terminal sont :

\Par

\begin{center}
\begin{tabular}{|Zc|Zc|}
\tabulartitle\hline
Commande & Description\\
\hline
ls & Liste les fichiers et répertoires du répertoire courant\\
\hline
 cd & Change de répertoire (Change Directory)\\
\hline
rm & Supprime un fichier ou un répertoire (ReMove)\\
\hline
<commande> --help & Affiche les options de la commande\\
\hline
\end{tabular}
\end{center}

\begin{Exemples}
\begin{itemize}
\item Sous Windows, \texttt{cd/} mène à la racine du disque dur.
\item \texttt{rm toto.txt} supprime le fichier \og toto.txt \fg.
\end{itemize}
\end{Exemples}
Certaines commandes ne sont pas identiques selon que l'on est sous Windows ou Linux/macOS :
\vspace*{-3mm}
\begin{center}
\begin{tabular}{|Zc|Zc|Zc|}
\tabulartitle\hline
Windows & Linux/macOS & Description\\
\hline
copy & cp & Copie un fichier à un autre endroit ou sous un autre nom\\
\hline
move & mv & Déplace un fichier ailleurs\\
\hline
ren & mv &  Renomme un fichier\\
\hline
\end{tabular}
\end{center}
\enlargethispage*{5em}
\begin{Exemples}
\begin{itemize}
\item Sous Windows, \texttt{copy toto.txt fichiers/temp.txt} copie le fichier \og toto.txt \fg{}  se trouvant dans le répertoire courant dans le répertoire \textit{fichiers/} sous le nom de \og temp.txt \fg.

\item Sous Ubuntu, \texttt{mv toto.txt fichiers} déplace le fichier \og toto.txt \fg{} dans le répertoire \textit{fichiers/}.
\end{itemize}
\end{Exemples}

\subsection{Droits et permissions}

Par défaut, quel que soit le système d'exploitation utilisé, chaque fichier et répertoire a un droit d'accès et des permissions (d'être lu, modifié ou exécuté).

Ces droits sont visibles en cliquant avec le bouton droit de la souris sur le fichier ou répertoire afin d'afficher un menu contextuel, et en sélectionnant \textit{Propriétés}.

Sous Ubuntu, on a la fenêtre :
\begin{center}
\includegraphics{193_149_05-droits01-marron}
\end{center}

Sous Windows, on a la fenêtre :
\begin{center}
\includegraphics{193_149_05-droits02-marron}
\end{center}

Vous pouvez ainsi, grâce à l'interface graphique, changer facilement les droits d'accès à un fichier, ainsi que les permissions (droits d'écriture, de lecture, lecture et exécution, etc.).

\section{Réseaux}

\subsection{Principe de base}

Quand un ordinateur souhaite transmettre des données à un autre, il suit les étapes suivantes :
\begin{itemize}
\item les données sont transmises au système d'exploitation à l'aide d'une application;
\item celui-ci les coupe en plusieurs paquets, les numérote, et les transmet à la carte réseau;
\item celle-ci les envoie sur le réseau;
\item le carte réseau de l'ordinateur destinataire reçoit les paquets transmis, et les envoie au système d'exploitation;
\item l'OS reconstitue le message et le transmet à l'application de destination.
\end{itemize}

C'est ce que l'on appelle le \textit{modèle en couches}.

Le modèle OSI (\textit{Open Systems Interconnection}) contient 7 couches et le TCP/IP en contient 4 :

\Par

\begin{center}
\includegraphics{194_150_05-OSI-TCPIP}
\end{center}


\subsection{Encapsulation des données}

Lorsqu'elles passent par une couche, les données sont \og complétées \fg{} par un en-tête spécifique à la couche traversée. C'est ce que l'on appelle l'\textit{encapsulation}.



\begin{Exemple}
en suivant le protocole TCP/IP, lorsqu'un paquet passe par la carte réseau par exemple, l'en-tête adjointe contient l'adresse MAC (\textit{Medium Access Control}), une suite de 6 nombres exprimés en hexadécimal, comme 4C-BB-58-BC-45-49. 
\end{Exemple}

À la réception des paquets, les en-têtes sont enlevés : on appelle cela la\linebreak \textit{décapsulation}.

\begin{center}
\includegraphics{195_151_05-encapsulation}
\end{center}




\subsection{Protocole du bit alterné}
\NathanLiveVideo[\PictoVideo\ Retrouvez ce protocole en vidéo.]{protocole du bit alterné}{https://media.prepamath.fr/IL1NSIch06crs01}

\qrset{height=1.1cm,version=5}\rput(-1,0.3){
\psframebox{\qrcode{https://media.prepamath.fr/IL1NSIch06crs01}}}
\vspace*{-10pt}

\enlargethispage*{3em}

\subsubsection{Principe}

%Le protocole du bit alterné (\textit{alternating bit protocol}) fait
%partie de la couche liaison de données (seconde couche du modèle OSI et
%première couche du modèle TCP/IP). Il permet de transférer des données
%entre deux entités pour lesquelles une connexion bi-directionnelle a
%été établie, de façon à ce qu'il n'y ait pas d'erreur dans la
%transmission.
%
%\Par
%
%Appelons $(T)$ la première entité, celle qui transmet les données à la seconde entité, que l'on va noter $(R)$  comme \textit{réceptrice} (\textit{receiver}).
%
%Dans l'idéal, c'est-à-dire quand tout se passe bien, le protocole du bit alterné fait que $(T)$ envoie un message à $(R)$ et à la réception de ce message, $(R)$ renvoie un \textit{acquittement} à $(T)$ (\textit{acknowledgment}).
%
%Mais il se peut que la liaison entre $(T)$ et $(R)$ ne soit pas fiable. Il est donc possible que certains messages ou certains acquittements se perdent.
%
%
%Afin de voir s'il y a des pertes, le protocole stipule que:
%
%\begin{itemize}
%\item chaque message et chaque acquittement correspondant contiennent un même bit de contrôle. Par exemple, le premier message contient le bit de contrôle \og 0 \fg, et son acquittement contient aussi le bit de contrôle \og 0 \fg;
%
%\item deux messages successifs contiennent des bits différents (la valeur du bit de contrôle alterne à chaque émission).
%\end{itemize}
%
%Si l'entité $(T)$ reçoit une indication de perte d'acquittement (on la note \textit{NACK0} ou \textit{NACK1} suivant le bit de contrôle) ou un acquittement avec un bit de contrôle erroné (noté \textit{ACK0} ou \textit{ACK1}), elle émet à nouveau le dernier message envoyé.
%
%Si l'entité $(R)$ reçoit une indication de perte de message ou un message avec un bit de contrôle erroné, elle émet à nouveau le dernier acquittement envoyé.
%
%Pour chaque message envoyé, un délai de vérification des acquittement doit être respecté.
Le protocole du bit alterné (\textit{alternating bit protocol}) fait
partie de la couche liaison (seconde couche du modèle OSI et
couche accès réseau du modèle TCP/IP). Il permet de transférer des données
entre deux entités, de façon à ce qu'il n'y ait pas d'erreur dans la
transmission.

\Par

Appelons $(T)$ la première entité, celle qui transmet les données à la seconde entité, que l'on va noter $(R)$ comme \textit{réceptrice}.

Dans l'idéal, c'est-à-dire quand tout se passe bien, le protocole du bit alterné fait que $(T)$ envoie un message à $(R)$ et à la réception de ce message, $(R)$ renvoie un \textit{acquittement} à $(T)$ (\textit{acknowledgment}). Mais il se peut que la liaison entre $(T)$ et $(R)$ ne soit pas fiable. Il est donc possible que certains messages ou certains acquittements se perdent.

Afin de détecter s'il y a des pertes, le protocole stipule que :
\begin{itemize}
\item chaque message et chaque acquittement correspondant contiennent un même bit de contrôle. Par exemple, le premier message contient le bit de contrôle \og 0 \fg, et son acquittement contient aussi le bit de contrôle \og 0 \fg;

\item deux messages successifs contiennent des bits différents (la valeur du bit de contrôle alterne à chaque émission).
\end{itemize}

Si, après l'émission d'un message par l'entité $(T)$ (par exemple avec le bit de contrôle \og 0 \fg), aucun acquittement correspondant (noté \textit{ACK0}) n'est reçu au bout d'une certaine durée, ou si un acquittement avec un bit de contrôle erroné (noté \textit{ACK1}), elle émet à nouveau le dernier message envoyé, avec le même bit de contrôle (\og 0 \fg).

Si l'entité $(R)$ reçoit un message avec un bit de contrôle différent de celui attendu, elle émet à nouveau le dernier acquittement envoyé.

\newpage

\subsubsection{Non réception du message}

Un message est découpé en plusieurs blocs : $M_0$, $M_1$, etc. Par défaut, on attribue le bit de contrôle \og 0 \fg{} à $M_0$. 

$M_0$ est donc transmis de $(T)$ à $(R)$ avec le bit de contrôle \og 0 \fg. %Si le transfert n'est pas correctement fait alors $(R)$ va renvoyer un acquittement négatif à $(T)$ : \textit{NACK0}. Dans ce cas, $(T)$ transfert à nouveau $M_0$.
Si le transfert n'est pas correctement fait, $(R)$ ne renvoie pas d'acquittement. Au bout d'une durée prédéfinie, sans réception d'acquittement, $(T)$ transfère à nouveau $M_0$.

\begin{center}
\includegraphics{196_152_05-bit-alterne-01}
\end{center}


\subsubsection{Non réception de l'acquittement}

Il se peut que l'acquittement lui-même ne soit pas délivré correctement ou ne soit pas délivré dans le délai imparti. Dans ce cas, le message est renvoyé.

\begin{center}
\includegraphics{196_152_05-bit-alterne-02}
\end{center}

\newpage

\subsubsection{Chevauchement de messages}

Dans le cas où un message met trop longtemps à parvenir à $(R)$, il est transmis à nouveau après que le délai d'attente soit passé. Dans ce cas, le message reçu après est écarté.
\begin{center}
\includegraphics{197_153_05-bit-alterne-03}
\end{center}


\subsubsection{Chevauchement d'acquittements}

Dans le cas où un acquittement met trop longtemps à parvenir à $(T)$, le message est transmis à nouveau après que le délai d'attente soit passé. Dans ce cas, le message dont l'acquittement est reçu après est écarté.
\begin{center}
\includegraphics{197_153_05-bit-alterne-04}
\end{center}

\begin{Remarque}
il existe bien entendu d'autres possibilités, mais ce protocole n'étant plus utilisé dans la pratique, nous ne nous attarderons pas sur tous les différents cas possibles.
\end{Remarque}


\newpage

\subsection{Architecture d'un réseau}

Il existe 4 catégories de réseaux :

\begin{itemize}
\item le réseau personnel (PAN : Personal Area Network), qui relie des machines sur quelques mètres;

\item le réseau local (LAN : Local Area Network), adapté à la taille d'un site d'entreprise;

\item le réseau \textit{métropolitain} (MAN : Metropolitan Area Network), étendu à l'échelle d'une ville;


\item le réseau \textit{étendu} (WAN : Wide Area Network), pour une grande zone géographique, comme un pays ou un continent.
\end{itemize}

Nous ne nous intéresserons ici qu'aux réseaux de type LAN.

Il existe 3 topologies pour un tel réseau.


\subsubsection{Topologie en bus}

\Par

\begin{center}
\includegraphics{198_154_05-Topologie-en-bus}
\end{center}

\Par

Le \textit{bus} est ici un câble auquel sont reliées les machines.

L'un des avantages du bus réside dans la simplicité de sa mise en \oe uvre et son moindre coût. 

Parmi les inconvénients, on peut citer qu'en cas de rupture du bus, le réseau\linebreak devient inutilisable. De plus, le signal n'est jamais régénéré, ce qui limite la\linebreak longueur des câbles. 

\newpage

\subsubsection{Topologie en anneau}

\Par

\begin{center}
\includegraphics{199_155_05-Topologie-en-anneau}
\end{center}

\Par

Parmi les avantages, cette topologie permet d'avoir un débit proche de 90\;\% de la bande passante. De plus, le signal qui circule est régénéré par chaque station. 

Dans les inconvénients, on peut citer le fait que si un poste tombe en panne, le réseau ne fonctionne plus. De plus, plus le nombre de machines augmente, plus la transmission d'une information est longue.

En réalité, les ordinateurs d'un réseau en anneau ne sont pas reliés en boucle, mais sont reliés à un répartiteur (appelé MAU, \textit{Multistation Access Unit}) qui va gérer la communication entre les ordinateurs qui lui sont reliés en impartissant à chacun d'entre eux un temps de parole.

\subsubsection{Topologie en étoile}

\Par


\begin{center}
\includegraphics{199_155_05-Topologie-en-etoile}
\end{center}

\Par

Cette topologie est la plus courante. 

Toutes les stations sont reliées à un unique composant central : % le concentrateur. Quand une station émet vers le concentrateur, celui-ci envoie les données à celle qui en est le destinataire (switch) ou à toutes les autres machines (hub).
le concentrateur (hub) ou le commutateur (switch). Le concentrateur rediffuse le message d'une station à toutes les autres stations qui lui sont connectées alors que le commutateur envoie le message uniquement à la station destinataire.

\newpage

Ce type de réseau est facile à mettre en place et à surveiller. La panne d'une station ne met pas en cause l'ensemble du réseau. En revanche, il faut plus de câbles que pour les autres topologies, ce qui engendre un coût plus élevé que les autres topologies, et si le concentrateur tombe en panne, tout le réseau est hors d'état de fonctionner. De plus, le débit pratique est moins bon que pour les autres topologies.


\begin{solintro}
\begin{questions}
\item  Avec la commande \texttt{ipconfig /all} ou \texttt{ifconfig}, on obtient une suite de paragraphes. Dans chacun d'eux concernant une carte réseau figure une \og adresse physique \fg{}: c'est l'adresse MAC de la carte, qui est de la forme \texttt{45:7a:df:8b:9c:78}.

\item À l'aide de la commande \texttt{ping bsky.app}, on obtient que l'adresse IP de ce site est \texttt{18.224.121.90}.

À l'aide de la commande \texttt{ping www.google.fr}, on obtient que l'adresse IP de ce site est \texttt{2a00:1450:400c:c0a::5e}. 


On constate qu'il y a une différence d'affichage : la première IP est une IPv4, la seconde une IPv6.

\item À l'aide de la commande \texttt{traceroute 18.224.121.90} ou \texttt{tracert 18.224.121.90}, on peut voir que l'on passe (si on est chez nous) par notre box Internet, un n\oe  ud à proximité de chez nous (par lequel passe la connexion de vos voisins s'ils ont le même fournisseur d'accès à Internet), éventuellement d'autres routeurs de votre ville et d'ailleurs... jusqu'à arriver finalement au serveur web de BlueSky.
\end{questions}
\end{solintro}