Voici une réponse structurée et approfondie à la question :

QUESTION 1 Quels sont les enseignements essentiels que la RDC peut tirer de
son contexte historique et de l’histoire de l’informatique des superpuissances ?
La République Démocratique du Congo (RDC), en analysant son propre parcours
historique et celui des superpuissances en matière d'informatique, peut tirer
plusieurs enseignements cruciaux pour son développement socio-économique et
technologique. Ces enseignements se regroupent en deux volets : leçons issues
de son contexte historique et leçons issues de l'histoire de l'informatique des
superpuissances.

I. Enseignements tirés du contexte historique de la RDC

1. Valorisation de l'indépendance et de la souveraineté numérique L’histoire
politique et économique de la RDC montre les conséquences de la dépen-
dance vis-à-vis de puissances étrangères. La souveraineté technologique
devient donc essentielle pour éviter une nouvelle forme de domination à
travers la dépendance informatique.
2. Importance de la stabilité politique pour le développement technologique
L’instabilité chronique (guerres, corruption, faibles institutions) a ralenti
le développement technologique. La RDC doit comprendre qu’un environ-
nement stable et sécurisé est un préalable au progrès numérique.
3. Nécessité d’investir dans l’éducation et la formation locale Le manque de
main-d’œuvre qualifiée limite l’innovation. L’histoire de la RDC montre la
faiblesse des politiques éducatives en matière scientifique et technologique.
Il faut investir massivement dans les STEM (sciences, technologies, in-
génierie et mathématiques).
4. Exploitation responsable des ressources naturelles Le pays regorge de
ressources (coltan, cobalt) essentielles à l’industrie informatique mondiale.
Il doit apprendre à transformer ces ressources localement et non se contenter
de les exporter à bas prix.

II. Enseignements tirés de l’histoire de l’informatique des superpuissances

1. Le rôle stratégique de l’informatique dans le développement national Les
États-Unis, la Chine, l’Union européenne ont compris que l’informatique
est un pilier de la puissance : défense, économie, éducation, administration.
La RDC doit intégrer l’informatique dans sa stratégie de développement.
2. Investir dans la recherche et l’innovation locale Les grandes puissances ont
bâti leur avance sur des décennies de soutien à la recherche fondamentale et

1
 appliquée. La RDC peut en tirer la leçon qu’un pays ne peut être souverain
sans ses propres centres de recherche technologique.
3. La maîtrise des infrastructures numériques L’histoire des superpuissances
montre que contrôler les infrastructures (réseaux, serveurs, data centers)
est indispensable. La RDC doit renforcer ses capacités internes en cyber-
sécurité, hébergement local et connectivité.
4. La coopération internationale stratégique Les puissances utilisent aussi
la collaboration (ex. : Union européenne, accords internationaux sur
les données) pour progresser tout en préservant leurs intérêts. La RDC
peut chercher des partenariats équilibrés pour bénéficier du transfert de
technologie.
5. Anticiper les enjeux éthiques et géopolitiques du numérique La manipu-
lation de l’information, la surveillance de masse, l’intelligence artificielle
posent des défis éthiques. La RDC doit intégrer ces dimensions dans sa
politique numérique pour éviter une exploitation externe de ses données et
citoyens.
Voici un exemple de script Python simple simulant une analyse de trafic réseau
pour détecter des flux suspects provenant d’adresses IP étrangères. Ce script
illustre comment un pays peut exercer un contrôle stratégique numérique en
surveillant ses infrastructures critiques pour détecter des cyberattaques ou des
tentatives d'espionnage.

Script Python : Analyse de trafic réseau pour détection d'intrusions

import random from ipaddress import ip_address, ip_network

Liste simulée des adresses IP observées dans le

trafic réseau
simulated_traffic = [ {"ip": "[Link]", "bytes": 500}, {"ip": "[Link]", "bytes":
1000}, {"ip": "[Link]", "bytes": 3000}, {"ip": "[Link]", "bytes": 450},
{"ip": "[Link]", "bytes": 700}, {"ip": "[Link]", "bytes": 2500}, {"ip":
"[Link]", "bytes": 2800}, {"ip": "[Link]", "bytes": 4000}, ]

Plages d’IP internes (réseaux privés non suspects)

internal_networks = [ ip_network("[Link]/16"), ip_network("[Link]/8"),
ip_network("[Link]/12"), ]

2
Détection d’IP étrangères suspectes
def is_foreign(ip): ip_obj = ip_address(ip) for network in internal_networks:
if ip_obj in network: return False return True
def detect_intrusions(traffic): print("Analyse du trafic réseau...") for flow in traf-
fic: ip = flow["ip"] if is_foreign(ip) and flow["bytes"] > 1000: print(f"[ALERTE]
Flux suspect détecté depuis l'IP étrangère : {ip} ({flow['bytes']} octets)")
detect_intrusions(simulated_traffic)

Explication : Contrôle stratégique numérique

Ce script illustre un contrôle stratégique numérique de plusieurs façons :
1. Surveillance active : il montre comment un pays peut surveiller les com-
munications entrantes sur ses réseaux critiques pour identifier des flux
anormaux.
2. Détection préventive : en détectant des IP étrangères avec un volume de
données élevé, le système peut anticiper des tentatives d’exfiltration de
données ou d’intrusion.
3. Protection des infrastructures critiques : l’analyse ciblée permet de pro-
téger les systèmes sensibles (gouvernement, énergie, télécommunications,
défense).
4. Souveraineté numérique : cela démontre comment un État peut exercer sa
souveraineté en développant des capacités locales de cybersécurité plutôt
que de dépendre d’acteurs extérieurs.
Voici une implémentation simple d’une machine de Turing en C++, suivie d’une
explication de son rôle historique en informatique.

1. Implémentation en C++ : Simulation d’une machine de Turing

Ce programme simule une machine de Turing qui incrémente un nombre unaire
(par exemple, transforme "111" en "1111").
#include #include #include #include
using namespace std;
enum Direction { LEFT, RIGHT, STAY };
struct Transition { char writeSymbol; Direction moveDirection; string nextState;
};
class TuringMachine { private: vector tape; int head; string currentState;
map<pair<string, char>, Transition> transitions; string acceptState;

3
public: TuringMachine(string initialState, string accept, const vector&
input) : currentState(initialState), acceptState(accept) { tape = input;
tape.push_back('_'); // symbole blanc head = 0; }
void addTransition(string state, char read, char write, Direction
dir, string next) {
transitions[{state, read}] = {write, dir, next};
}

void run() {
while (currentState != acceptState) {
char read = tape[head];
auto key = make_pair(currentState, read);

if ([Link](key) == [Link]()) {
cout << "Aucune transition trouvée. Arrêt.\n";
break;
}

Transition t = transitions[key];
tape[head] = [Link];

if ([Link] == RIGHT) head++;

else if ([Link] == LEFT) head--;
// expansion du ruban
if (head >= [Link]()) tape.push_back('_');
if (head < 0) {
[Link]([Link](), '_');
head = 0;
}

currentState = [Link];
}

cout << "Ruban final : ";

for (char c : tape) cout << c;
cout << endl;
}
};
int main() { // Ruban initial : "111" vector input = {'1', '1', '1'};
TuringMachine tm("q0", "q_accept", input);

// Transitions : lire 1 -> aller à droite jusqu'à blanc

[Link]("q0", '1', '1', RIGHT, "q0");
[Link]("q0", '_', '1', STAY, "q_accept");

4
[Link]();

return 0;
}

2. Rôle historique de la machine de Turing

La machine de Turing, introduite en 1936 par Alan Turing, est un modèle
théorique fondamental qui a permis de formaliser la notion de calcul. Elle a
marqué l’histoire de l’informatique pour plusieurs raisons :
Définition du calculable : elle permet de déterminer quelles fonctions peuvent
être calculées par un algorithme.
Prémices de l’ordinateur moderne : bien que théorique, la machine de Turing a
inspiré l’architecture des ordinateurs actuels.
Base de la théorie de la complexité : elle sert de référence pour classer les
problèmes selon leur difficulté algorithmique.
Concept d’universalité : une machine de Turing universelle peut simuler toute
autre machine de Turing, concept fondamental pour les langages de programma-
tion.
Voici un projet Python complet simulant ce que demande la QUESTION 5
: génération d’un rapport PDF automatisé à partir de données (CSV), avec
graphiques matplotlib, tableaux pandas, et exportation au format PDF. Il illustre
parfaitement une compétence essentielle pour un ingénieur en automatisation
des rapports.

1. Étapes du processus (simulé ici)

Connexion à des données (ex. : Category_Sales_for_1997.csv exportée depuis
Power Query)
Analyse et visualisation (graphiques et tableau)
Génération d’un PDF rapport

2. Script Python : Générateur de rapport PDF

import pandas as pd import [Link] as plt from fpdf import FPDF
import os

5
1. Charger les données (extraites de Power Query
ou Power BI)
df = pd.read_csv('Category_Sales_for_1997.csv')

2. Création d’un histogramme groupé

[Link](figsize=(10,6)) [Link](df['CategoryName'], df['CategorySales'],
color='skyblue') [Link]('Ventes par catégorie - 1997') [Link]('Catégorie')
[Link]('Ventes ($)') [Link](rotation=45, ha='right') plt.tight_layout()
[Link]('[Link]') [Link]()

3. Générer le rapport PDF

class PDFReport(FPDF): def header(self): self.set_font('Arial', 'B', 14)
[Link](0, 10, 'Rapport de Ventes - Catégories (1997)', 0, 1, 'C') [Link](5)
def chapter_title(self, title):
self.set_font('Arial', 'B', 12)
[Link](0, 10, title, 0, 1, 'L')
[Link](2)

def chapter_body(self, content):

self.set_font('Arial', '', 10)
self.multi_cell(0, 8, content)
[Link]()

def add_chart(self, image_path):

[Link](image_path, x=10, w=190)
[Link](10)

def add_table(self, dataframe):

self.set_font('Arial', 'B', 10)
col_width = self.w / 4.5
for col in [Link]:
[Link](col_width, 8, col, 1)
[Link]()
self.set_font('Arial', '', 10)
for index, row in [Link]():
for item in row:
[Link](col_width, 8, str(item), 1)
[Link]()
pdf = PDFReport() pdf.add_page() pdf.chapter_title('1. Aperçu des ventes')
pdf.chapter_body("Voici la distribution des ventes par catégorie de produits de

6
l'année 1997.") pdf.add_chart('[Link]')
pdf.chapter_title('2. Tableau des données') pdf.add_table(df)

4. Sauvegarder le rapport PDF

[Link]('rapport_ventes_1997.pdf') print("Rapport PDF généré avec suc-
cès.")

Nettoyage (optionnel)
[Link]('[Link]')

3. À propos des outils mentionnés (Power Query, Power BI)

Power Query : utilisé pour extraire les données du service OData Northwind.
Power BI : utilisé pour créer des visualisations interactives, comme l’histogramme
groupé.

4. Pourquoi cette compétence est stratégique pour un ingénieur ?

Gain de temps : automatisation des rapports périodiques.
Réduction d’erreurs : moins de copier-coller manuel entre Excel, Power BI et
Word.
Présentation claire et professionnelle : intégration directe d’analyses et de
graphiques.
Transversalité : utile dans la finance, logistique, production, marketing, etc.
Voici un programme en langage C qui mesure de façon approximative la différence
de temps d'accès entre la RAM et le cache, à l’aide de boucles répétitives et
d’un tableau suffisamment grand. Ce test met en évidence le rôle crucial de la
localité spatiale et de l’architecture matérielle (cache L1/L2/RAM).

1. Code C : Test d’accès mémoire (cache vs RAM)

#include <stdio.h> #include <stdlib.h> #include <time.h>
#define SIZE_SMALL 1024 // Taille petite (cache-friendly) #define
SIZE_LARGE 100 * 1024 * 1024 // Taille grande (va au-delà du cache) #define
STRIDE 64 // Écart pour simuler accès non contigu #define REPEAT 1000
double timed_access(int *array, size_t size) { volatile int sum = 0; clock_t start
= clock(); for (int r = 0; r < REPEAT; r++) { for (size_t i = 0; i < size; i +=

7
STRIDE) { sum += array[i]; } } clock_t end = clock(); return (double)(end -
start) / CLOCKS_PER_SEC; }
int main() { // Allocation d’un tableau petit (peut tenir dans le cache) int
*small_array = malloc(SIZE_SMALL * sizeof(int)); // Allocation d’un tableau
grand (débordera dans la RAM) int *large_array = malloc(SIZE_LARGE *
sizeof(int));
if (!small_array || !large_array) {
printf("Erreur d'allocation mémoire.\n");
return 1;
}

for (int i = 0; i < SIZE_SMALL; i++) small_array[i] = i;

for (int i = 0; i < SIZE_LARGE; i++) large_array[i] = i;

double time_small = timed_access(small_array, SIZE_SMALL);

double time_large = timed_access(large_array, SIZE_LARGE);

printf("Temps d'accès (cache): %f s\n", time_small);

printf("Temps d'accès (RAM): %f s\n", time_large);

free(small_array);
free(large_array);

return 0;
}

2. Explication technique et implications matérielles

Cache vs RAM
Cache (L1/L2/L3) : mémoire ultra-rapide située près du processeur. Temps
d’accès : ~1-10 ns.
RAM : mémoire principale, plus éloignée. Temps d’accès : ~100 ns ou plus.
Localité spatiale
Les processeurs lisent les données en blocs (ex. 64 octets).
En accédant à des données contiguës, on exploite le cache efficacement.
Des accès espacés ou aléatoires obligent à recharger les blocs, ce qui ralentit
fortement.
Ce que montre ce programme
Les petits tableaux sont traités très rapidement, car ils tiennent dans le cache.

8
Les grands tableaux accèdent souvent à la RAM, ce qui ralentit les performances.

3. Application concrète
En algorithmique, il est plus performant d’accéder à la mémoire de manière
séquentielle.
Les ingénieurs doivent optimiser les structures de données et les modèles d’accès
mémoire pour tirer parti des caches (par exemple, éviter les accès aléatoires dans
les grandes matrices).
Voici une explication claire et structurée des concepts fondamentaux de
l’architecture des processeurs : cycle d’instruction, pipeline, et aléas (hazards).

1. Cycle d’instruction (FETCH – DECODE – EXECUTE)

C’est le processus par lequel un processeur exécute chaque instruction d’un
programme. Il comprend trois étapes principales :
Exemple : ADD R1, R2, R3 : le processeur va chercher cette instruc-
tion, la déchiffrer, puis additionner R2 et R3 et stocker le résultat
dans R1.

2. Pipeline (ou canalisation)

Le pipeline est une technique utilisée pour améliorer la performance des pro-
cesseurs en exécutant plusieurs instructions en parallèle, chacune à une étape
différente.
Analogie : comme une chaîne de montage en usine.
Résultat : 1 instruction terminée par cycle après le remplissage du
pipeline, ce qui augmente considérablement la vitesse.

3. Aléas (Hazards)
Les aléas sont des problèmes qui peuvent perturber l’exécution fluide du pipeline.
Il en existe trois types :
Solutions aux aléas :
Stall (attente)
Forwarding (transfert de résultats intermédiaires)
Branch prediction (prédiction de branchement)

9
Conclusion
Ces concepts sont cruciaux pour comprendre les performances d’un processeur :
Le cycle FETCH-DECODE-EXECUTE explique l’exécution d’une seule instruc-
tion.
Le pipeline améliore les performances par exécution en parallèle.
Les aléas sont les limites de ce parallélisme, qu’il faut gérer intelligemment.
Voici une explication claire accompagnée d’un exemple Python comparant pro-
cessus (multiprocessing) et threads (threading) pour une tâche de calcul intensif
(CPU-bound).

1. Exemple de tâche CPU-bound (calcul de nombres premiers)

Fonction commune (test primalité)
def is_prime(n): if n < 2: return False for i in range(2, int(n**0.5) + 1): if n %
i == 0: return False return True

2. Version avec threading (ne contourne pas le GIL)

import threading import time
def count_primes_thread(nums): for n in nums: is_prime(n)
if name == "main": numbers = list(range(10_000, 15_000)) t1 = thread-
[Link](target=count_primes_thread, args=(numbers[:2500],)) t2 = thread-
[Link](target=count_primes_thread, args=(numbers[2500:5000],)) t3 =
[Link](target=count_primes_thread, args=(numbers[5000:7500],))
t4 = [Link](target=count_primes_thread, args=(numbers[7500:],))
start = [Link]()
[Link](); [Link](); [Link](); [Link]()
[Link](); [Link](); [Link](); [Link]()
print("Temps avec threading :", [Link]() - start, "secondes")
Résultat attendu : lenteur malgré 4 threads — le GIL empêche le
vrai parallélisme CPU.

3. Version avec multiprocessing (contourne le GIL)

import multiprocessing import time
def count_primes_process(nums): for n in nums: is_prime(n)

10
if name == "main": numbers = list(range(10_000, 15_000)) p1 = multiprocess-
[Link](target=count_primes_process, args=(numbers[:2500],)) p2 = multi-
[Link](target=count_primes_process, args=(numbers[2500:5000],))
p3 = [Link](target=count_primes_process, args=(numbers[5000:7500],))
p4 = [Link](target=count_primes_process, args=(numbers[7500:],))
start = [Link]()
[Link](); [Link](); [Link](); [Link]()
[Link](); [Link](); [Link](); [Link]()
print("Temps avec multiprocessing :", [Link]() - start, "secondes")
Résultat attendu : bien plus rapide — chaque processus utilise un
cœur indépendant.

4. Explication technique des différences

5. Conclusion pédagogique
Pour les tâches CPU-intensives, multiprocessing est à privilégier.
Le GIL (Global Interpreter Lock) empêche les threads Python de s’exécuter en
parallèle sur plusieurs cœurs, même s’ils semblent parallèles.
Les processus, eux, sont gérés séparément par le système d’exploitation, permet-
tant un vrai parallélisme multi-cœurs.
Voici les principales fonctions techniques d’un système d’exploitation (SE),
élément fondamental qui agit comme intermédiaire entre le matériel et les
applications :

1. Gestion des processus

Création, planification et terminaison des processus.
Assure le multitâche : plusieurs programmes peuvent s’exécuter simultanément.
Alloue le temps CPU à chaque processus via un ordonnanceur (scheduler).
Ex. : exécuter un navigateur pendant qu’un téléchargement tourne
en arrière-plan.

2. Gestion de la mémoire
Alloue la mémoire vive (RAM) aux programmes en cours.
Utilise des techniques comme :
Mémoire virtuelle

11
Pagination / Segmentation
Protection de mémoire pour éviter qu’un programme n’en écrase un autre.
Ex. : un programme ne peut pas accéder à la mémoire d’un autre
par erreur.

3. Gestion du système de fichiers

Organisation, lecture, écriture et suppression de fichiers.
Gère l’accès aux disques durs, SSD, clés USB, etc.
Maintient la sécurité et les permissions des fichiers.
Ex. : droits d’accès « lecture seule », « exécution », « admin », etc.

4. Gestion des périphériques (Entrées/Sorties)

Interface entre les logiciels et les périphériques matériels (clavier, écran, impri-
mante, etc.).
Utilise des pilotes (drivers) pour chaque type de matériel.
Ex. : communication entre le processeur et une souris USB.

5. Gestion des utilisateurs et de la sécurité

Gère les comptes utilisateurs, leurs droits d’accès et la protection du système.
Met en place des mécanismes d’authentification, cryptage, isolation.
Ex. : mot de passe, pare-feu, contrôle des accès à des fichiers critiques.

6. Gestion des communications inter-processus (IPC)

Permet aux processus de communiquer et coopérer.
Utilise des techniques comme :
Pipes
Sockets
Mémoire partagée
Signaux
Ex. : un logiciel qui affiche l’état d’un téléchargement en cours.

12
 7. Gestion de l’alimentation et des ressources
Optimisation de la consommation d’énergie (notamment pour les appareils
mobiles).
Gère l’utilisation des ressources matérielles : CPU, mémoire, batterie, etc.

Conclusion
Un système d’exploitation est un chef d’orchestre technique qui :
Coordonne le matériel,
Protège les programmes,
Optimise les performances,
Garantit la sécurité et la stabilité du système.
Voici une réponse complète à la Question 10, en deux parties :

I. Importance de comprendre le terminal

Le terminal (ou ligne de commande) est un outil essentiel pour tout ingénieur ou
informaticien. Il permet d’interagir directement avec le système d’exploitation
via des commandes textuelles, sans interface graphique.
Pourquoi c’est important ?
1. Puissance et rapidité : certaines tâches (installation de logiciels, traitement
de fichiers, scripts) sont plus rapides et précises en terminal.
2. Automatisation : permet d’écrire des scripts (Bash, PowerShell) pour
automatiser des tâches.
3. Contrôle système avancé : accès direct à des fonctions profondes (réseaux,
permissions, processus).
4. Compétence universelle : les mêmes commandes ou concepts sont valables
dans tous les OS Unix-like (Linux, macOS, serveurs distants...).
5. Développement et DevOps : Git, Docker, SSH, Python, Java, etc. sont
souvent utilisés en ligne de commande.

II. Accéder au terminal selon les systèmes d’exploitation

III. Installer WSL (Windows Subsystem for Linux) sur Windows 11

WSL permet de faire tourner un vrai Linux à l’intérieur de Windows, sans
machine virtuelle.

13
Étapes d’installation de WSL sur Windows 11 :
1. Ouvrir PowerShell en mode administrateur
Clic droit sur le bouton Démarrer > "Windows PowerShell (Admin)"
2. Exécuter la commande suivante :
wsl --install
Cela installe WSL 2 et Ubuntu par défaut.
Redémarrez l’ordinateur si demandé.
3. Configurer Ubuntu
Après redémarrage, Ubuntu se lance automatiquement.
Vous devrez créer un nom d’utilisateur Linux et un mot de passe.
4. (Facultatif) : Installer une autre distribution
wsl --list --online wsl --install -d Debian # exemple pour Debian

Vérifier la version de WSL

wsl --status

Pourquoi WSL est important ?

Permet d’exécuter des outils Linux (gcc, git, apt, python, etc.) sur Windows.
Utile pour le développement web, l'administration système, la cybersécurité, les
scripts Bash, etc.
Compatible avec VS Code via l’extension "Remote - WSL".
.

14