Articles pour développeurs

Encodage

Base64 : à quoi sert l'encodage et comment il fonctionne

Comment Base64 transforme des données binaires en texte ASCII, et quand c'est réellement utile.

Base32 : en quoi il diffère de Base64 et quand il est plus pratique

L'alphabet de Base32, insensible à la casse, et les cas où il est plus pratique que Base64.

URL Encode/Decode : le percent-encoding dans les liens

Comment les caractères spéciaux d'une URL et de ses paramètres deviennent des séquences %XX.

HTML Entities : afficher des caractères spéciaux en toute sécurité

Pourquoi les caractères < > & doivent être échappés, et comment cela évite de casser le balisage.

JWT : structure du token et ce que signifie « décoder » un JWT

Le header, le payload et la signature d'un JWT, et pourquoi décoder n'est pas la même chose que vérifier la signature.

Unicode Escape : que signifient les séquences \uXXXX

D'où viennent les séquences du type \u0041 dans le JSON et les chaînes JS, et ce qu'elles signifient.

ROT13 et le chiffre de César : une simple substitution de caractères

Pourquoi un décalage de 13 lettres rend ROT13 auto-inverse, et pourquoi on l'utilise encore aujourd'hui.

Punycode : comment les domaines internationalisés fonctionnent dans le DNS

Comment un domaine avec des caractères non latins devient une forme ASCII avec le préfixe xn--.

Le morse : comment le texte devient des points et des traits

Le principe de l'encodage des lettres en points et traits, et où le morse est encore utilisé aujourd'hui.

Data URI : quand intégrer une image directement dans le code

Comment un Data URI intègre le contenu d'un fichier directement en HTML ou CSS, et quand cela en vaut la peine.

Gzip + Base64 : compresser des données pour les transmettre en texte

Pourquoi des données binaires compressées sont aussi encodées en Base64 avant d'être placées dans un champ texte.

XML Entities : échapper les caractères dans les documents XML

Les cinq entités XML obligatoires, sans lesquelles le document se casse à l'analyse.

JSON

JSON Formatter : mise en forme, minification et validation

Mise en forme pour la lisibilité, minification pour la taille, validation pour la correction : trois tâches JSON différentes.

JSONPath : interroger des données JSON sans les parcourir à la main

Comment JSONPath permet d'extraire les valeurs voulues d'un gros JSON en une seule expression, sans parcours manuel.

JSON Diff : en quoi la comparaison structurelle diffère de la comparaison textuelle

Pourquoi l'ordre des clés ne devrait pas affecter la comparaison de deux documents JSON.

JSON Schema : décrire et valider la structure d'un JSON

Comment JSON Schema permet de vérifier automatiquement si des données respectent un contrat attendu.

JSON Flatten : transformer une structure imbriquée en liste plate

Comment un JSON profondément imbriqué devient une liste plate de clés comme user.address.city.

JSON Sort Keys : pourquoi trier les clés d'un objet

Pourquoi l'ordre des clés JSON n'est pas spécifié, mais reste utile à trier en pratique.

JSON Repair : pourquoi le JSON casse et comment le réparer

Les causes courantes de JSON « cassé », et ce qu'une réparation automatique peut ou ne peut pas corriger.

Mock JSON Generator : à quoi servent les fausses données

Comment des données fictives permettent de commencer à construire une interface avant que le backend soit prêt.

JSON ↔ YAML/CSV/XML/TOML : quand et pourquoi convertir

Quelles données se perdent en convertissant du JSON en CSV, et pourquoi YAML et TOML sont populaires pour les fichiers de configuration.

Texte

Case Converter : pourquoi il existe différents styles de nommage

Pourquoi un même projet écrit les variables en camelCase mais les fichiers en kebab-case, et d'où viennent ces règles.

Text Diff : comment les algorithmes trouvent la différence entre deux textes

Comment un algorithme de diff trouve l'ensemble minimal de changements entre deux versions d'un texte.

Expressions régulières : syntaxe de base et motifs courants

Comment lire une expression régulière, et en quoi la correspondance gourmande diffère de la paresseuse.

Trier et dédupliquer des lignes : pourquoi c'est utile

Pourquoi un tri numérique plaçant « 10 » avant « 9 » est une erreur, et comment l'éviter.

String Escape : pourquoi le même texte doit être échappé différemment

Pourquoi le même guillemet s'échappe différemment dans une chaîne JS, du JSON et une commande shell.

CRLF contre LF : pourquoi les caractères de fin de ligne comptent encore

Pourquoi un fichier écrit sous Windows peut apparaître « entièrement modifié » dans git sous Linux.

Compter les caractères et les mots : pourquoi ce n'est pas toujours trivial

Pourquoi un emoji ou une lettre accentuée peut compter comme plusieurs caractères à la fois.

Lorem Ipsum : d'où vient ce texte de remplissage et à quoi il sert

Pourquoi les designers utilisent délibérément un texte « insensé » plutôt que du vrai contenu dans les maquettes.

Slugify : transformer un texte quelconque en URL

Comment un titre comme « Bonjour, le Monde ! » devient une chaîne compatible URL comme bonjour-le-monde.

Markdown : pourquoi une syntaxe texte simple a supplanté les éditeurs riches

Pourquoi les développeurs préfèrent écrire la documentation en Markdown plutôt que dans un éditeur de texte riche.

Espaces et caractères invisibles : la cause cachée de bugs étranges

Pourquoi deux chaînes qui semblent identiques peuvent ne pas correspondre à cause d'un caractère invisible.

Text Reverse : pourquoi « inverser un texte » est plus dur qu'il n'y paraît

Pourquoi une inversion naïve de chaîne peut transformer un emoji en octets inutilisables.

Analyse de fréquence de texte : pourquoi compter les répétitions de mots

Comment la fréquence des lettres dans un texte chiffré aide à casser les chiffrements par substitution les plus simples.

Hachage/Crypto

Hash Generator : en quoi MD5, SHA-1 et SHA-256 diffèrent

Pourquoi MD5 sert encore à vérifier l'intégrité de fichiers, mais pas pour les mots de passe.

Checksum Verifier : comment vérifier qu'un fichier n'est pas corrompu

Pourquoi une somme de contrôle correspondante confirme l'intégrité d'un fichier, mais pas qui l'a créé.

HMAC : en quoi un hachage avec clé diffère d'un hachage classique

Pourquoi un simple SHA-256 ne protège pas contre la falsification d'un message, mais HMAC oui.

Bcrypt : pourquoi les mots de passe sont hachés lentement, pas rapidement

Pourquoi un SHA-256 rapide est un mauvais choix pour les mots de passe, et un bcrypt lent le bon choix.

UUID : comment générer des identifiants qui ne se répètent presque jamais

Pourquoi un UUID v4 peut être généré indépendamment sur des millions de machines sans risque de collision.

Générateur de mots de passe : ce qui rend vraiment un mot de passe solide

Pourquoi un long mot de passe fait de mots du dictionnaire est plus solide qu'un court avec symboles et chiffres.

AES : comment fonctionne le chiffrement symétrique

Pourquoi la même clé chiffre et déchiffre les données en AES, et en quoi cela diffère du chiffrement asymétrique.

Argon2 : pourquoi cet algorithme a remporté le concours de hachage de mots de passe

Comment Argon2 se défend mieux contre les attaques par GPU que les algorithmes de hachage de mots de passe plus anciens.

Scrypt : pourquoi l'algorithme a besoin d'autant de mémoire

Pourquoi scrypt exige volontairement beaucoup de mémoire pour compliquer le cassage sur des dispositifs ASIC.

TOTP : comment fonctionnent les codes à usage unique des applications d'authentification

Pourquoi le code de Google Authenticator fonctionne sans internet et se synchronise avec le serveur uniquement via l'heure.

PBKDF2 : le plus ancien standard d'étirement de clé

Pourquoi le nombre d'itérations recommandé pour PBKDF2 augmente chaque année.

X.509 : ce qu'il y a à l'intérieur d'un certificat SSL

Ce que le navigateur vérifie exactement dans le certificat d'un site avant d'afficher le cadenas vert.

PGP : comment fonctionne le chiffrement à clé publique et privée

Pourquoi on peut partager librement une clé publique PGP, mais jamais la clé privée.

Temps/Nombres

Temps Unix : pourquoi les ordinateurs comptent le temps depuis 1970

Pourquoi le 1er janvier 1970 est devenu le point de référence du temps pour la plupart des systèmes informatiques.

Expressions cron : comment déchiffrer un horaire de tâches

Comment déchiffrer une expression comme */15 * * * * et savoir exactement quand la tâche s'exécutera.

Systèmes numériques : à quoi servent le binaire, l'octal et l'hexadécimal

Pourquoi la couleur #FF5733 en CSS est écrite avec des chiffres hexadécimaux plutôt que décimaux.

Opérations bit à bit : comment fonctionnent AND, OR et XOR au niveau des bits

En quoi le AND bit à bit diffère du AND logique, et pourquoi manipuler des bits individuels d'un nombre.

Différence entre dates : pourquoi compter les jours est plus compliqué qu'il n'y paraît

Pourquoi soustraire naïvement deux dates peut donner un résultat incorrect à cause des années bissextiles.

Calcul de l'âge : pourquoi ce n'est pas une simple soustraction d'années

Pourquoi soustraire simplement les années de naissance peut donner un âge supérieur d'un an à l'âge réel.

Fuseaux horaires : pourquoi UTC n'est pas la même chose que GMT

Pourquoi UTC ne change jamais deux fois par an, alors que l'heure de Londres (GMT/BST) change.

Calculatrice de durée : comment additionner correctement heures, minutes et secondes

Pourquoi additionner des minutes et des secondes nécessite de « reporter » le reste sur le rang suivant, comme dans l'addition décimale.

ISO 8601 Duration : comment écrire une durée dans un format standard

Pourquoi PT1H30M signifie « 1 heure 30 minutes », et non « 1 minute 30 heures ».

Numéro de semaine : pourquoi les pays comptent les semaines différemment

Pourquoi le 1er janvier appartient parfois à la semaine 52 ou 53 de l'année précédente selon la norme ISO 8601.

Chiffres romains : comment fonctionne un système sans zéro ni position

Pourquoi IV signifie 4 et non 6, et comment fonctionne la règle de soustraction dans les chiffres romains.

IEEE 754 : pourquoi 0.1 + 0.2 n'est pas égal à 0.3 dans le code

Pourquoi presque tous les langages de programmation affichent 0.30000000000000004 pour 0.1 + 0.2.

Nombre en toutes lettres : pourquoi transformer des chiffres en mots

Pourquoi les documents bancaires écrivent un montant à la fois en chiffres et en toutes lettres.

Réseau/HTTP

Analyse d'URL : de quelles parties se compose une adresse web

Pourquoi une URL contient une partie après le symbole # que le serveur ne reçoit même jamais.

Query string contre JSON : pourquoi les paramètres GET sont si limités

Pourquoi passer un tableau ou un objet imbriqué via la query string d'une URL n'est pas aussi simple qu'avec JSON.

User-Agent : pourquoi cette chaîne est un tel fouillis

Pourquoi Chrome, Safari et Edge contiennent tous à la fois les mots « Mozilla » et « Safari » dans leur User-Agent.

Basic Authentication : comment fonctionne le moyen le plus simple de protéger une ressource HTTP

Pourquoi Basic Auth exige absolument HTTPS, puisque Base64 est un encodage, pas un chiffrement.

En-têtes HTTP : ce qui se cache dans chaque requête et chaque réponse

Pourquoi l'en-tête Content-Type détermine comment le navigateur interprète le corps de la réponse du serveur.

Cookies : comment un petit bout de texte conserve l'état d'une session

Pourquoi l'attribut HttpOnly protège un cookie contre le vol par un script JavaScript malveillant.

CORS : pourquoi le navigateur bloque des requêtes « normales » vers un autre domaine

Pourquoi une erreur CORS se produit dans le navigateur, pas côté serveur, et qui bloque réellement la requête.

En-têtes d'email : comment retracer le parcours d'un message de l'expéditeur jusqu'à vous

Pourquoi il faut lire les en-têtes Received de bas en haut pour retracer le parcours d'un message.

SEO

Meta tags : lesquels influencent vraiment la recherche et les réseaux sociaux

Pourquoi un moteur de recherche ignore parfois votre meta description et génère son propre extrait à partir du texte de la page.

robots.txt : comment les robots d'indexation décident ce qu'ils peuvent explorer

Pourquoi une règle Disallow dans robots.txt ne masque pas une page des résultats si un lien pointe vers elle ailleurs.

Sitemap.xml : pourquoi les moteurs de recherche ont besoin d'un plan du site

Pourquoi figurer dans sitemap.xml ne garantit pas qu'un moteur de recherche indexera une page.

Favicon : pourquoi une seule icône nécessite autant de tailles et de formats

Pourquoi un seul favicon.ico ne suffit plus pour s'afficher correctement sur tous les appareils.

Générer sitemap.xml : construire un plan de site automatiquement

Pourquoi les moteurs de recherche ignorent en grande partie le champ priority dans sitemap.xml, bien qu'il fasse partie de la spécification.