Commit 36b18b97 authored by Matsvei's avatar Matsvei
Browse files

First commit

parent 94541fba
img_dependencies/
test
# Lexique Technopolice: Automated PDF generator
## Intro
This is a small **python3**- and **latex**-based project that aims to automatically generate a `.pdf` file (for the "**Lexique Technopolice**") starting from a plain-text participatory document and a `.tex` template.
https://technopolice.be/
## Requirements
- Install `python3` and `latex` on your computer.
##### Remarks:
- Make sure to have access to the `pdflatex` command line function.
- Make sure that all latex' packages mentioned in the header of `template.tex` file are installed.
## Usage
Run the following command from current directory:
```
python3 generate_pdf.py
```
## Modify
- Adapt execution's **parameters** in the header of `generate_pdf.py` script.
- Add **words and definitions** in the `lexique.txt` file.
- Adapt the latex **template** file by changing the `template.tex` file.
## Syntax
#### 1) Lexique Syntax
- Only lines that are located between the two `%%LEXIQUE%%` tags are considered.
- Lines starting with `#` are not considered.
- Write each word with the following syntax:
**%myWord &myHashtag $myCategory @myLink**
**myDefinition...**
- "hashtag", "catogory" and "link" tags are not mandatory.
**Example:**
```
%Plante &didactique $les_termes_techniques @https://fr.wikipedia.org/wiki/Plante
Les plantes (Plantae) sont des organismes photosynthétiques (...).
```
#### 2) Template Syntax
Use the usual latex syntax where:
- `%%DATE%%` will be replaced by the current date (DD/MM/YYYY)
- `%%LEXIQUE%%` will be replaced by lexique list
## Contacts:
- contact@technopolice.be
- matsvei.tsishyn@protonmail.com
# ------------------------------------------------------------------------------
# Imports ----------------------------------------------------------------------
from os import system, remove
from datetime import datetime
# ------------------------------------------------------------------------------
# Global Variables -------------------------------------------------------------
PARAMETERS = {
"saveExcessFiles": False,
"printLatexLogs": False,
}
CONSTANTS = {
"lexiquePath": "lexique.txt",
"templatePath": "template.tex",
"outputName": "lexique_technopolice",
"excessFilesExtentions": ["aux", "log", "out"],
"prefixes": ["la ", "le ", "les ", "un ", "une ", "des "],
"latexSyntaxCharaters": ["{", "}", "#", "$", "%", "_"],
"clearCharacters": ["\n", "\t"],
"tagSymbols": ["%", "&", "$", "@"],
}
# ------------------------------------------------------------------------------
# Functions --------------------------------------------------------------------
# File System ------------------------------------------------------------------
def readStringFromFile(path):
""" Read the content of a .txt file as a string """
f = open(path, "r")
fileString = f.read()
f.close()
return fileString
def readLinesFromFile(path):
""" Read the content of a .txt file as the array of its lines """
f = open(path, "r")
lines = list(f.readlines())
f.close()
return lines
def writeTextToFile(path, text):
""" Save the string <text> in a file located at <path> """
f = open(path, "w")
f.write(text)
f.close()
# Getters ----------------------------------------------------------------------
def getCurrentDate():
""" Generate current date as a string in format DD/MM/YYYY """
current_data = str(datetime.now()).split()[0].split("-")
current_data.reverse()
return "/".join(current_data)
def getHash(word, id, prefixes):
"""
Assign a hash to a word:
INPUTS:
- word {::str}: the word to assign a hash
- id {::int}: unique integer so that the hash is unique in case the same word is defined n>1 times
- prefixes {[::str]}: List of prefixes that will not be considered in the alphabetic order
OUTPUT:
- hash {::str}: Unique identifier that will preserve the alphabetic order of the words list
"""
hash = word + "___" + id # id guarantees uniqueness
hash = hash.lower() # use lower so that "La" => "la"
for prefixe in prefixes:
hash = hash.replace(prefixe, "") # Delete prefixes for correct alphabetical order
return hash
# PARSERS ----------------------------------------------------------------------
def getLinesBetweenMarker(lines, marker):
"""
Return the subarray that is located between the two first lines that starts with the marker string
[::str] => [::str]
"""
ids = []
marker_len = len(marker)
for id, line in enumerate(lines):
if line[0:marker_len] == marker:
ids.append(id)
return lines[ids[0]+1: ids[1]]
def parseBetweenSymbol(line, symbol, tagSymbols):
"""
Return the content between <symbol> and one of the <tagSymbols> from a string.
::str => ::str
"""
if symbol not in line:
return "" # Return empty in case <symbol> not in line
queue = line.split(symbol)[1] # Take everything is after <symbol>
for symbol in tagSymbols: # Map every other symbol to "%"
queue = queue.replace(symbol, "%")
tail = queue.split("%")[0] # Take everything before "%"
output = tail.strip() # Delete opening and ending " "
output = " ".join(output.split()) # Delete repeated " "
return output
def parseWordLine(line, tagSymbols):
"""
Parse the line that contains meta data of a definition (word, hashtag, category, ...)
::str => { name: ::str, hashtag: ::str, ...}
"""
return {
"name": parseBetweenSymbol(line, "%", tagSymbols),
"hashtag": parseBetweenSymbol(line, "&", tagSymbols),
"category": parseBetweenSymbol(line, "$", tagSymbols),
"source": parseBetweenSymbol(line, "@", tagSymbols),
"definition": []
}
def parseLexique(lines, CONSTANTS):
"""
Parse the list of words and their respective definitions from a .txt file and store it in a dictionary
INPUT:
- lines : array of strings (containing the plain text definitions)
OUTPUT:
- Dict{ word => defintion }
"""
# Delete useless tabs and spaces for uniformity
lines = [ x.strip() for x in lines ]
# Keep only lines between the first "%%LEXIQUE%%" tag and the second "%%LEXIQUE%%" tag
lines = getLinesBetweenMarker(lines, "%%LEXIQUE%%")
# Delete comments lines and empty lines
lines = [ line for line in lines if len(line) > 0 ]
lines = [ line for line in lines if line[0] not in ["#", "\n"] ]
# Read lines as a dictionary of word
dic = {}
current_word = "__NOT_A_WORD__" # This "not a word" is used to initialize our dictionary
dic[current_word] = {"definition": []}
for line_id, line in enumerate(lines):
# If the line defines a new word
if line[0] == "%":
meta_data = parseWordLine(line, CONSTANTS["tagSymbols"])
current_word = getHash(meta_data["name"], str(line_id), CONSTANTS["prefixes"])
dic[current_word] = meta_data
# If the line contain the definition of a word
else:
dic[current_word]["definition"].append(line)
del dic["__NOT_A_WORD__"] # Delete the initialized word
# Process definitions into strings
for word, word_data in dic.items():
definition = word_data["definition"]
str_definition = " ".join(definition) # Put in one single string
str_definition = " ".join(str_definition.split()) # Delete repeated spaces if there are some
dic[word]["definition"] = str_definition
# Clear text values in each word's data
for word, word_data in dic.items():
for key, value in word_data.items():
for char in CONSTANTS["latexSyntaxCharaters"]:
value = value.replace(char, "\\" + char)
for char in CONSTANTS["clearCharacters"]:
value = value.replace(char, "")
word_data[key] = value
return dic
# Generator --------------------------------------------------------------------
def getShortWebLink(link):
""" From a web-link string, generate a shorter/simpler link representation."""
return link.replace("https://", "").replace("http://", "").split("/")[0]
def generateLatexName(name):
return "" if name == "" else "\\textbf{" + name + "}"
def generateLatexHashtag(hashtag):
return "" if hashtag == "" else "\\texttt{\#" + hashtag + "}"
def generateLatexCategory(category):
return "" if category == "" else "\\textit{" + category + "}"
def generateLatexSource(source):
if source == "":
return ""
if "http" in source or "://" in source or "www" in source:
short_link = getShortWebLink(source)
return "\\href{" + source + "}{[" + short_link + "]}"
return "[" + source + "]"
def generateDescription(descriptors):
txt_descriptors = ", ".join(descriptor for descriptor in descriptors if descriptor != "" )
if txt_descriptors == "":
return ""
return '\\hspace*{5mm}{\\small' + txt_descriptors + "}"
def generateLatexWord(name, description, definition):
if description == "":
return name + "\\\\" + definition + "\\\\"
else:
return name + "\\\\" + description + "\\\\" + definition + "\\\\"
def generateLatexWordList(lexique):
"""
Generate a string in latex sytax for a list of words and their respective definitions.
- INPUT: Dict{ word => defintion } (output of parseLexique function)
- OUTPUT: String that represents the list of words and definition in a latex syntax
"""
# Sort words in alphabetial order
words = list(lexique.keys())
words.sort()
# Generate lines
latex_lines = []
for word in words:
word_data = lexique[word]
name = generateLatexName(word_data["name"])
hashtag = generateLatexHashtag(word_data["hashtag"])
category = generateLatexCategory(word_data["category"])
source = generateLatexSource(word_data["source"])
description = generateDescription([hashtag, category, source])
definition = word_data["definition"]
line = generateLatexWord(name, description, definition)
latex_lines.append(line)
return "\n\n".join(latex_lines)
def generateLatexFile(lexique, template):
latex_word_list = generateLatexWordList(lexique)
current_date = getCurrentDate()
latex_file = template.replace("%%DATE%%", current_date).replace("%%LEXIQUE%%", latex_word_list)
return latex_file
# ------------------------------------------------------------------------------
# Execution --------------------------------------------------------------------
if __name__ == "__main__":
# Load and Parse lexique
print("STEP 1: Load and Parse lexique ...")
lexique_lines = readLinesFromFile(CONSTANTS["lexiquePath"])
lexique = parseLexique(lexique_lines, CONSTANTS)
# Load latex template
print("STEP 2: Load template ...")
template = readStringFromFile(CONSTANTS["templatePath"])
# Edit latex template
print("STEP 3: Generate latex file ...")
latex_file = generateLatexFile(lexique, template)
# Save generated latex file
print("STEP 4: Save generated latex (.tex) file ...")
writeTextToFile(CONSTANTS["outputName"] + ".tex", latex_file)
# Generate PDB with latex
print("STEP 5: Generate PDF ...")
cmd_suffix = "" if PARAMETERS["printLatexLogs"] else ">/dev/null"
system("pdflatex {0} {1}".format(CONSTANTS["outputName"], cmd_suffix))
# For a mysterious reason of latex, you sometimes need to compile the file two times to get the wanted redering ...
system("pdflatex {0} {1}".format(CONSTANTS["outputName"], cmd_suffix))
# Remove extra files
if not PARAMETERS["saveExcessFiles"]:
print("STEP 6: Remove excess files ...")
for format in CONSTANTS["excessFilesExtentions"]:
remove("{0}.{1}".format(CONSTANTS["outputName"], format))
# Print conclusion
print("\n => New PDF file generated and saved in '{0}.pdf'.".format(CONSTANTS["outputName"]))
Présentation du lexique
Les technologies numériques qui servent la surveillance sont en plein développement et jouent d’une certaine opacité.
Ce lexique de la technopolice a pour vocation de définir les termes de la surveillance de masse pour mieux appréhender ses enjeux, dans leurs aspects techniques, sociaux et politiques. Ce document est participatif. Il se nourrit des diverses voix qui scrutent cette surveillance, dessinant les contours de sa critique.
Ce document est donc informatif et ne doit pas être considéré comme une référence scientifique. Il sera régulièrement mis à jour au gré des contributions.
Toutes remarques et contributions sont les bienvenues.
# ----------------------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------------
# INTRODUCTION:
# Ceci est le document destiné à générer le LEXIQUE TECHNOPOLICE.
# Complétez les mots que vous souhaitez, ou modifiez les mot existants ICI.
# MODÈLE:
# Pour définir un mot, commencez la ligne pas un symbole pourcent '%' et écrivez le mot (ou la séquence de mots) sur la même ligne.
# Écrivez sa définition dans les lignes qui suivent.
# Vous pouvez aussi spécifier le "hashtag", la "catégorie" et la "source" d'un mot avec la syntaxe suivante:
# %Mon_Mot &Mon_Hashtag $Ma_Catégorie @Ma_Source
# Ma_Définition ...
# Hashtags suggérés: &didactique ; &mauvaise_foi ; &officiel ; &académique ; &wikipédia ; &wiktionnaire
# Catégories suggérées: $les_mots_du_pouvoir ; $les_termes_techniques ; $les_armes_de_la_critique ; $qui_est_qui
# REMARQUES
# - Toutes les lignes commencent par un hashtag '#' sont des lignes de commentaires, c'est-à-dire qu'elles seront ignorées.
# - Les lignes vides et les passages à la ligne seront ignorées.
# - L'ordre alphabétique est automatiquement généré dans le .pdf, il ne faut pas s'en soucier.
# - N'utilisez pas de caractère spéciaux tels que "$", "\", "{}", ...
# ----------------------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------------------
%%LEXIQUE%%
%La Quadrature du Net &officiel $qui_est_qui @https://www.laquadrature.net/nous/
La Quadrature du Net promeut et défend les libertés fondamentales dans l’environnement numérique.
L’association lutte contre la censure et la surveillance, que celles-ci viennent des États ou des entreprises privées.
Elle questionne la façon dont le numérique et la société s’influencent mutuellement.
Elle œuvre pour un Internet libre, décentralisé et émancipateur.
%Algorithme &didactique $les_termes_techniques
Un algorithme est une suite finie et non ambiguë d’opérations ou d'instructions permettant de résoudre une classe de problèmes (source: Wikipédia).
Ce terme est souvent utilisé dans le carde de l'informatique où une suite d’instructions est donnée à un ordinateur afin qu'il exécute la tâche donnée.
Par exemple, nous pouvons parler des algorithmes qui trouvent le plus court chemin entre deux localisations, ou d'un algorithme de reconnaissance faciale.
%Navigateur web &didactique $les_termes_techniques
(ou web browser) est un logiciel conçu pour consulter et interagir avec des pages internet.
Parmi les plus connus, il y a Mozilla Firefox, Tor, Google Chrome et Internet Explorer.
À ne pas confondre avec un moteur de recherche, qui est un outil (généralement sous forme de site-web) permettant de trouver des sites internet pertinents à l'aide de mots clés.
%Web browser &didactique $les_termes_techniques
Cf. Navigateur web.
%Chiffrement &didactique $les_termes_techniques
(ou cryptage bien que ce terme ne soit pas reconnu pas l'Académie française) est un procédé en cryptographie par lequel on peut rendre un texte ou un document illisible à toute personne mis à part le/la ou les destinataire.s de celui-ci.
Ce procédé est actuellement largement utilisé sur internet et en informatique en général.
Pensez par exemple à quand vous introduisez votre mot de passe, ou à quand vous effectuez un payement en utilisant votre carte de banque.
%OS &didactique $les_termes_techniques
(Operating System ou système d'exploitation en français) est l'ensemble de logiciels permettant à un.e utilisateur.trice d’interagir avec un ordinateur.
D'une certaine façon, il s'agit de l’âme qui anime les composantes électroniques d'un ordinateur.
Parmi les plus connus, il y a, GNU/Linux, Microsoft Windows et iOS.
%Logiciel open source &didactique $les_termes_techniques
Est un logiciel dont les utilisateur.trice.s ont l'accès au code source de celui-ci.
Ceci permet à la communauté de savoir exactement ce que le logiciel fait et tout ce que le logiciel fait.
Par exemple, si un logiciel open source récolte des données utilisateur.trice.s, ce sera visible dans le code et donc publique.
A ne pas confondre avec logiciel libre (un logiciel peut être open source mais pas libre).
%Logiciel libre &didactique $les_termes_techniques
Est un logiciel dont l'étude, la modification et la duplication du code est permise.
Ceci permet une transparence totale envers les utilisateur.trice.s, un contrôle sur le programme et un partage entre individus.
Par exemple GNU/Linux et Firefox sont des logiciel libres.
%FOSS &didactique $les_termes_techniques
Free and open-source
%Onion dildonics &didactique $les_termes_techniques
Sécuriser des sex toys à l'aide de protocoles préservant la vie privée. Onion fait ici référence au réseau Tor.
%Cloud &didactique
Le cloud, nuage en français, désigne le cloud computing, le système qui permet de stocker des données sur des serveurs informatiques distants et accessibles par Internet. Il offre des espaces et de la puissance de calculs au public le plus large. La métaphore nuageuse contribue à l’abstraction de la réalité matérielle du numérique et de ses infrastructures physiques. [Richard 2018]
%Data center &didactique
Lieu de stockage des données qui héberge également les ordinateurs dont la puissance de calcul permet les opérations en ligne. Espaces discrets voire secrets, les data centers sont difficiles d’accès, stratégiques et surveillés, mais pourtant répartis sur toute la planète. On en dénombrait 8,6 millions à travers le monde en 2017. [Richard 2018]
%Fournisseur d’accès à Internet (FAI) &didactique
Organisme qui offre une connexion à Internet. Il s’agit généralement d’entreprises mais le service peut être proposé par une association. Les FAI les plus importants gèrent une infrastructure physique sur le territoire et la connectent aux utilisateurs. [Richard 2018]
%Internet &didactique
Internet est un réseau informatique mondial. Composé du World Wide Web et de multiples autres protocoles (boîtes de messagerie, VOIP, torrents, chats, etc.), il est le réseau des réseaux et comprend notamment les dorsales (backbones en anglais), les réseaux de FAI, ceux des universités, etc. [Richard 2018]
%Logiciel libre &didactique
Le logiciel libre est un logiciel dont l’utilisation, l’étude, la modification et la duplication sont autorisées sans restriction. Il est une alternative aux industries du logiciel propriétaire développée dans les années 1980 par Richard Stallman pour qui « la liberté de modifier un programme (permet de) le contrôler plutôt (que d’être) contrôl(é) par lui. Pour cela, le code doit (...) être accessible. » [Richard 2018]
%Open source &didactique
L’open source désigne les logiciels informatiques dont le code source est accessible, ouvert et modifiable. Ces logiciels se distinguent des logiciels libres car ils peuvent intégrer des logiciels propriétaires. L’open source désigne aussi un mouvement que l’on peut retrouver dans la recherche, la création ou la pédagogie, qui valorise le libre partage des savoirs et l’appropriation des connaissances par tous.
%Pad ou EtherPad &didactique
Éditeur libre de texte collaboratif fonctionnant en temps réel, c’est-à-dire permettant à plusieurs personnes de le modifier simultanément. C’est une alternative au Google Doc. [Richard 2018]
%PirateBox &didactique
Dispositif électronique, souvent mobile, composé d’un routeur et de mémoire pour stocker des informations. La PirateBox crée un réseau sans fil local déconnecté d’Internet qui permet à ses utilisateurs d’échanger leurs fichiers de manière anonyme. Elle propose une alternative au Web tel que nous le connaissons et peut être utilisée dans des zones non couvertes par le réseau. [Richard 2018]
%Serveur &didactique
Un serveur est un ordinateur qui fonctionne en permanence et propose des services à d’autres ordinateurs par l’intermédiaire d’Internet. Il peut héberger des sites Web, une messagerie électronique et des données. [Richard 2018]
%Souveraineté technologique &didactique
Le concept s’inspire de la « souveraineté alimentaire » dont il repend les principes pour les appliquer aux technologies : autonomie, choix d’outils culturellement et socialement adaptés, priorité au local, respect environnemental. [Richard 2018]
%Technologie appropriée &didactique
Egalement appelée « technologie intermédiaire », elle est une « technologie à visage humain », locale, décentralisée, respectueuse de l’environnement et pensée en fonction de son contexte d’utilisation. Le concept est apparu dans les années 1960 et a été popularisé par le livre Small is beautiful de l’économiste britannique Ernst Friedrich « Fritz » Schumacher. [Richard 2018]
%VPN (Virtual Personal Network) &didactique
« Réseau privé virtuel » en français : il s’agit d’un service permettant d’accéder anonymement à Internet. Techniquement, le VPN détourne le trafic d’un ordinateur. [Richard 2018]
%Web &didactique
Le World Wide Web est une des applications qui permet d’accéder à des pages accessibles sur des sites, grâce à un navigateur. [Richard 2018]
%%LEXIQUE%%
Sources
%%SOURCES%%
[Richard 2018] Richard, Claire & Louise Drulhe (dessins). 2018. Petit ouvrage d'autonomie technologique. 369 éditions: Manuels. Accessible à l'adresse : https://www.369editions.com/wp-content/uploads/2018/06/369_manuel_Autonomie_technologique.pdf
%%SOURCES%%
# Idées de mots à ajouter
#Obfuscation (ou offuscation)
#Solutionnisme technologique
#Silicolonisation
#automation/automatisation
#servitude volontaire
#Société de contrôle
#Digitalisation
#Vidéoprotection
#Surveillance latérale
#Prévention situationnelle
#Security by Design
#Panoptique
#Sousveillance
#Transparence
#Orwell ou Huxley?
#Biopolitique et biopouvoir
#Gouvernementalité
#Gouvernementalité algorithmique
#Capitalisme de surveillance
#Capitalisme de plateforme
#Smart
#semiconducteur
#silicone
#transistor
#cookie
#log : journal de bord, registre, historique
#RFID : radio frequency identificatio
#ANPR (LAPI) : automatic number plate recognition (lecture automatique de plaque d'immatriculation)
#tracking
#tracing
#profilage
#datamining
#fingerprinting
#double numérique
#protocole
#agencement de surveillance (surveillant assemblage)
#Big Brother
#effet cliquet
#stratégie du choc (schock doctrine)
#function creep
#Commission Nationale de l’Informatique et des Libertés (CNIL)
#Autorité de protection des données (APD)
#Data Protection Officer (DPO)
#Règlement général sur la protection des données (RGPD) (GDPR en anglais)
#Taylorisme et organisation scientifique du travail (OST)
#World Wide Web
#Internet
#Arpanet
#HTML
#TCP/IP
#DNS
#Technopolice
#Espionnage
#Footfall Analytics
#"Acceptabilité" $les_mots_du_pouvoir
#Antenne
#Caméra-piéton
#Cookie
#Donnée
#Adresse MAC
#Adresse IP
#QR Code
#Numérique
#Reconnaisseance faciale
#Vidéo-surveillance
#"Vidéo-protection" $les_mots_du_pouvoir
#Vie privée
#Drone
#2G
#3G
#4G
#5G
#6G
\documentclass[5pt]{article}
% ------------------------------------------------------------------------------
% Packages ---------------------------------------------------------------------
%\usepackage{amsmath,amssymb,amsthm}
%\usepackage[utf8]{inputenc}
%\usepackage[shortlabels]{enumitem}
%\usepackage{float}
%\usepackage{subfiles}
%\usepackage{eso-pic}
%\usepackage[T1]{fontenc}
%\usepackage{eso-pic,graphicx}
\usepackage{hyperref}
\usepackage[top=30mm, bottom=20mm, outer=20mm, inner=20mm]{geometry}
\usepackage[pages=some]{background}
\usepackage[T1]{fontenc}
% ------------------------------------------------------------------------------
% Document ---------------------------------------------------------------------
\begin{document}
% First page -------------------------------------------------------------------
\backgroundsetup{
placement=bottom,
scale=1,
color=black,
opacity=1,
angle=0,
contents={ \includegraphics[width=\paperwidth,height=120mm]{img/ville_bw.png} }
}
\BgThispage
\vspace*{15mm}
\hspace*{15mm}
\Huge{Lexique Technopolice} \\ \\
\hspace*{17mm}
\Large{
Version: 29/11/2021
}
\clearpage
% Introduction page ------------------------------------------------------------
\newpage
\vspace*{20mm}
Les technologies numériques qui servent la surveillance sont en plein développement et jouent d’une certaine opacité.\\
Ce lexique de la technopolice a pour vocation de définir les termes de la surveillance de masse pour mieux appréhender ses enjeux, dans leurs aspects techniques, sociaux et politiques. Ce document est participatif. Il se nourrit des diverses voix qui scrutent cette surveillance, dessinant les contours de sa critique. \\
Ce document est donc informatif et ne doit pas être considéré comme une référence scientifique. Il sera régulièrement mis à jour au gré des contributions. \\
Toutes remarques et contributions sont les bienvenues. \\
\vfill
Contact: contact@technopolice.be
\clearpage
% Lexique ----------------------------------------------------------------------
\newpage
\textbf{Algorithme}\\\hspace*{5mm}{\small\texttt{\#didactique}, \textit{les\_termes\_techniques}}\\Un algorithme est une suite finie et non ambiguë d’opérations ou d'instructions permettant de résoudre une classe de problèmes (source: Wikipédia). Ce terme est souvent utilisé dans le carde de l'informatique où une suite d’instructions est donnée à un ordinateur afin qu'il exécute la tâche donnée. Par exemple, nous pouvons parler des algorithmes qui trouvent le plus court chemin entre deux localisations, ou d'un algorithme de reconnaissance faciale.\\
\textbf{Chiffrement}\\\hspace*{5mm}{\small\texttt{\#didactique}, \textit{les\_termes\_techniques}}\\(ou cryptage bien que ce terme ne soit pas reconnu pas l'Académie française) est un procédé en cryptographie par lequel on peut rendre un texte ou un document illisible à toute personne mis à part le/la ou les destinataire.s de celui-ci. Ce procédé est actuellement largement utilisé sur internet et en informatique en général. Pensez par exemple à quand vous introduisez votre mot de passe, ou à quand vous effectuez un payement en utilisant votre carte de banque.\\
\textbf{Cloud}\\\hspace*{5mm}{\small\texttt{\#didactique}}\\Le cloud, nuage en français, désigne le cloud computing, le système qui permet de stocker des données sur des serveurs informatiques distants et accessibles par Internet. Il offre des espaces et de la puissance de calculs au public le plus large. La métaphore nuageuse contribue à l’abstraction de la réalité matérielle du numérique et de ses infrastructures physiques. [Richard 2018]\\
\textbf{Data center}\\\hspace*