Et si votre script PHP pouvait devenir un exécutable autonome, sans dépendance, sans serveur et sans Composer ? Jean-François Lépine nous a démontré qu’il est désormais possible de transformer du code PHP en binaire statique, capable de s’exécuter partout — à la manière d’un outil Go ou Rust. Une innovation qui redéfinit la portabilité et l’industrialisation du développement PHP.

Historiquement, PHP repose sur différentes SAPI (Server Application Programming Interface) qui servent d’intermédiaire entre le moteur Zend et le monde extérieur (terminal, serveur web, etc.). Si les interfaces cli, phpdbg ou fpm-cgi sont bien connues, la SAPI embed l’est beaucoup moins. C’est pourtant elle qui permet d’embarquer le moteur PHP directement dans une autre application, ouvrant la voie à l’exécution de scripts totalement autonomes.

Construire un binaire PHP statique

Pour rendre cela possible, deux projets phares ont été présentés :

• static-php-cli (SPC) — l’outil principal pour compiler PHP en binaire statique ;
• phpmicro.sfx — qui fusionne le moteur PHP et le code source .phar en un seul exécutable.

Le processus de création d’un binaire PHP repose sur plusieurs étapes simples :

1. Créer une archive .phar du projet avec ses dépendances (outil recommandé : box) ;
2. Télécharger et configurer SPC ;
3. Installer les dépendances et extensions nécessaires, puis corriger les manques via spc doctor --auto-fix ;
4. Optimiser le binaire final avec upx (optionnel) ;
5. Construire le binaire exécutable via spc build, compatible Linux, macOS et Windows (ARM ou AMD).

Pour simplifier cette procédure, le conférencier a également évoqué phpacker/phpacker, un outil prometteur qui automatise toutes ces étapes en une seule commande.

Forces, limites et cas d’usage

Le résultat obtenu est un véritable moteur PHP encapsulé dans un seul fichier exécutable. Certaines limitations subsistent, notamment l’absence du support FFI, une taille de binaire plus importante et un démarrage légèrement plus lent. Malgré cela, l’approche est idéale pour l’outillage en ligne de commande ou les environnements contraints sans dépendances système.

Jean-François a cité plusieurs projets de référence tels que Castor ou FrankenPHP, qui exploitent SPC pour proposer des versions statiques performantes et portables. Une approche qui ouvre à PHP de nouveaux horizons, notamment dans le domaine du DevOps et du scripting multiplateforme.

Une nouvelle dimension pour PHP

En conclusion, Jean-François Lépine rappelle que « le PHP compilé reste du PHP » : fiable, portable et flexible. Grâce à ces nouvelles approches, le langage entre dans une nouvelle ère, où il devient possible d’exécuter PHP sans l’installer, tout en conservant sa puissance et sa simplicité.

Concevoir une application SaaS multi-tenant en 2025 représente un défi majeur pour les équipes techniques. Lors de cette conférence, Vincent Demonchy a partagé son retour d’expérience sur la manière de bâtir une architecture performante, évolutive et sécurisée avec PHP, Laravel et PostgreSQL. L’objectif : comprendre comment faire les bons choix techniques en matière de calcul, de cache, de stockage et surtout de base de données.

Comprendre le concept de multi-tenancy

Le multi-tenancy (ou multi-locataire) est un modèle d’architecture logicielle dans lequel une seule application sert plusieurs clients, appelés « tenants ». Chaque tenant correspond à une entreprise, une organisation ou un groupe d’utilisateurs partageant les mêmes données et configurations.

Dans une application multi-tenant, les données de chaque client sont strictement isolées. Ainsi, deux tenants peuvent utiliser la même plateforme tout en ayant l’impression de disposer de leur propre environnement applicatif.

Quand (et pourquoi) adopter une architecture multi-tenant

Le multi-tenant s’impose pour les applications SaaS B2B nécessitant une gestion fine de la confidentialité, de la scalabilité et de la conformité réglementaire. C’est le modèle idéal pour les éditeurs qui veulent mutualiser les coûts tout en garantissant l’isolation des données.

À l’inverse, une telle architecture est moins adaptée aux projets B2C à faible besoin d’isolation ou à un produit destiné à un unique client — où la complexité technique d’un modèle multi-tenant n’est pas justifiée.

Stratégies d’isolation des tenants

Plusieurs stratégies de silotage existent selon le niveau d’isolation recherché :

• Par propriété : chaque objet métier contient un identifiant unique de tenant. Simple à mettre en œuvre, mais la sécurité dépend fortement de la rigueur du code applicatif.
• Par objet logique : séparation via un préfixe de table, un schéma ou une base logique distincte dans le même SGBD.
• Par objet physique : chaque tenant dispose de sa propre base de données. Solution la plus isolée, mais plus coûteuse à maintenir et à scaler.

Implémenter le multi-tenant dans Laravel

Laravel offre un écosystème riche facilitant la mise en place du multi-tenancy. Deux bibliothèques principales ont été présentées par Vincent Demonchy :

• spatie/laravel-multitenancy — une approche simple et claire, idéale pour les projets nécessitant un contrôle précis sur la logique métier.
• stancl/tenancy — plus complète et flexible, adaptée aux projets SaaS avancés où chaque tenant possède une configuration propre.

Les deux solutions permettent de gérer dynamiquement les connexions à la base de données, l’isolation des fichiers de cache et la configuration des files d’attente ou des tâches planifiées. Le choix entre les deux dépendra de la complexité de l’application et du niveau d’indépendance requis pour chaque client.

Vers un SaaS PHP plus modulaire et scalable

En conclusion, cette conférence a offert une vision pragmatique du développement SaaS moderne : faire le bon arbitrage entre performance, sécurité et maintenabilité. Grâce à Laravel et à l’écosystème open source, construire une application multi-tenant robuste en PHP n’a jamais été aussi accessible — à condition de penser l’architecture dès la conception.

Atteindre 180 000 requêtes HTTP par seconde avec PHP — un chiffre impressionnant, presque irréel. C’est pourtant le défi que Xavier Leune a relevé en direct, démontrant qu’avec une compréhension fine des mécanismes bas-niveau de PHP et du protocole HTTP, il est possible d’atteindre des performances extrêmes même depuis un simple ordinateur portable.

L’objectif de cette présentation n’était pas seulement de battre des records, mais surtout de expliquer pas à pas comment optimiser les appels API et comprendre les limites du langage PHP en matière de réseau et de concurrence. À travers cette approche progressive, Xavier a rendu accessibles des notions souvent réservées aux experts en performance backend.

Comprendre les bases : le rôle de cURL et d’HTTP

Pour cette démonstration, Xavier n’a pas utilisé de client HTTP haut-niveau comme Guzzle ou le HttpClient de Symfony. À la place, il a préféré un code custom basé sur cURL, permettant un contrôle total des connexions réseau et des paramètres de performance.

L’un des premiers enseignements est l’importance de réutiliser les connexions HTTP. Chaque nouvelle ouverture de socket impose un coût non négligeable en latence — un frein majeur quand on vise des centaines de milliers de requêtes par seconde.

Techniques d’optimisation et parallélisation

Pour atteindre de tels débits, plusieurs leviers ont été exploités :

• Réutilisation de la même connexion : évite les délais liés aux handshakes TCP et TLS.
• Utilisation de curl_multi_init() : permet d’exécuter plusieurs requêtes HTTP en parallèle, maximisant ainsi le débit réseau.
• Busy looping : technique consistant à occuper continuellement le CPU en vérifiant une condition sans pause, utilisée ici pour éviter toute attente bloquante.
• Multi-threading avec l’extension pcntl : grâce à la fonction pcntl_fork(), chaque thread duplique le processus et exécute une partie du travail simultanément.
• Partage mémoire via shmop : permet la lecture et l’écriture en mémoire partagée, facilitant la communication entre processus sans passer par le disque.

Ces optimisations, combinées à une architecture horizontale et une gestion fine des ressources, ouvrent la voie à des scénarios de scaling massif — essentiels pour les applications SaaS et les systèmes à fort trafic API.

De la performance brute à la scalabilité

Bien que centrée sur les performances pures, la conférence de Xavier Leune abordait aussi une notion clé : la scalabilité horizontale. Une fois la limite atteinte sur une seule machine, il faut penser en termes de distribution de charge et de duplication d’instances.

Cette approche démontre qu’en combinant optimisation bas-niveau et stratégies de scaling, il est possible de concevoir des architectures PHP capables de rivaliser avec les systèmes les plus performants du marché.

Pour les plus curieux, le code source de la démonstration est disponible sur GitHub : github.com/xavierleune/180000-rps .

Et si l’on pouvait atteindre la fluidité d’une application moderne sans écrire une seule ligne de JavaScript ? C’est le défi que Damien Alexandre a relevé lors de cette conférence, en présentant HTMX : une librairie qui redonne ses lettres de noblesse à HTML et HTTP tout en offrant l’expérience utilisateur d’une Single Page Application (SPA).

Les frameworks front-end tels que React, Vue ou Angular ont révolutionné le web moderne, mais au prix d’une complexité accrue, d’une dette technique importante et d’un coût en performance non négligeable. HTMX propose une alternative élégante et minimaliste, centrée sur la simplicité : quelques attributs HTML suffisent pour transformer une application serveur classique en interface réactive et fluide.

HTMX + Twig : une combinaison gagnante

Intégré dans un projet Symfony, HTMX permet d’ajouter de l’interactivité directement dans les templates Twig. L’exemple suivant, présenté par Damien, illustre parfaitement le principe :

{% block like %}
  <button class="{{ isLiked ? 'text-rose-600' : 'text-neutral-500' }}"
          hx-post="{{ path('app_like_toggle') }}"
          hx-swap="outerHTML"
  >❤</button>
{% endblock %}

Ce simple bouton envoie une requête AJAX (hx-post) vers la route Symfony app_like_toggle et remplace son propre contenu (hx-swap) par la réponse HTML reçue. Pas de JavaScript additionnel, pas de gestion manuelle du DOM : tout repose sur les standards du web.

Des exemples concrets et inspirants

Damien a démontré à quel point HTMX simplifie la création de fonctionnalités interactives :

• Formulaires dynamiques et validation asynchrone
• Scroll infini et chargement progressif
• Recherche « as you type »
• Chargement différé de contenus ou de composants

Ces exemples prouvent qu’un développeur backend peut concevoir des interfaces riches sans recourir à un framework JavaScript complet. HTMX repose sur une approche progressive : on garde une architecture serveur classique, tout en ajoutant des interactions fluides côté client.

Améliorer la DX et l’intégration

Pour les développeurs souhaitant aller plus loin, plusieurs outils facilitent l’usage de HTMX :

• tomcri/htmxpony : un bundle qui améliore la Developer Experience (DX)
• Support natif dans PHPStorm pour la complétion et la syntaxe
• Compatibilité avec Turbo Streams et les Server-Sent Events (SSE)

Damien a également précisé que dans les projets déjà équipés de Symfony UX avec Stimulus et Hotwire Turbo, ces solutions restent plus intégrées et cohérentes. En revanche, pour des projets plus légers ou sans Symfony UX, HTMX s’impose comme une alternative idéale.

Une approche pragmatique et pérenne

HTMX permet de se concentrer sur l’essentiel : le code métier côté serveur. En retournant simplement du HTML enrichi d’attributs HTMX, les développeurs peuvent offrir une expérience fluide, rapide et compatible avec la majorité des navigateurs modernes.

La version 2 d’HTMX est désormais compatible avec tous les navigateurs modernes (hors Internet Explorer), tandis que la version 1 maintient encore le support IE pour les environnements legacy.

Retrouvez la présentation complète et les exemples de code sur les slides de la conférence : https://jolicode.github.io/htmx-conf/1 .

Trente ans de PHP, trente ans d’évolution du web. C’est avec un mélange de nostalgie et d’admiration qu’Antoine Bluchet a retracé l’incroyable parcours de ce langage qui continue de faire battre le cœur d’Internet. De ses premiers scripts dynamiques jusqu’à l’ère des frameworks modernes, cette conférence proposait un véritable voyage à travers l’histoire de PHP et son rôle central dans la construction du web que nous connaissons aujourd’hui.

Antoine a débuté en rappelant ses débuts sur les célèbres tutoriels « PHP/MySQL du Site du Zéro », une madeleine de Proust pour toute une génération de développeurs francophones. Depuis, le langage a connu une transformation spectaculaire : d’un simple outil de génération de pages HTML, il est devenu une plateforme complète capable de supporter les architectures les plus complexes, les CMS les plus populaires et les frameworks les plus performants.

De PHP 3 à PHP 8 : trois décennies d’innovation

Antoine a retracé les grandes étapes de cette évolution : l’introduction des objets en PHP 5, l’arrivée de Composer et du PSR qui ont professionnalisé l’écosystème, jusqu’à l’émergence de frameworks modernes tels que Symfony, Laravel et Drupal. Autant d’outils qui ont contribué à hisser PHP au rang des langages incontournables du développement web.

Il a également évoqué l’impact colossal des CMS open source comme WordPress, qui propulse aujourd’hui près de la moitié des sites Internet, ainsi que des solutions e-commerce modulaires telles que Sylius et Magento, démontrant la polyvalence et la longévité du langage.

Performance et modernité : PHP n’a jamais été aussi fort

Au-delà du regard historique, la conférence a aussi montré comment PHP continue de repousser ses limites techniques. Antoine a pris pour exemple une application moderne dopée aux dernières optimisations de l’écosystème PHP, associées à la puissance de FrankenPHP en mode worker. Résultat : des gains de performances impressionnants, capables de rivaliser avec des environnements compilés.

En combinant JIT (Just-In-Time compilation), opcache, des optimisations serveur, et une architecture orientée worker, PHP prouve qu’il reste une technologie de choix pour des applications web modernes, scalables et performantes.

Une conférence entre hommage et projection

Plus qu’un exposé technique, cette session était un véritable hommage à l’écosystème PHP. Antoine a su transmettre la passion et la résilience d’une communauté qui a su se réinventer à chaque décennie. De la création artisanale de sites à la montée en puissance des architectures SaaS et API-first, PHP s’est adapté, modernisé et renforcé, tout en restant fidèle à sa mission d’origine : rendre le web accessible et performant.

En conclusion, la conférence a mis en lumière un constat clair : PHP n’est pas un langage du passé, mais une plateforme vivante, robuste et tournée vers l’avenir.

Et si la clé de la performance était… la paresse ? C’est le fil conducteur de cette conférence passionnante animée par Nicolas Grekas, figure emblématique de la Symfony Core Team. En bon artisan du framework, il a rappelé que les développeurs ont souvent tendance à trop en faire — et que, paradoxalement, apprendre à “ne rien faire tant que ce n’est pas nécessaire” est l’une des meilleures optimisations possibles.

Le vrai coût caché des dépendances

Nicolas a commencé par identifier un coupable fréquent des lenteurs et de la surconsommation mémoire : l’instanciation prématurée de services. Dans un projet Symfony, chaque requête peut déclencher la création de dizaines — voire de centaines — d’objets, même lorsque certains ne sont jamais utilisés. C’est particulièrement vrai pour les Event Listeners, souvent trop généreux en dépendances injectées.

Résultat : une application plus lourde, des temps de démarrage allongés, et une empreinte mémoire inutilement élevée. La solution ? Être “suffisamment paresseux”.

Le lazy loading à la rescousse

Nicolas a illustré comment le mécanisme de lazy loading intégré à Symfony permet de ne charger les services qu’au moment où ils sont réellement utilisés. Grâce à des outils comme #[Lazy] ou #[AutowireMethodOf], il devient possible d’ajuster la granularité de l’injection de dépendances avec une grande précision.

Cette approche permet non seulement de réduire la consommation de ressources, mais aussi d’améliorer la lisibilité et la maintenabilité du code. En ne surchargeant plus le conteneur de services, les développeurs conservent un code plus propre, plus prévisible et surtout plus performant.

Les outils Symfony au service de la “paresse efficace”

La session a passé en revue plusieurs fonctionnalités puissantes mais parfois méconnues du framework :

• Autowiring — pour simplifier la déclaration de dépendances ;
• Lazy services — pour retarder l’instanciation ;
• Service locators — pour injecter un sous-ensemble ciblé de services ;
• Iterateurs — pour itérer paresseusement sur des collections de services.

Ces mécanismes permettent d’atteindre une efficacité remarquable sans complexifier inutilement le code. Nicolas a insisté sur un point clé : ces optimisations ne doivent pas être vues comme des “micro-tweaks”, mais comme une philosophie d’ingénierie à adopter dès la conception des applications.

Une approche pragmatique et immédiatement applicable

Fidèle à son style clair et direct, Nicolas a livré une masterclass technique mais pragmatique. Chaque exemple présenté pouvait être réutilisé tel quel dans un projet Symfony existant. L’idée n’était pas de théoriser sur la performance, mais de montrer comment de petites optimisations ciblées peuvent avoir un impact mesurable sur le comportement d’une application.

En conclusion, cette conférence rappelait que l’un des grands atouts de Symfony réside dans sa capacité à équilibrer puissance, flexibilité et performance. Et que parfois, le meilleur conseil à suivre pour aller plus vite, c’est simplement d’en faire moins.

Sylius 2, le framework e-commerce basé sur Symfony et sorti fin 2024, marque une étape importante dans l’évolution de la plateforme. Toujours aussi accessible, il gagne en puissance, en modularité et en rapidité d’exécution, tout en restant fidèle à sa philosophie : offrir une base solide et extensible pour les projets e-commerce modernes.

Dans cette session dynamique, Maxime Huran nous a démontré, preuves à l’appui, qu’il est désormais possible de créer un site e-commerce complet avec Sylius 2… en moins de 40 minutes. Son exemple concret : un site de vente de jeux vidéo, développé en direct devant le public.

Les nouveautés majeures de Sylius 2

Maxime a commencé par une introduction aux nouvelles fonctionnalités clés de Sylius 2 : refonte du cœur du framework, meilleure intégration avec Symfony 7, simplification du cycle de développement, et un système d’extensions encore plus flexible. L’objectif est clair : rendre le framework à la fois plus rapide à mettre en œuvre et plus adaptable aux besoins spécifiques de chaque projet.

Une démonstration concrète et percutante

La démo live a captivé l’audience. En quelques lignes de code, Maxime a généré un back-office complet avec CRUD, gestion des produits, catégories et commandes. Grâce aux nouvelles commandes en console et à la puissance du maker bundle, Sylius 2 permet désormais de bâtir une base fonctionnelle en un temps record.

Il a ensuite montré comment étendre et personnaliser le comportement natif de Sylius grâce aux hooks et aux systèmes d’événements. Cette approche offre un équilibre idéal entre productivité et flexibilité, tout en conservant la robustesse de Symfony.

Un framework e-commerce mature et moderne

Ce qui ressort de cette conférence, c’est la maturité croissante de Sylius. Avec cette version 2, le framework s’impose plus que jamais comme une alternative sérieuse aux solutions e-commerce monolithiques. Il s’adresse aussi bien aux petites boutiques cherchant à se lancer rapidement, qu’aux architectures SaaS ou B2B nécessitant des intégrations complexes.

Maxime a également rappelé que Sylius s’appuie sur la philosophie “API First” et reste parfaitement compatible avec des outils modernes tels qu’API Platform ou GraphQL. En bref, Sylius 2, c’est l’agilité du monde Symfony mise au service de l’e-commerce.

Pour ceux qui souhaitent approfondir le sujet, les slides de la présentation sont disponibles ici : https://www.maximehuran.fr/fr/developpez-sous-sylius-2-en-40-minutes-top-chrono .

Composer est aujourd’hui le cœur battant de tout projet PHP moderne. Indispensable et omniprésent, il orchestre la gestion des dépendances, automatise la configuration et assure la cohérence de nos environnements de développement. Pourtant, malgré son usage quotidien, rares sont ceux qui savent réellement ce qu’il se passe derrière un simple composer install.

Dans cette conférence aussi claire que captivante, Felix Eymonot nous a invité à “soulever le capot” pour comprendre le fonctionnement interne de Composer. Objectif : rendre cet outil un peu moins magique, et beaucoup plus maîtrisable.

Un chef d’orchestre depuis 2012

Né en 2012, Composer s’est imposé comme le gestionnaire de dépendances incontournable du monde PHP. Son rôle : analyser les contraintes de version, télécharger les paquets nécessaires, et garantir la stabilité de votre projet. Felix a détaillé les trois grandes étapes exécutées lors d’un composer install :

• Résolution des dépendances : choix des versions compatibles entre elles.
• Vérification cryptographique : contrôle des signatures et des hachages pour assurer l’intégrité.
• Optimisation de l’autoloader : création d’un chargement de classes performant.

Composer.json, composer.lock et vendor : le trio magique

Felix a ensuite levé le voile sur la relation entre les trois piliers d’un projet Composer :

• composer.json définit les dépendances et les métadonnées du projet.
• composer.lock fige les versions exactes installées pour garantir la reproductibilité.
• Le dossier vendor/ contient enfin le code des dépendances téléchargées.

Il a rappelé un point essentiel : le fichier composer.lock doit toujours être versionné, car il assure la stabilité et la sécurité de votre environnement.

Diagnostiquer les erreurs et comprendre les blocages

Composer n’est pas infaillible, et il arrive qu’une installation échoue. Felix a partagé plusieurs commandes précieuses pour déboguer efficacement vos projets :

• composer why package → savoir qui utilise un package donné.
• composer why-not package → comprendre pourquoi une mise à jour est bloquée.
• composer depends --tree → visualiser la hiérarchie complète des dépendances.

Ces outils de diagnostic permettent de gagner un temps considérable lors de conflits de versions ou d’erreurs d’installation.

Autoloading : la clé des performances

L’un des points les plus techniques, mais aussi les plus instructifs de la présentation, concernait le fonctionnement de l’autoloader de Composer. Felix a détaillé les quatre principales méthodes de chargement des classes :

• PSR-4 — basée sur les namespaces.
• Classmap — génération d’une table de correspondances.
• APCu — version en cache mémoire pour des performances maximales.
• Files — chargement manuel de fichiers spécifiques.

Un moment clé de la session a été la démonstration de la commande d’optimisation pour la production : composer install --no-dev --optimize-autoloader --apcu-autoloader. Une astuce simple, mais souvent négligée, pour réduire drastiquement le temps de chargement et améliorer la performance globale de vos applications PHP.

La sécurité applicative est aujourd’hui un enjeu majeur de tout projet web. Amaury Bouchard a livré une présentation claire et structurée sur les principales menaces auxquelles les développeurs sont confrontés — et surtout sur les bonnes pratiques à mettre en œuvre pour s’en prémunir efficacement.

En introduction, il rappelle un chiffre marquant : 60 % des entreprises victimes d’une cyberattaque ferment dans les 18 mois. Les principaux vecteurs d’intrusion restent le phishing, l’exploitation de failles applicatives et les attaques par déni de service (DoS).

1. Configuration du serveur HTTP

Une grande partie de la sécurité repose sur une bonne configuration serveur. Il faut notamment :

• Masquer l’accès aux fichiers sensibles et aux informations de version du framework ;
• Forcer le HTTPS et activer Strict-Transport-Security ;
• Bloquer l’inclusion du site dans des <iframe> avec X-Frame-Options: DENY ;
• Empêcher la détection automatique du type MIME (X-Content-Type-Options: nosniff) ;
• Limiter les scripts externes avec Content-Security-Policy (CSP) ;
• Définir Referrer-Policy et Permissions-Policy pour renforcer la confidentialité.

2. Injection SQL

L’injection SQL consiste à injecter du code SQL dans un champ utilisateur afin de manipuler la base de données.

Pour s’en protéger :

• Utiliser des requêtes préparées (prepare() / execute()) ;
• Privilégier un ORM ou un query builder comme Doctrine ;
• Ne jamais concaténer directement les entrées utilisateur dans les requêtes SQL.

3. Cross-Site Scripting (XSS)

L’attaque XSS vise à injecter du JavaScript malveillant dans une page afin d’exécuter du code côté navigateur (exfiltration de cookies, redirections, minage…).

Exemples de prévention :

• Échapper les données à l’affichage avec htmlspecialchars() ou les moteurs de templates (Twig, etc.) ;
• Pour le contenu HTML riche, utiliser un sanitizer comme HTML Purifier ou le Symfony HTML Sanitizer ;
• Activer une Content-Security-Policy limitant les scripts inline et externes ;
• Marquer les cookies comme HttpOnly pour les rendre inaccessibles via JavaScript.

4. Server-Side Request Forgery (SSRF)

L’objectif d’une attaque SSRF est de forcer le serveur à effectuer des requêtes non prévues, souvent vers des ressources internes ou des API sensibles.

Pour s’en prémunir :

• Valider et filtrer les URLs avant de les utiliser ;
• Vérifier que l’adresse n’est pas locale ni privée (FILTER_FLAG_NO_PRIV_RANGE) ;
• Consulter les recommandations de l’OWASP.

5. Cross-Site Request Forgery (CSRF)

Une attaque CSRF consiste à faire exécuter une action involontaire par un utilisateur authentifié sur une autre page (ex. : suppression de compte).

• Utiliser des tokens CSRF sur les formulaires (automatique dans Symfony Form) ;
• Configurer les cookies avec l’attribut SameSite ;
• Vérifier le header Referer sur les requêtes sensibles ;
• Limiter la validité des tokens dans le temps.

Ressources recommandées

• OWASP – Open Web Application Security Project
• MDN – Web Security Documentation
• Mozilla HTTP Observatory

En conclusion, Amaury résume sa philosophie en une phrase simple mais essentielle : « Ne jamais faire confiance aux données entrantes ». Une maxime qui, si elle est suivie à la lettre, permet d’éviter la plupart des vulnérabilités rencontrées au quotidien.

Et si PHP sortait du web pour atterrir… sur votre console de jeux ? C’est le pari enthousiasmant d’Éric Courtial, qui a partagé le récit technique et humain de son projet : porter un jeu 2D écrit en PHP sur une Sega Dreamcast, baptisé Super Mega Aqua Ball Ultra 2000.

Après une tentative sous Unity — jugée trop « assistée » à son goût — Éric a choisi d’aller au fond des choses en gardant PHP comme langage principal. Pour y parvenir, il s’est appuyé sur des briques systèmes et embarquées : le SDK KallistiOS pour Dreamcast, et une SAPI « PHP Embed » permettant d’appeler le moteur Zend depuis du code C.

De la ligne de commande au hardware

Le talk mêlait démonstration du jeu et récit des défis techniques rencontrés. Éric a expliqué comment il a adapté le runtime PHP au contexte contraint d’une console : gestion mémoire, compilation croisée, et synchronisation graphique.

Problèmes techniques résolus

Plusieurs contraintes ont demandé des ajustements précis :

• Gestion mémoire : la Dreamcast ne gère pas la mémoire comme l’environnement classique de PHP ; il a fallu concilier le Zend Memory Manager et les spécificités matérielles.
• Désactivation d’extensions : certaines extensions PHP ont dû être désactivées pour permettre la compilation embarquée du moteur.
• Double buffering : mise en place pour éviter le tearing et les scintillements visuels lors du rendu graphique.

Grâce à ces adaptations et au couplage entre KallistiOS et PHP Embed, Éric a pu livrer une démonstration fonctionnelle : un vrai jeu 2D tournant sur la Dreamcast, contrôlé par du code PHP.

Une aventure technique et créative

Au-delà de l’aspect purement technique, la présentation était aussi un plaidoyer pour l’expérimentation : PHP peut servir à des usages inattendus lorsqu’on accepte de creuser les couches basses de la plateforme. Ce projet illustre la polyvalence du langage et la valeur de la curiosité technique pour repousser les frontières d’un écosystème.