Catalogue technique

L'évolution du web sous le capot : multiplexage HTTP/2, le piège du head-of-line blocking TCP, et QUIC qui change de transport. Même langage HTTP, plomberie réinventée.

Comprends comment HTTP envoie des données progressivement : chunked encoding, Server-Sent Events et streaming de fichiers.

Tagged services, décoration, compiler passes, service locators, lazy — le conteneur Symfony sans mystère.

Firewalls, authenticators, voters, tokens, stratégies — maîtrise complète de la couche Security Symfony.

Maîtrise le streaming PHP de A à Z : output buffering, générateurs et streams natifs. Traite des données volumineuses sans saturer la mémoire.

PSR-6, PSR-16, adapters, tags, early expiration — le composant Cache Symfony sans mystère.

Attributs #[Route], requirements, génération d'URL, conditions, RouteCollection et matching — maîtrise complète du composant Routing.

Workflow, StateMachine, guards, événements, Registry — modélise n'importe quel cycle de vie métier avec le composant Workflow.

Verrous exclusifs et partagés, TTL, blocking, stores Redis/Flock/PostgreSQL — gère les accès concurrents en production.

TreeBuilder, Processor, AbstractExtension, prepend — construis des bundles configurables et robustes.

Construis un serveur TCP et un client de zéro en Python. Sockets, bind/listen/accept, handshake, paquets, ports — tout ce que HTTP, Redis et PostgreSQL ont en commun sous le capot.

Reverse proxy, couches de cache HTTP, CDN, invalidation — comment servir du contenu vite et sans surcharger l'origin.

Call stack, microtasks, I/O non-bloquant, async/await, PHP Fibers — comment un seul thread fait tout en même temps.

Pipeline normalize/encode, normalizers fournis, attributs, groupes, contexte, custom normalizer — le Serializer Symfony sans mystère.

CurlHttpClient, streaming, concurrence, retry, MockHttpClient — maîtrise le client HTTP de Symfony du test à la production.

FormInterface, DataTransformer, DataMapper, Events, TypeExtension — le Form Component Symfony sans mystère.

Bus de messages, Envelope, Stamps, Middleware, Transport, Worker, Retry — Messenger sans mystère.

Listeners, subscribers, priorités, propagation, TraceableEventDispatcher — le bus d'événements Symfony dans les détails.

ValidatorInterface, contraintes built-in, groupes, cascading, contraintes custom — le Validator Symfony sans mystère.

Domaines, pluriels Interval et ICU, catalogues avec fallback, LocaleSwitcher, extraction — l'i18n Symfony de A à Z.

Valider, normaliser et documenter les options d'une classe — lazy options, nested, prototypes, déprecation.

Producteur/consommateur, ACK, DLQ, backpressure, RabbitMQ, Kafka — les patterns de communication asynchrone.

Token bucket, leaky bucket, sliding window, fixed window, Redis distribué — les algorithmes qui protègent tes APIs de la surcharge.

LRU, LFU, TTL, Redis, stampede, write-through — tout ce qui se passe derrière un simple hit de cache.

ACID, niveaux d'isolation, MVCC, deadlocks, optimistic locking — comprendre ce qui se passe vraiment entre BEGIN et COMMIT.

Du log texte au log JSON. Collecte avec Promtail, stockage dans Loki, requêtes LogQL et corrélation avec métriques et traces.

Comprends comment une requête traverse plusieurs services. Spans, propagation W3C, SDK OpenTelemetry, stockage Tempo, et TraceQL pour diagnostiquer n'importe quel problème de performance.

Comment fonctionne un index B-tree, comment un ORM génère N+1 requêtes sans prévenir, et comment lire EXPLAIN ANALYZE.

Logs, métriques, traces — comprendre les trois signaux qui rendent un système observable, comment les corréler, et pourquoi le monitoring seul ne suffit plus.

Comprends le modèle pull de Prometheus, les quatre types de métriques, PromQL et comment construire une stack d'alerting fiable.

Datasources, dashboards, variables de template, alerting et corrélations métriques-logs-traces dans Grafana. La vitrine unifiée du stack LGTM.

Monolog JSON, SDK OpenTelemetry PHP, auto-instrumentation Symfony, corrélation trace_id dans les logs. L'observabilité complète d'une application PHP dans le stack LGTM.

Conçois un pipeline de métriques scalable pour Kubernetes : Prometheus + Thanos (Sidecar, Store Gateway, Query, Compacteur) + S3 long terme + Grafana. Du pod unique à l'architecture haute disponibilité.

Strings, Lists, Hashes, Sets, Sorted Sets, TTL, persistance RDB/AOF, Pub/Sub, Streams et patterns avancés. Du premier INCR au verrou distribué.

Handshake TLS 1.3, certificats X.509, Forward Secrecy, SNI, ALPN, HSTS — comment HTTPS fonctionne vraiment.

Conçois un système qui passe à l'échelle, étape par étape : d'un serveur unique à une architecture distribuée. Serveur sans état, load balancing, microservices, gateway, object storage, broker, cache, CDN, rate limiting — le tout illustré en construisant un clone de Google Drive.

Construis une messagerie instantanée entièrement serverless : WebSocket via API Gateway, Lambda, DynamoDB, file SQS et IAM. Le capstone pour comprendre comment on architecture les systèmes temps réel dans le cloud.

Les cinq timeouts d'un système (connexion, lecture, attente, traitement, réponse), pourquoi un timeout n'annule rien, comment ils se cumulent derrière un proxy, et les patterns de résilience qui évitent les tempêtes de retry : backoff, jitter, circuit breaker, idempotence.

Construis un raccourcisseur d'URL comme Bitly, entièrement serverless : API Gateway, Lambda, DynamoDB, IAM et CloudWatch. Un TP fil rouge pour comprendre l'architecture événementielle dans le cloud.

Deux faces d'un même problème : gérer les erreurs à l'intérieur (exceptions — lever, ne jamais avaler, mapper) et les communiquer à l'extérieur de façon normalisée (codes de statut HTTP, puis Problem Details — RFC 7807 et RFC 9457).

Plonge sous le capot de PHP : la SAPI, le cycle de vie d'une requête, la compilation en opcodes, OPcache, la gestion mémoire et le modèle share-nothing. Comprendre comment PHP fonctionne pour mieux développer et mieux héberger.

Comprends WebTransport, le protocole bâti sur HTTP/3 et QUIC : sessions, streams bidirectionnels et datagrammes non fiables — de l'UDP dans le navigateur. Pourquoi il arrive après WebSocket, ce qu'il change, et quand le choisir.

Dès qu'une entité change d'état, d'autres parties du système doivent réagir. Injecter des services dans l'entité ? C'est tentant — et c'est faux. Les Domain Events règlent ça proprement.

Les relations ManyToMany en ORM cachent souvent une question que tu ne t'es pas encore posée : qui est vraiment responsable de cette association ? On remodélise ensemble, avec Doctrine et les règles des agrégats DDD.

Arguments, options, SymfonyStyle, ProgressBar, autocomplétion et tests — maîtrise complète du composant Console.

RequestEvent, ControllerEvent, ViewEvent, ExceptionEvent — les 8 événements qui orchestrent chaque requête Symfony.

Poser les bons en-têtes de cache, cacher par morceaux avec l'ESI, et faire tourner le reverse proxy HttpCache de Symfony.

Ton modèle tient très bien — jusqu'au jour où il a du succès : accès concurrents, totaux qui divergent, règles violées sans coupable. Les agrégats sont la réponse. On trace la frontière, on désigne la racine, on protège les invariants, et on descend jusqu'au mapping Doctrine réel (cascade, référence par identité, verrou optimiste).

Les entités et les agrégats, c'est la partie visible du DDD. La partie qui décide de tout se joue avant : de quoi parle-t-on, avec qui, et où trace-t-on les frontières ? Voici le versant stratégique.

Un prix n'est pas un float, un e-mail n'est pas un string. Voici comment donner à chaque concept de ton métier un type qui porte ses règles — la brique fondatrice du DDD tactique, jusque dans Doctrine.

Comment ranger un agrégat en base, le ressortir intact, et le fabriquer sans trahir ses règles ? La mécanique fine de la persistance en DDD — repository, factory, et le piège de la reconstitution.

On les cite toujours ensemble, mais ce sont deux idées distinctes. Séparer lecture et écriture d'un côté ; stocker l'histoire plutôt que l'état de l'autre. Quand chacune vaut le coût — et quand elle ne le vaut pas.

Un design pattern n'est pas une brique à empiler pour faire pro — c'est un nom donné à une solution que tu réinventes déjà. SOLID, les patterns essentiels du Gang of Four, et surtout : quand ne PAS en mettre.

Processus, threads, parallélisme, FastCGI, le pool PHP-FPM et FrankenPHP. Comment PHP traite plusieurs requêtes à la fois, et où va la mémoire.

Dès que deux threads partagent une mémoire, tu perds le droit d'affirmer qu'entre deux lignes personne n'a touché à tes données. Voici comment reconstruire cette certitude — et ce que ça coûte.

Ce qui existe, et ce qui se passe. Les deux unités que ton système sait faire tourner, comment le noyau les confond, et pourquoi ça décide de tout le reste.