Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

La réputation

Vous connaissiez la blague avant d’ouvrir ce livre : PHP, c’est le langage de 2004, tenu par du ruban adhésif et écrit par des gens qui n’ont jamais vraiment appris à programmer. La réputation est ancienne, elle a été méritée, et la plupart de ce qui l’a méritée n’est plus vrai. Ce chapitre tient dans cette phrase. Tout le reste du livre sert à vous laisser la vérifier vous-même, plutôt que de me croire sur parole.

Partons de ce qui reste visible. Au 17 septembre 2026, PHP fait tourner 69,9 % des sites web dont le langage côté serveur est connu, selon W3Techs, qui recalcule ce chiffre en continu à partir de l’exploration de sites en ligne et non de réponses à un sondage. Le chiffre bouge d’une semaine à l’autre : il affichait 71,8 % en mars 2026 et 70,2 % le 3 septembre 2026. Prenez donc chaque pourcentage pour un instantané, pas pour une constante, et attendez-vous à ce que celui imprimé ici soit déjà un peu faux au moment où vous le lisez. Ces variations ne changent pas l’ordre de grandeur. L’essentiel du web rendu côté serveur tourne toujours sur PHP, et si vous misez sur ce langage, vous ne misez pas seul.

Cette échelle explique aussi la réputation. Un langage qu’une large part du web utilise depuis trente ans accumule une large part du pire code du web, écrit sous toutes les pressions de délai, à tous les niveaux de compétence et à chaque époque de sa propre histoire. Le PHP des débuts, celui de l’époque phpBB et osCommerce, mélangeait HTML et logique dans la même page, sans structure imposée, sans gestionnaire de dépendances et sans manière standard de tester ce qu’on avait écrit. Un programme qui tournait suffisait souvent, faute de moyen bon marché de prouver qu’il était correct. Les critiques visant le code de cette époque étaient justes, et une part non négligeable de ce code tourne encore en production aujourd’hui, comme le montre Gouvernance et versions. Juger le langage actuel sur ce code revient à juger une entreprise sur le prototype de son année de création.

Le code lui-même a mérité la réputation, pas seulement l’époque. Une page qui mélangeait la requête SQL, la logique métier et le HTML dans un seul fichier, sans frontière imposée entre les trois, n’avait rien d’une caricature. C’était un schéma courant et fonctionnel, parce que rien dans le langage n’empêchait de l’écrire ainsi et que rien dans l’outillage ne repérait le résultat avant la mise en ligne. Il n’existait aucune manière standard de déclarer qu’une fonction attendait un entier, et non une chaîne qui en avait seulement l’air. Pour intégrer une bibliothèque tierce, on téléchargeait un zip en espérant que ses chemins de fichiers internes ne heurtent pas les vôtres. Et aucune convention partagée ne disait comment organiser le code d’une bibliothèque pour qu’une autre puisse le trouver. Prise isolément, chacune de ces lacunes n’était qu’un désagrément. Réunies, sur des millions de sites écrits chacun dans son coin, elles ont produit exactement l’écosystème que décrit la réputation.

Ce qui a changé ne l’a pas fait en silence. Le langage a gagné un vrai système de types : déclarations de types scalaires et de types de retour, types union et intersection, et declare(strict_types=1) pour soustraire un fichier entier à la conversion de types historique de PHP. Le runtime le montre avec du code. PHP a aussi gagné un gestionnaire de dépendances et un dépôt public de paquets, présentés dans Coût, qui ont transformé « télécharger un zip et espérer » en une étape d’installation résolue, verrouillable et auditable. Un processus de normalisation, les PSR, adopté librement par les auteurs de frameworks et de bibliothèques plutôt qu’imposé par le langage, a donné à l’écosystème une convention commune pour l’autoloading, la journalisation et les messages HTTP, si bien que deux bibliothèques écrites par des inconnus s’emboîtent. Les outils d’analyse statique, qui lisent une base de code sans l’exécuter, PHPStan et Psalm parmi eux, ont fait de « cette fonction renvoie-t-elle vraiment toujours ce qu’elle annonce » une question qui se tranche avant le déploiement, et non plus une surprise en production. Rien de tout cela n’efface le vieux code qui tourne encore quelque part sur le serveur de votre prestataire. Mais « PHP » et « le pire PHP que vous ayez vu » ont cessé de désigner la même chose au cours de la dernière décennie, et une revue de due diligence doit les traiter comme deux questions distinctes.

L’écosystème a changé au même rythme que le langage. Une page qu’on aurait qualifiée de « simple PHP » il y a dix ans repose aujourd’hui, le plus souvent, sur l’un des quelques frameworks full-stack disponibles, parmi lesquels CakePHP, Laminas, Laravel, Symfony et Yii, chacun imposant au code écrit chez lui sa structure, son routage et ses conventions de test. Aucun n’est présenté ici comme le bon choix ou le choix populaire. Le seul point à retenir est que le langage a cessé de s’écrire entièrement à la main à peu près au moment où la réputation s’est figée, et que la réputation, elle, n’a pas été mise à jour.

Une personne tient à bout de bras une vieille photo jaunie d'un éléphant ébouriffé emmêlé dans des câbles, et la compare au même éléphant qui se tient devant elle aujourd'hui, soigné, à côté d'une boîte à outils fermée et d'une pile de feuilles bien rangée.

La limite. La réputation n’est pas entièrement périmée. Une part non négligeable du parc installé de PHP tourne encore sur des versions qui ne reçoivent plus aucun support, et une base de code héritée, plutôt qu’écrite avec rigueur, peut être aussi peu structurée que la réputation le laisse entendre. Aucun de ces deux faits ne concerne le langage actuel. Tous deux concernent ce qu’une organisation précise a fait d’une ancienne version, et Là où PHP est le mauvais choix nomme ce schéma sans chercher à l’escamoter.

Chaque chapitre suivant a la même forme, parce qu’un document de décision qui demande votre confiance doit pouvoir être vérifié, pas seulement lu. Chacun s’ouvre sur la question que vous vous posez réellement, donne la réponse sourcée sans détour, puis montre les preuves avant l’argument qui s’appuie dessus. Chacun dit, avec ses propres mots, où PHP ne répond pas à la question traitée, car un chapitre sans limite n’est pas un chapitre auquel vous devriez vous fier. Et chacun se termine par une vérification à faire en un après-midi : une commande à lancer, une page publique à ouvrir, un benchmark à relancer. Rien de tout cela ne prétend que PHP est le bon choix pour votre prochain projet. L’argument est ailleurs : la réputation et le langage actuel sont deux choses différentes, et une évaluation digne de confiance doit regarder le second en face au lieu de citer la première de mémoire. La suite est ce regard. Comment le langage s’exécute réellement, qui le fait tourner aujourd’hui et à quelle échelle, ce qu’il coûte, qui le maintient et, aussi franchement que pour les quatre premières questions, là où il n’est pas le bon outil.

À vérifier vous-même. Ouvrez w3techs.com/technologies/details/pl-php dès maintenant et comparez le pourcentage affiché à celui imprimé plus haut ; l’écart entre les deux montre, à petite échelle et honnêtement, comment je traite un chiffre qui bouge. Lisez ensuite les chiffres sur la dispersion des versions dans Gouvernance et versions avant de décider quelle part de l’ancienne réputation s’applique encore au prestataire ou à la base de code que vous évaluez.

La question qui revient tout au long de ces pages n’est pas de savoir si PHP méritait autrefois sa réputation. Elle est de savoir si le langage que vous avez devant vous aujourd’hui, avec son système de types, son gestionnaire de dépendances et son processus de maintenance financé, complète l’architecture que vous construisez vraiment. Cette question commence avec Le runtime.

Le runtime

PHP exécute une requête par processus ou par thread, sur le Zend Engine, en mode shared-nothing par défaut : rien de ce que votre code met en mémoire ne survit à la réponse qu’il vient d’envoyer, sauf si vous changez explicitement de modèle de service pour garder l’application démarrée. Cette phrase répond à la plupart des questions que vous vous posez sur le runtime. Elle mérite qu’on s’y arrête avant de lire la suite, car presque tout ce que PHP fait bien ou mal en découle.

Une exécution shared-nothing, où rien n’est partagé d’une requête à l’autre, signifie qu’une requête démarre l’application, exécute votre code et démonte le tout, à chaque fois. Une variable affectée, une connexion à la base ouverte, un cache réchauffé en mémoire : rien de cela n’existe pour la requête suivante, qui repart d’un démarrage propre. Ce n’est pas le retard d’un langage lent qui rattraperait son temps. C’est le modèle autour duquel PHP a été construit dès l’origine, et il vous apporte une propriété précise et précieuse. Une fuite mémoire dans une requête ne peut pas s’accumuler sur mille requêtes, puisqu’il n’existe aucune mémoire partagée où s’accumuler. Un plantage dans une requête ne peut pas corrompre l’état dont dépend la suivante, puisqu’il n’y a pas d’état partagé. Le prix est celui qu’on devine : rien n’est chaud. Chaque requête qui a besoin d’une connexion à la base en ouvre une, et chaque requête qui a besoin des routes et de la configuration de l’application les reconstruit, sauf si une couche située sous le langage met le résultat en cache.

Cette couche, c’est opcache. Le code source PHP est compilé en bytecode avant de s’exécuter, et par défaut cette compilation recommence à chaque requête, depuis zéro. Opcache, livré avec PHP depuis la version 5.5, garde le bytecode compilé en mémoire partagée pour que la requête suivante saute la recompilation. Dit précisément, et non comme on le décrit d’habitude : opcache est une zend_extension, et il faut le charger dans php.ini pour qu’il fasse quoi que ce soit. La plupart des distributions l’activent dans leurs paquets, mais PHP lui-même ne le fait pas. « PHP est rapide parce qu’il met le bytecode en cache » n’est donc vrai que pour une configuration précise et vérifiable, pas pour le langage tel qu’il s’installe.

Un couloir d'hôtel avec trois chambres identiques : un client muni d'une enveloppe s'installe dans la première, un éléphant en tablier de femme de chambre défait et nettoie la deuxième, et la troisième, faite et vide, attend.

Ce que le système de types impose vraiment

Les déclarations de types ajoutées depuis PHP 7 ne sont pas décoratives. Un fichier qui les active fait respecter ses contrats par le moteur lui-même, et pas seulement par un linter :

<?php

declare(strict_types=1);

function total(float ...$prices): float
{
    return array_sum($prices);
}

total(9.99, "4.50"); // TypeError: total(): Argument #2 must be of type float, string given

Sans declare(strict_types=1), PHP convertirait une chaîne numérique en nombre flottant et poursuivrait l’exécution. Avec, l’incohérence devient une TypeError à l’endroit exact où elle se produit, au lieu d’une corruption silencieuse trois fonctions plus loin. Voilà la version concrète et vérifiable de ce qu’annonçait La réputation : le système de types a changé. Il s’active fichier par fichier, et une fois activé, il est réel.

Modèles de service : comment on contourne le shared-nothing

Trois façons de servir une application, par ordre alphabétique, couvrent l’essentiel de la production PHP aujourd’hui : FrankenPHP, PHP-FPM derrière un serveur web, et RoadRunner. PHP-FPM est le modèle historique. Un pool de processus workers traite chacun une requête à la fois, chaque processus est redémarré périodiquement, et aucun ne conserve l’état de l’application d’une requête à l’autre. C’est l’expression la plus pure du shared-nothing, et c’est encore le modèle que supposent par défaut la plupart des hébergements.

FrankenPHP et RoadRunner proposent tous deux un « mode worker » qui contourne volontairement ce comportement par défaut : l’application démarre une fois, reste en mémoire et traite de nombreuses requêtes à la suite sans redémarrage complet entre elles. La documentation de FrankenPHP le décrit sans détour, compromis compris. Les superglobales de PHP ($_GET, $_POST, $_COOKIE, $_FILES, $_SERVER, $_REQUEST) sont réinitialisées automatiquement entre deux requêtes, si bien qu’un worker ne laisse pas fuir les données de formulaire d’un visiteur dans la requête du suivant. En revanche, $_ENV n’est pas réinitialisée, et tout ce que votre propre code range délibérément hors d’une superglobale persiste tant que vous ne le videz pas vous-même. La documentation dit franchement pourquoi c’est important : selon ses termes, PHP « was not originally designed for long-running processes » (n’a pas été conçu à l’origine pour des processus de longue durée), et la parade habituelle consiste à redémarrer périodiquement les workers pour borner la mémoire qu’un processus de longue durée peut accumuler sans bruit. RoadRunner aborde la même idée par un autre côté : c’est un serveur d’applications écrit en Go qui gère un pool de workers PHP de longue durée, conservés d’une requête à l’autre au lieu d’être détruits après chacune.

Le JIT : une vraie fonctionnalité, un bénéfice étroit

PHP 8.0 a ajouté un compilateur Just-In-Time, et la RFC qui l’a introduit est d’une franchise inhabituelle sur ce qu’il aide et n’aide pas. Le compilateur traduit à l’exécution les portions de code les plus sollicitées en code machine, ce qui accélère nettement le travail numérique limité par le CPU. Il apporte peu à une requête web ordinaire, dont le temps se passe à attendre une base de données ou le réseau plutôt qu’à calculer, et la RFC fournit son propre benchmark qui montre exactement cet écart sur une charge réaliste.

Requêtes WordPress par seconde, benchmark de la RFC JIT elle-même Requêtes WordPress par seconde, benchmark de la RFC JIT elle-même Requête WordPress 315 req/s 326 req/s RFC JIT de PHP, wiki.php.net/rfc/jit, benchmark sur une requête WordPress, vérifié le 17/09/2026

Trois cent vingt-six requêtes par seconde avec le JIT, trois cent quinze sans, sur une requête WordPress. C’est une différence réelle et mesurée, de quelques pour cent, sur la charge que font tourner la plupart des installations PHP, et elle vient de la RFC qui a livré la fonctionnalité, pas d’un détracteur. Le JIT n’est pas rien : c’est lui qui explique l’allure des comparaisons sur le code numérique dans Performances. Ce n’est simplement pas lui qui rend plus rapide une application web écrite en PHP.

La concurrence sans threads

Quatre options, dans l’ordre que je garderai tout au long du livre, couvrent la manière dont du code PHP obtient de la concurrence à l’intérieur d’un seul processus : AMPHP, ReactPHP, Swoole (ou OpenSwoole) et, en tant que fonctionnalité du langage plutôt que bibliothèque, les Fibers. AMPHP est un ensemble de bibliothèques bâties sur le même modèle de boucle d’événements que les deux suivantes, et vise la même famille de problèmes de concurrence liés aux entrées-sorties : beaucoup de choses en attente en même temps, prises en charge par un seul processus qui ne se bloque jamais entièrement sur l’une d’elles. ReactPHP se présente, dans sa propre documentation, comme une bibliothèque bas niveau fondée sur une boucle d’événements, destinée aux serveurs et aux clients qui doivent garder ouvertes de nombreuses connexions simultanées. Swoole se décrit comme un moteur réseau événementiel à base de coroutines, écrit en C pour PHP, qui transforme les appels d’entrées-sorties normalement bloquants de PHP en appels non bloquants sous son propre ordonnanceur. Les Fibers, arrivées avec PHP 8.1, sont coopératives : une fiber se suspend et reprend via Fiber::suspend() et Fiber::resume(), et le code d’une seule fiber s’exécute à un instant donné. Tout cela relève de la concurrence, c’est-à-dire la capacité à mener de front de nombreuses tâches logiques et à passer de l’une à l’autre pendant qu’une attend une entrée-sortie. Rien de cela n’est du parallélisme, la capacité à faire réellement tourner deux tâches au même instant sur deux cœurs.

La limite. PHP n’offre pas de multithreading natif dans le code utilisateur. Les extensions PECL parallel et pthreads existent et apportent un vrai parallélisme par threads du système, mais elles sont tierces, peu adoptées, et il faut les présenter honnêtement comme « existantes, mais de niche », sans les fondre en silence dans le récit sur la concurrence ci-dessus ni les en retirer. Si votre charge a besoin de deux tâches limitées par le CPU qui tournent littéralement au même instant dans un seul processus, rien dans la liste de ce chapitre ne le fait, et Là où PHP est le mauvais choix traite cette limite en entier.

À vérifier vous-même. Sur n’importe quelle machine où PHP est installé, lancez :

php -v
php -i | grep -i opcache

La première commande vous indique la version de PHP et, en général, la SAPI (FPM, CLI ou autre) à laquelle vous avez affaire. La seconde vous dit si opcache est réellement chargé sur cette installation précise, et non s’il pourrait théoriquement l’être. La page commerciale d’un hébergeur n’est pas une preuve ; un grep sur la sortie de votre propre phpinfo(), si.

Le modèle d’exécution décrit ici, shared-nothing par défaut, contournable par certaines couches de service, concurrent mais pas parallèle, est le socle de tout ce qui suit. La question suivante ne porte plus sur la façon dont PHP exécute une requête, mais sur ceux qui le font tourner, à quelle échelle et sur quelles preuves. C’est le sujet de Qui fait tourner PHP.

Qui fait tourner PHP

PHP fait tourner la majorité du web si l’on compte les serveurs et une minorité si l’on compte les développeurs, et ces deux chiffres sont vrais en même temps parce qu’ils ne mesurent pas la même chose. Si vous n’avez entendu que l’un des deux, vous n’avez vu que la moitié du tableau, et la moitié que vous connaissez dépend sans doute de la personne qui vous l’a racontée.

Côté serveurs, W3Techs, qui explore les sites en ligne au lieu d’interroger des gens, place PHP à 69,9 % des sites web dont il parvient à détecter le langage côté serveur, au 17 septembre 2026. Ce chiffre bouge en continu au fil de l’exploration. Prenez-le donc pour un instantané et non pour une constante, avec la même réserve que celle posée dans La réputation. Côté développeurs, le tableau change. Le Stack Overflow Developer Survey 2025, fondé sur 24 759 répondants qui se déclarent développeurs professionnels, trouve 19,1 % d’utilisateurs de PHP, contre 68,8 % pour JavaScript, 54,8 % pour Python, 48,8 % pour TypeScript, 29,9 % pour C# et 29,6 % pour Java.

Part des développeurs professionnels qui utilisent chaque langage, 2025 Part des développeurs professionnels qui utilisent chaque langage, 2025 JavaScript 68,8 % Python 54,8 % TypeScript 48,8 % C# 29,9 % Java 29,6 % PHP 19,1 % Go 17,4 % Ruby 6,9 % Stack Overflow Developer Survey 2025, 24 759 répondants professionnels, données 2025

Lisez ce graphique tel qu’il doit être lu, et non comme l’un ou l’autre camp d’un débat le préférerait. PHP se place derrière JavaScript, Python, TypeScript, C# et Java, et devant Go et Ruby, à 17,4 % et 6,9 %. Ce n’est pas le langage dominant chez les développeurs professionnels, et ce n’est pas non plus un langage de niche. Il occupe une position précise, au milieu du classement et bien peuplée, et un lecteur hostile qui consulte l’enquête lui-même trouvera exactement ce graphique, pas une version plus flatteuse ou plus arrondie.

Les deux chiffres ne se contredisent pas. Ils comptent des populations différentes. Celui de W3Techs compte des sites en service, dont la plupart ont été construits une fois puis peu entretenus, voire pas du tout. Une énorme part du web est faite de petits sites marchands, de blogs et de plateformes de contenu bâtis sur un CMS, et les CMS, parmi lesquels Drupal, Joomla, TYPO3 et WordPress, tournent sur PHP. Celui de Stack Overflow compte les développeurs qui ont choisi de répondre à une enquête destinée aux professionnels qui écrivent du code au quotidien, une population plus petite, plus autosélectionnée et différente de « tous ceux qui ont un jour mis un site en ligne ». Les deux chiffres sont honnêtes. Aucun, à lui seul, ne répond à « les développeurs que mon nouveau projet vise connaissent-ils déjà PHP ? », plus proche de la question des effectifs, ni à « mon application va-t-elle côtoyer beaucoup d’autres infrastructures PHP ? », plus proche de la question des serveurs.

Une rue où presque chaque devanture porte une petite enseigne à l'éléphant, alors que seules trois personnes dans la foule du trottoir portent un badge à l'éléphant ; au coin de la rue, un éléphant compte les deux sur un bloc-notes.

Pour une décision de recrutement, le chiffre des développeurs est en général le plus utile, parce qu’il se rapproche de la question « combien de personnes connaissant déjà ce langage pourrais-je raisonnablement embaucher ? ». Le chiffre des serveurs se rapproche plutôt de « quelle part de l’infrastructure environnante, des panneaux de contrôle d’hébergement aux extensions de CMS en passant par les outils internes d’autres entreprises, supposera que PHP est de la partie ? ». Les deux questions ont leur place dans une revue de due diligence, et les fondre en une seule phrase du type « PHP est populaire » efface précisément la distinction dont vous avez besoin.

Un cas à grande échelle, documenté par l’organisation elle-même

Les chiffres agrégés sur le web sont utiles, mais vous voulez aussi savoir à quoi ressemble PHP sous une charge réelle et soutenue, pas seulement à quelle fréquence il apparaît. Wikimedia est l’une des rares organisations à le documenter en détail, avec ses propres mots, sur son propre wiki technique et non par l’intermédiaire d’un tiers. MediaWiki, le logiciel qui fait tourner Wikipédia et ses projets frères, est écrit à environ 70 % en PHP selon Wikimedia, soit près de deux millions de lignes de code PHP maintenues par la fondation. Il tourne dans sept centres de données, trois aux États-Unis, deux en Europe, un en Asie et un en Amérique du Sud, derrière plusieurs étages de cache (Varnish et Apache Traffic Server devant, APCu et Memcached derrière l’application) qui maintiennent réactif un site du top dix mondial sous un trafic continu venu du monde entier.

Datacenters de Wikimedia qui font tourner MediaWiki, par région Datacenters de Wikimedia qui font tourner MediaWiki, par région États-Unis 3 Europe 2 Asie 1 Amérique du Sud 1 Wikimedia, wikitech.wikimedia.org/wiki/Wikimedia_infrastructure, consulté le 17/09/2026

Cette répartition géographique compte pour une raison qui dépasse la redondance : elle montre que le modèle de requête shared-nothing de PHP, décrit dans Le runtime, n’est pas une limite réservée aux petits sites. Dans chacun de ces sept emplacements, une requête démarre, s’exécute et se démonte de façon indépendante, sans mémoire partagée par construction, et l’ensemble sert pourtant l’un des sites les plus visités d’internet. Le trafic y est routé selon la géographie, si bien qu’un visiteur obtient sa réponse du centre de données le plus proche plutôt que d’un centre unique. La documentation de Wikimedia est une page de wiki vivante et non un rapport daté, je la cite donc avec sa date de consultation, le 17 septembre 2026, et je la traite comme toute source qui évolue : exacte au jour de la lecture, pas figée pour toujours.

Ce cas ne remplace pas une enquête. Une organisation, si grande soit-elle, prouve qu’une chose est possible ; elle ne décrit pas une distribution. Elle vous apprend que PHP peut être exploité à cette échelle par une organisation prête à investir dans les couches de cache et de routage qui l’entourent. Elle ne vous dit pas quelle part des déploiements PHP atteint réellement cette échelle, et je ne laisserai pas entendre le contraire en présentant un exemple unique comme représentatif.

Ceux qu’il faut écarter

Deux noms reviennent par réflexe dès qu’on parle de PHP à grande échelle, et tous deux appartiennent à l’autre colonne. On suppose souvent que Meta et Slack font tourner PHP, à cause du lien historique entre PHP et les débuts de l’ingénierie chez Meta. En réalité, tous deux utilisent Hack, un langage apparenté mais distinct, sur HHVM, un runtime qui a rompu la compatibilité avec PHP il y a des années. Les compter comme preuves en faveur de PHP serait exactement le genre de tri sélectif que la règle de neutralité de ce livre doit empêcher. Je les nomme donc ici pour les écarter, pas pour les revendiquer.

La limite. En dehors de Wikimedia, les études de cas PHP à grande échelle, vérifiables et documentées à la source, sont plus difficiles à trouver que la réputation ne le laisse croire. Plusieurs des chiffres qu’on répète volontiers sur d’autres grandes plateformes PHP remontent à des billets de blog sponsorisés, à des conférences résumées de seconde main ou à des documents commerciaux vieux de plusieurs années, plutôt qu’à une déclaration actuelle et datée de l’entreprise elle-même. Je préfère publier une seule étude de cas que je peux défendre entièrement plutôt que plusieurs que je ne peux pas défendre, et je le dis ici au lieu de remplir le chapitre en douce.

À vérifier vous-même. Ouvrez w3techs.com/technologies/details/pl-php et comparez le pourcentage en ligne à celui imprimé plus haut. Ouvrez ensuite les résultats technologiques du Stack Overflow Developer Survey de l’année en cours et regardez où se situe réellement PHP face aux langages que votre équipe connaît déjà : pour une décision de recrutement, c’est en général cette comparaison qui compte, et non la part agrégée du web.

L’adoption vous dit qui fait tourner PHP et sur quelle surface. Elle ne vous dit pas à quelle vitesse tout cela tourne, une question distincte, souvent confondue avec la première, et que Performances aborde de front.

Performances

La vitesse de PHP dépend entièrement de ce que vous mesurez : sur une requête web ordinaire, il est rapide, parce que la requête passe l’essentiel de son temps à attendre une base de données ou le réseau, pas à exécuter du PHP ; sur du calcul pur, il est plus rapide que Python et plus lent que les langages compilés ou dotés d’un JIT mûr, comme Go, Rust, Java et C#. Les deux moitiés de cette phrase portent le raisonnement, et un benchmark qui ne vous en montre qu’une vous cache la moitié du tableau.

Dans la plupart des discussions sur la performance, le mot « rapide » recouvre trois choses qu’il faut séparer avant de regarder le moindre chiffre. Le débit, c’est le nombre de requêtes qu’un matériel donné sert par seconde, et c’est lui qui compte quand vous dimensionnez une infrastructure. La latence, c’est le temps que met une requête précise à obtenir sa réponse, et c’est elle que ressent l’utilisateur qui attend sa page. La vitesse de calcul brute, enfin, c’est le temps que prend un morceau d’arithmétique donné, et elle intéresse la tâche de fond qui fait du calcul numérique lourd. Avec le modèle de PHP, un processus par requête et rien de partagé, décrit dans Le runtime, les deux premières dépendent surtout de la quantité d’entrées-sorties de la requête et du réglage de la couche qui sert l’application, pas de la vitesse arithmétique du langage. La troisième est le seul cas où le langage lui-même fait goulot. C’est elle qui demande le plus de soin dans ce chapitre, parce que c’est aussi celle qu’on mesure le plus souvent avec un micro-benchmark synthétique avant d’en tirer, en douce, une conclusion sur la performance web. Ce glissement, j’essaie de ne pas le commettre.

Le benchmark que je ne peux pas utiliser

Le benchmark de référence pour comparer les frameworks web entre langages, TechEmpower Framework Benchmarks, a été arrêté le 24 mars 2026, et son dépôt GitHub est désormais archivé. Le dernier tour complet, le Round 23, publié le 17 mars 2025, couvrait plus de 330 implémentations de frameworks dans de nombreux langages. Je préfère vous donner la date de cet arrêt que citer un tour périmé comme s’il était encore d’actualité : si vous cherchez un tour plus récent, vous ne trouverez que l’avis d’archivage, et mieux vaut expliquer ce trou que faire comme s’il n’existait pas. C’est aussi pour cela que ce chapitre s’appuie davantage sur deux autres sources : un benchmark livré avec la proposition qui a introduit le JIT de PHP, et une suite de benchmarks multilangages maintenue de façon indépendante et toujours active.

Ce que le JIT vous apporte vraiment sur une requête web

Le runtime a déjà présenté le compilateur à la volée (JIT) de PHP, et l’aveu de sa propre RFC : il aide bien plus le code de calcul que le code web ordinaire. Ce même benchmark est la preuve de performance la plus nette de tout ce guide, justement parce qu’il vient des personnes qui ont construit la fonctionnalité et qui avaient tout intérêt à la montrer sous son meilleur jour.

Requêtes WordPress par seconde, benchmark de la RFC JIT elle-même Requêtes WordPress par seconde, benchmark de la RFC JIT elle-même Requête WordPress 315 req/s 326 req/s RFC JIT de PHP, wiki.php.net/rfc/jit, benchmark sur une requête WordPress, vérifié le 17/09/2026

Sur une requête WordPress, on mesure trois cent vingt-six requêtes par seconde avec le JIT, trois cent quinze sans. L’écart est d’environ 3 %, sur une vraie application, d’après la RFC qui a introduit la fonctionnalité. La raison tient à l’architecture, pas à un mauvais réglage : une requête WordPress passe la plupart de son temps en requêtes SQL et en entrées-sorties, pas dans le calcul numérique que le JIT accélère. Si votre grille d’évaluation contient la question « activer le JIT rendra-t-il mon application web nettement plus rapide ? », la réponse honnête, tirée des propres chiffres de PHP, est : en général, pas beaucoup. Un benchmark qui affirme le contraire sur une charge web mérite qu’on regarde de près ce qu’il a réellement mesuré.

Le JIT n’est pas inutile pour autant. Il vise simplement une cible plus étroite que « PHP » en général. Un script en ligne de commande qui traite des images dans une boucle serrée, un worker qui fait tourner une simulation numérique, un consommateur de file qui transforme massivement des chaînes ou des tableaux sans appel réseau au milieu : voilà les charges où le compilateur montre ses gains, parce qu’elles sont limitées par le CPU, ce que n’est pas une requête WordPress. Pour décider d’activer ou non le JIT, demandez-vous quelle part de votre charge réelle calcule et quelle part attend, plutôt que de vous demander si le JIT existe.

La comparaison que PHP perd d’ordinaire sur le mauvais axe

La critique la plus courante compare PHP à Python et le déclare lent. Le Computer Language Benchmarks Game, une suite multilangages maintenue de façon indépendante et mise à jour régulièrement, raconte autre chose sur les tâches de calcul. Dans ses tests de PHP 8.4.1 face à Python 3.13, sur des tâches comme fannkuch-redux, n-body et spectral-norm, trois benchmarks classiques de calcul pur sans entrées-sorties derrière lesquelles se cacher, PHP est plus rapide que Python sur la plupart d’entre elles, d’un facteur d’environ une fois et demie à deux.

TâcheCe qu’elle solliciteLangage le plus rapide
fannkuch-reduxGénération de permutations, boucles serréesPHP
n-bodyArithmétique flottante, simulationPHP
spectral-normCalcul matriciel et vectorielPHP

Ce résultat change la façon de formuler la limite, et pas seulement le chiffre. « PHP est lent » n’est pas vrai par rapport à Python ; c’est vrai par rapport aux langages compilés et à ceux dont le JIT est mûr. Une comparaison qui s’arrête à Python et tient le résultat pour acquis compare PHP à la mauvaise catégorie, et si vous relancez ce benchmark vous-même dans le cadre d’un audit, vous retrouverez le classement imprimé ici. C’est aussi le résultat qui a le plus de chances de vous surprendre si vous arrivez avec la réputation décrite dans La réputation en tête : un langage dont on garde le souvenir d’une lenteur bat l’un des langages les plus associés au travail sur les données et aux scripts, sur l’axe précis où l’on mesure les deux.

Une piste à deux couloirs : en haut, un lièvre mène, un éléphant court deuxième et une tortue ferme la marche ; en bas, les trois mêmes coureurs font la queue à un guichet pendant qu'un employé fouille des classeurs. Une personne avec un chronomètre regarde tour à tour les deux couloirs.

La limite. Sur un débit de calcul soutenu, PHP reste derrière les langages compilés et ceux dont le JIT est mûr, Go, Rust, Java et C#, et je n’ai pas de coefficient unique, propre et tiré d’une source primaire pour chiffrer cet écart comme je peux le faire pour Python. C’est une vraie limite des données disponibles, pas une façon de dire que l’écart est faible : une charge réellement limitée par le CPU, qui fait du calcul numérique lourd avec peu d’entrées-sorties pour masquer ce temps, est une charge pour laquelle PHP n’est pas, par construction, l’outil le plus rapide. Là où PHP est le mauvais choix traite ce cas de front.

À vérifier vous-même. Le Computer Language Benchmarks Game publie l’intégralité de ses résultats à jour sur son propre site, et sa page de méthodologie précise le matériel et la version de chaque langage utilisés. Relancez une tâche qui ressemble à votre propre charge plutôt que de croire le tableau récapitulatif. Si vous voulez voir le débit de PHP sur des requêtes sans faire confiance à l’un ou l’autre benchmark, le test le plus honnête est celui que décrit L’évaluation : faites tourner une charge représentative de la vôtre sur votre propre version de PHP, avec opcache et le JIT dans l’état où vous les déploieriez vraiment.

La vitesse brute sur une seule machine n’est qu’une partie de la question de capacité. En production, ce qui compte le plus est en général ce qui se passe quand la charge grandit et que vous ajoutez des machines, et c’est là que reprend Montée en charge.

Montée en charge

PHP monte en charge comme son modèle d’exécution le laisse prévoir : horizontalement, en ajoutant derrière un répartiteur de charge des workers identiques et interchangeables, parce qu’un processus shared-nothing n’a aucun état interne à réconcilier avec un autre processus. Tout le mécanisme est là. Il n’a rien d’exotique et, sur le principe, rien de propre à PHP, mais le modèle d’exécution par défaut de PHP, décrit dans Le runtime, en fait presque la seule option, ce qui se révèle plus souvent un atout qu’une contrainte.

Pourquoi le shared-nothing passe facilement à l’échelle dans un sens

PHP-FPM repose sur des workers : un pool de processus, chacun traitant une seule requête à la fois, sans aucune mémoire en commun. Comme aucun worker ne sait quoi que ce soit que ses voisins ne puissent reconstruire aussi bien que lui, un répartiteur de charge peut envoyer n’importe quelle requête à n’importe quel worker, sur n’importe quelle machine, sans étape de coordination. Doubler la capacité revient à ajouter une seconde machine identique qui fait tourner un second pool identique, pas à repenser la manière dont la première partage son état, puisqu’il n’y a jamais eu d’état à partager. C’est cette propriété précise qui rend simples à faire monter en charge les services HTTP sans état, l’essentiel de ce qu’on construit avec PHP, sans toute la famille de bugs qui naît quand deux processus ne sont pas d’accord sur ce qu’ils croient vrai tous les deux.

Qui fait tourner PHP présente déjà la démonstration la plus nette de ce principe à grande échelle, appuyée sur une source primaire : MediaWiki, le logiciel de Wikimedia, écrit à environ 70 % en PHP selon le projet lui-même, tourne dans sept centres de données sur trois continents. Chacun peut répondre seul à une requête, parce que rien dans le modèle d’exécution de PHP ne les oblige à se coordonner au-delà de ce que les couches de cache et de routage décident explicitement de partager.

Datacenters de Wikimedia qui font tourner MediaWiki, par région Datacenters de Wikimedia qui font tourner MediaWiki, par région États-Unis 3 Europe 2 Asie 1 Amérique du Sud 1 Wikimedia, wikitech.wikimedia.org/wiki/Wikimedia_infrastructure, consulté le 17/09/2026

La leçon de cette répartition ne tient pas au nombre de centres de données. Elle tient au fait qu’aucun n’a besoin de savoir ce que font les autres pour répondre correctement à une requête. Ajoutez un huitième centre dans une nouvelle région, et le changement se résume à une décision de routage et à un déploiement, pas à une réécriture de l’architecture, parce que chaque worker, partout, fait déjà tourner la même unité autonome de PHP shared-nothing. Une architecture avec état devrait régler la réplication et la cohérence pour faire le même pas. Celle-ci n’en a pas besoin, puisqu’elle n’a jamais eu d’état partagé à répliquer.

Ce qui doit sortir du processus pour que ça marche

La montée en charge shared-nothing a une condition, simple à énoncer et facile à violer par mégarde : rien de ce qui doit survivre d’une requête à l’autre ne peut vivre dans le processus PHP. La session d’un utilisateur, une donnée mise en cache pour éviter de relancer une requête coûteuse, un fichier envoyé qui attend son traitement : tout cela doit vivre hors du worker qui l’a manipulé en premier, dans une base de données, une couche de cache à part ou un stockage partagé, parce que rien ne garantit que la requête suivante du même utilisateur arrivera sur le même worker, ni même sur la même machine. Ce n’est pas une limite propre à PHP, c’est la forme habituelle de toute couche web sans état. Je la nomme ici sans détour parce qu’une équipe qui découvre les réglages par défaut de PHP l’apprend parfois à ses dépens : elle range quelque chose dans une simple variable ou dans un cache interne au processus, puis s’étonne de le voir disparaître dès la requête suivante.

Une rangée de cinq étals de marché identiques, un éléphant à chacun, avec un seul entrepôt commun derrière eux ; une personne amène un sixième étal, encore plié, pour l'ajouter à la rangée.

Monter en charge dans un worker, pas seulement en en ajoutant

Ajouter des workers n’est pas le seul levier. Le runtime a déjà présenté quatre façons, pour du code PHP, de garder beaucoup de choses ouvertes à la fois dans un seul processus : AMPHP, ReactPHP, Swoole ou OpenSwoole, et les Fibers au niveau du langage. Pour une charge dominée par l’attente, comme de nombreuses connexions ouvertes vers des services lents, un relais de messagerie instantanée ou la diffusion d’un webhook vers de multiples destinataires, ces outils permettent à un processus de traiter bien plus de travail concurrent qu’avec une requête par worker, parce que le processus n’est pas bloqué pendant qu’il attend : il avance sur autre chose et revient ensuite. Cela ne remplace pas la montée en charge horizontale, et cela ne donne pas à PHP de parallélisme au niveau du système d’exploitation, la limite nommée clairement dans Le runtime. Mais la question qui se pose à vous n’est plus seulement « combien de workers ? ». Elle devient aussi « quelle concurrence un worker peut-il absorber avant qu’il en faille un autre ? », et la réponse dépend de celui de ces outils qui se trouve sous votre application, s’il y en a un.

Les conteneurs changent l’emballage, pas le modèle

La plupart des nouveaux déploiements PHP tournent aujourd’hui dans des conteneurs plutôt que directement sur une machine, et il vaut la peine d’être précis sur ce que cela change et ce que cela ne change pas. Un conteneur donne à chaque pool de workers son propre système de fichiers isolé et son propre jeu de dépendances, ce qui rend le déploiement reproductible. Il ne touche pas au modèle shared-nothing qui tourne dessous : dans un conteneur, PHP-FPM démarre, exécute et détruit une requête à la fois, exactement comme en dehors. Faire monter en charge un service PHP conteneurisé reste la même opération horizontale, confiée à un orchestrateur au lieu d’être faite à la main : davantage de pods identiques derrière le même genre de répartiteur de charge, chacun aussi interchangeable que le précédent. Je n’ai pas de chiffre propre, tiré d’une source primaire et indépendant des fournisseurs, pour comparer la taille d’une image de conteneur PHP ou son temps de démarrage à froid à ceux d’un autre langage, donc je n’en imprime pas. L’affirmation d’architecture qui compte, à savoir qu’aucune couche d’orchestration propriétaire n’est nécessaire pour faire tourner PHP ainsi, se vérifie directement dans la documentation de PHP-FPM, sans passer par un benchmark.

La limite. Sortir l’état du processus PHP ne fait pas disparaître le coût de cet état : le problème de montée en charge se déplace vers la base de données et le cache, qui doivent désormais encaisser la charge cumulée de tous les workers de toutes les machines. Une application PHP dont la couche web monte proprement en charge peut rester entièrement bridée par une base de données qu’on n’a pas fait grandir en même temps, et je ne prétendrai pas que la montée en charge de PHP s’étend à une brique d’infrastructure que PHP ne contrôle pas. Les serveurs en mode worker, qui restent démarrés longtemps et que décrit Le runtime, réintroduisent aussi un souci que PHP-FPM en shared-nothing n’a pas : un worker démarré depuis des heures accumule de la mémoire comme n’importe quel processus de longue durée. C’est précisément pour cela que la documentation de FrankenPHP recommande des redémarrages périodiques au lieu de prétendre que le problème n’existe pas.

À vérifier vous-même. Si vous utilisez PHP-FPM aujourd’hui, regardez dans la configuration du pool la valeur de pm.max_children, le réglage qui plafonne le nombre de processus workers qu’un pool fait tourner en même temps, et comparez-la à la mémoire disponible sur la machine. Un pool dimensionné sans ce calcul est un plafond de montée en charge courant, que l’on s’impose soi-même et qui n’a rien à voir avec le langage. Si vous évaluez plutôt un serveur en mode worker, demandez précisément comment et à quel rythme il redémarre ses workers, et traitez la réponse comme une donnée de dimensionnement, pas comme un détail à régler plus tard.

Faire monter en charge une couche web et constituer l’équipe qui la maintient sont deux problèmes distincts, et le second se laisse beaucoup moins facilement réduire à un chiffre. Qui fait vivre PHP se tourne vers les compétences disponibles, les pratiques de test et la question des personnes.

Qui fait vivre PHP

PHP compte une population de développeurs nombreuse et expérimentée, qui pour l’essentiel ne compte pas partir, et les pratiques de test et d’analyse statique que cette population déclare varient tellement que « développeur PHP » ne constitue pas, à lui seul, un gage de qualité uniforme sur lequel recruter. Les deux moitiés comptent pour une décision de recrutement, et la seconde est exactement le genre de constat qu’une version défensive de ce guide aurait laissé de côté.

Ce que les développeurs PHP disent d’eux-mêmes

« The State of PHP 2025 », de JetBrains, fait partie d’une enquête plus large, State of Developer Ecosystem, menée entre avril et juin 2025. Elle a recueilli 1 720 réponses spécifiques à PHP sur 24 534 développeurs interrogés au total. JetBrains énonce lui-même la réserve, et je la répète à chaque fois que je cite cette enquête : les résultats peuvent pencher vers les utilisateurs des produits JetBrains, qui ne forment pas la même population que « tous les développeurs PHP du monde ». Cette réserve posée, les chiffres déclarés restent instructifs. Parmi les répondants, 88 % disent avoir au moins trois ans d’expérience en PHP, et 58 % ne prévoient pas de quitter PHP dans l’année ; dans le groupe plus restreint qui envisage de partir, Go et Python sont les destinations les plus citées.

Pratiques déclarées par les développeurs PHP Pratiques déclarées par les développeurs PHP Utilisent PHPUnit 50 % Aucune analyse statique 42 % Utilisent PHPStan 36 % Aucun test automatisé 32 % Utilisent Pest 17 % JetBrains, The State of PHP 2025, 1 720 répondants PHP, avril à juin 2025, biais possible vers les utilisateurs JetBrains

Lisez ce graphique attentivement : c’est le seul endroit de ce guide où la bonne nouvelle et la limite sont les mêmes données. La moitié des répondants disent utiliser PHPUnit, et 17 % Pest, les deux frameworks de test que je cite sans classer l’un au-dessus de l’autre. PHPStan est cité par 36 % des répondants, neuf points de plus que l’année précédente, une progression qui se suffit à elle-même. Mais 32 % ne déclarent aucun test automatisé, et 42 % aucune analyse statique. Un responsable du recrutement qui ne lirait que les chiffres d’adoption conclurait que PHP a une culture du test en train de mûrir. Celui qui ne lirait que les manques conclurait l’inverse. Les deux lectures sont vraies, pour des parties différentes, qui se recouvrent, de la même population déclarative, et une évaluation qui ne cite qu’un côté a choisi sa conclusion avant de regarder les données.

Si vous auditez une base de code précise plutôt que le langage en général, ce constat a un usage direct : savoir que « l’équipe écrit du PHP » ne vous dit presque rien, à lui seul, de la qualité de la maintenance. Lors d’un rachat ou de l’évaluation d’un prestataire, la question « puis-je voir la suite de tests et la configuration de l’analyse statique ? » vous apprendra davantage que n’importe quelle question sur le langage lui-même. Les outils pour y répondre existent et sont assez répandus pour qu’on s’attende à les trouver : PHP-CS-Fixer et PHP_CodeSniffer pour le style de code, PHPStan et Psalm pour l’analyse statique, Pest et PHPUnit pour les tests, cités ici dans l’ordre alphabétique, sans les mettre en concurrence, comme partout ailleurs dans ce guide. Une base de code où aucun n’est configuré ne prouve pas que PHP manque de maturité. Elle renseigne sur cette base de code-là, et la distinction mérite d’être défendue dans la salle où se prend la décision.

Les versions utilisées, selon les développeurs

La même enquête montre que 89 % des répondants cochent PHP 8.x parmi les versions sur lesquelles ils travaillent (plusieurs réponses étaient possibles), 33 % touchent encore à la 7.x et 8 % encore à PHP 5.6 ou plus ancien. C’est la déclaration d’un développeur sur ce qu’il manipule au quotidien, pas une mesure du parc de serveurs en service. Gouvernance et versions donne le chiffre côté serveurs, tiré d’une autre source, et il ne faut pas fondre les deux en un seul : ils ne répondent pas à la même question. L’un dit ce que le poste d’un développeur exige de lui, l’autre ce qui est réellement déployé et exposé sur Internet.

Les talents disponibles près de chez vous, honnêtement

Un audit sur un marché réglementé ou non anglophone pose souvent une question plus étroite que « combien de développeurs PHP existe-t-il dans le monde ? » : pouvez-vous recruter sur place, sans passer au tout-télétravail ni demander à quelqu’un de déménager ? Je n’ai pas de chiffre propre, ventilé par zone géographique et tiré d’une source primaire, pour y répondre avec précision, et je préfère le dire plutôt que d’en emprunter un à une page marketing. Ce que je peux dire, en m’appuyant sur la structure plutôt que sur des statistiques, c’est que PHP fait partie de l’enseignement courant du développement web depuis vingt ans dans la plupart des régions, à l’université, en bootcamp comme en formation professionnelle. C’est la même longévité d’adoption que celle établie dans La réputation et Qui fait tourner PHP. Il est donc raisonnable de s’attendre à trouver localement, sur la plupart des marchés, des profils PHP juniors à confirmés ; ce n’est pas une raison pour ne pas vérifier votre marché local avant d’y engager un plan de recrutement.

Un atelier à six établis, un éléphant à chacun : quatre établis sont rangés, avec une liste de contrôle épinglée au-dessus et un petit banc d'essai, deux sont encombrés et sans liste ; une personne avec un bloc-notes examine les établis plutôt que ceux qui y travaillent.

Le cœur du langage est maintenu de la même façon : par un ensemble réparti de contributeurs au projet php-src, encadré par le processus de gouvernance décrit dans Gouvernance et versions, et non par un éditeur unique qui maîtriserait seul sa feuille de route. Cette distinction touche un autre risque que celui du recrutement : aucun rachat, aucun plan de licenciement, aucun changement de stratégie d’une seule entreprise ne peut à lui seul mettre fin à la maintenance du langage, comme cela peut arriver à un projet qui appartient entièrement à un éditeur.

La vitesse d’intégration d’un nouvel arrivant fait aussi partie de la question de la maintenance. Je la traite à part des données d’enquête parce qu’elle tient à l’outillage, pas à une déclaration. La première tâche d’une nouvelle recrue sur une base de code PHP consiste en général à lancer Composer (Coût décrit ce qu’il gère) sur un fichier de verrouillage qui fige chaque dépendance à une version exacte et reproductible. C’est une propriété mécanique et vérifiable de la chaîne d’outils, pas un jugement sur la culture d’ingénierie d’une équipe donnée, et c’est la même garantie que npm offre à une équipe Node.js ou cargo à une équipe Rust : une nouvelle machine peut reproduire exactement le graphe de dépendances que le reste de l’équipe utilise déjà. C’est un facteur modeste, mais réel, de la vitesse à laquelle un nouveau mainteneur devient productif.

La limite. Je ne peux pas vous donner de comparaison précise et sourcée des salaires ou de la demande d’emploi entre PHP et d’autres langages. Les deux sources évidentes, les enquêtes de Stack Overflow et de JetBrains, présentent les ventilations utiles sous forme de graphiques interactifs, pas sous forme de texte récupérable avec la précision que je m’impose. Quant au chiffre ancien et souvent répété sur le nombre total de développeurs PHP dans le monde, il est assez périmé pour que je refuse de le reprendre plutôt que d’imprimer un nombre que je ne peux pas défendre. Quand la précision manque, je le dis, au lieu d’arrondir une supposition en statistique d’apparence officielle.

À vérifier vous-même. Lisez la dernière édition de l’enquête State of Developer Ecosystem de JetBrains et vérifiez que la réserve sur le biais de ses répondants y figure toujours, comme je l’ai rappelée ici. Une enquête qui abandonne sa propre réserve d’une année sur l’autre, c’est un signal à noter. Quant à github.com/php/php-src, il montre publiquement l’activité de ses contributeurs : regardez vous-même le rythme et la diversité des commits avant de vous faire une opinion, dans un sens ou dans l’autre, sur la santé de la maintenance du cœur du langage.

Les compétences disponibles disent qui peut construire et maintenir une application PHP. Reste à savoir ce que coûtent réellement ces compétences, cette infrastructure et cette culture du test, et c’est dans Coût que se trouvent les éléments pour en juger.

Coût

PHP est gratuit et publié sous une licence permissive, son écosystème de près d’un demi-million de paquets ne coûte rien à utiliser, et le coût réel d’une application PHP se loge presque entièrement dans l’hébergement, l’équipe et la discipline de maintenance, pas dans les licences. La question utile pour vous n’est donc pas « combien coûte PHP », mais « qu’est-ce que l’architecture de PHP vous évite de payer », et c’est là que ce chapitre passe le plus de temps.

La licence, précisément

PHP est distribué sous la PHP License, une licence permissive approuvée par l’OSI, qui ne vous oblige à publier aucune ligne de ce que vous construisez avec. PHP 8.4, la version plancher retenue dans ces pages, est publié sous la version 3.01 de cette licence. Une nouvelle licence, la version 4, reprend le texte BSD modifié (BSD-3-Clause) et s’applique à partir de PHP 8.6, qui n’était pas sorti au moment où j’écris ces lignes. Voyez-la comme un changement à suivre, pas comme le régime de la version que vous déploierez le plus probablement aujourd’hui. Aucune des deux licences n’exige de redevance, d’enregistrement ou de déclaration d’usage auprès de qui que ce soit.

Ce que « gratuit » recouvre vraiment

Packagist, le registre public dans lequel Composer, le gestionnaire de dépendances de PHP, va chercher les paquets, recense près d’un demi-million de paquets publiés, environ 5,8 millions de versions à eux tous, et un total d’installations qui approche les 200 milliards depuis l’ouverture du registre en avril 2012.

IndicateurOrdre de grandeur
Paquets publiés~468 000
Versions publiées~5,8 millions
Installations cumulées depuis avril 2012~200 milliards

Ces compteurs bougent en continu. Prenez les chiffres exacts comme un instantané, avec la même prudence que pour tous les autres chiffres mis à jour en permanence dans ce livre : c’est l’ordre de grandeur qui compte. La dépendance dont votre projet PHP a besoin a toutes les chances d’être déjà publiée, versionnée et installable en une commande, sans autre coût que le temps de vérifier ce que vous faites entrer dans votre code.

Publier sur Packagist est gratuit, et aucun contrôle n’a lieu au-delà de ce que Composer vérifie mécaniquement : chaque installation est comparée à une empreinte enregistrée dans le fichier de verrouillage du projet, si bien qu’une dépendance ne peut pas changer en silence entre la version que votre équipe a relue et celle qui s’installe réellement. La garantie est réelle et utile. Elle est aussi plus étroite qu’une traçabilité complète de la chaîne d’approvisionnement, car une empreinte confirme que le code n’a pas changé depuis son verrouillage, pas qu’il était sain le jour où il est entré dans le projet. Cette première relecture reste à la charge de l’équipe qui ajoute la dépendance, dans l’écosystème PHP comme dans celui de n’importe quel autre langage.

Ce que vous ne payez pas : une orchestration propriétaire

Un éléphant qui porte la même petite valise franchit tour à tour trois portes, un garage en briques, une petite chambre louée et une cour de conteneurs, sans jamais l'ouvrir ; une étiquette de prix vierge pend à la poignée.

Le modèle de processus de PHP-FPM, décrit dans Le runtime, ne demande qu’un système d’exploitation conforme POSIX, un serveur web et le runtime PHP pour servir des requêtes à grande échelle. Il n’exige aucune couche propriétaire d’orchestration serverless, et rien dans l’architecture ne vous pousse à en adopter une. C’est un fait d’architecture, réel et vérifiable, pas une affirmation sur tel ou tel hébergeur, et je le formule ainsi à dessein : la même application peut tourner sur une machine physique qui vous appartient, sur un serveur virtuel minimal ou dans un orchestrateur de conteneurs, sans être repensée pour aucun des trois.

Cette propriété prend un relief particulier pour les organisations soumises à des obligations de localisation des données ou à une exigence de cloud souverain, où le calcul doit rester sur une infrastructure conforme aux règles de résidence d’une juridiction plutôt que sur la plateforme la plus commode. Un runtime qui n’a besoin de l’orchestration managée d’aucun fournisseur pour fonctionner se déplace plus facilement vers une infrastructure conforme, parce que la contrainte porte sur l’endroit où se trouve la machine, pas sur le service propriétaire pour lequel l’application a été écrite.

La limite. Cette portabilité concerne le runtime PHP, pas l’ensemble de votre exploitation. Une équipe qui a aussi adopté une base de données managée propre à un cloud, une file de messages managée propre à un cloud ou un outillage d’observabilité construit autour de l’agent d’un seul fournisseur a déjà réintroduit la même dépendance à ces étages-là, quel que soit le langage placé devant. Formulez l’argument ainsi : « le runtime n’impose pas de dépendance à un cloud », et non « une application PHP est portable », car la seconde affirmation va plus loin que ce que les faits établissent.

Ce que PHP vous donne pour la sécurité, d’emblée

La réputation de PHP, traitée une fois pour toutes dans La réputation, comprend l’idée que le langage serait peu sûr par nature. Le langage actuel fournit des briques précises et vérifiables qui interdisent de tenir cette idée pour encore vraie par défaut. password_hash et password_verify offrent une API de hachage de mots de passe maintenue et indépendante de l’algorithme, si bien qu’une application n’a pas à bricoler la sienne. Les bindings Libsodium sont livrés avec PHP depuis la version 7.2 et donnent un accès direct à des primitives cryptographiques auditées, sans extension tierce. Les requêtes préparées de PDO séparent la structure d’une requête de ses données au niveau du pilote, ce qui constitue la défense standard et efficace contre l’injection SQL, à condition de s’en servir. Aucun de ces faits ne rend une application sûre à lui seul, et une équipe qui les ignore peut écrire une application vulnérable dans n’importe quel langage. Ils signifient en revanche que les bons outils sont déjà dans la bibliothèque standard, et non un achat supplémentaire ou une dépendance tierce qu’il faudrait d’abord trouver puis évaluer.

Ce que ce chapitre ne sait pas chiffrer

J’aimerais répondre à deux questions de coût par un chiffre, et je ne le peux pas. Je préfère le dire ici plutôt que de deviner. Une comparaison propre et sourcée du coût d’hébergement de PHP face à d’autres langages n’existe pas sans s’appuyer sur les chiffres marketing d’un hébergeur, que les règles de sourçage de ce livre excluent ; l’argument d’architecture ci-dessus tient lieu de chiffre précisément parce que ce chiffre n’existe pas sans ce compromis. Le manque de données sur les salaires et la demande d’emploi, déjà signalé dans Qui fait vivre PHP, vaut ici aussi : je ne peux pas vous dire, source défendable à l’appui, si un développeur PHP coûte plus ou moins cher à recruter qu’un développeur d’un autre langage sur votre marché, et un chiffre inventé pour combler ce vide vaudrait moins que pas de chiffre du tout.

À vérifier vous-même. Consultez directement packagist.org/statistics pour connaître le nombre actuel de paquets, de versions et d’installations, et comparez-le aux chiffres imprimés ici : l’écart montre en direct à quelle vitesse l’écosystème grandit encore. Lisez ensuite php.net/license en regard de la version de PHP que vous comptez réellement faire tourner, car la licence applicable dépend de cette version précise, pas de celle que ce livre considère comme actuelle.

Licences et hébergement sont les parts du coût total de possession que vous pouvez chiffrer directement. Les parts plus difficiles à chiffrer, la façon dont le langage est gouverné, le rythme de ses changements et ce qui arrive quand une version atteint sa date de fin de support, sont précisément le sujet de Gouvernance et versions.

Gouvernance et versions

Les évolutions du langage passent par un processus public de proposition et de vote qui exige une majorité des deux tiers pour toute modification du langage lui-même, les versions sortent selon un calendrier annuel fixe avec quatre ans de support, et la maintenance du cœur est financée par une fondation indépendante de la feuille de route produit de toute entreprise. Cette combinaison, un processus prévisible, un rythme prévisible et un financement qui ne dépend pas de l’intérêt durable d’un seul fournisseur, est au fond ce que vous voulez savoir quand vous demandez « qui décide, pour ce langage ».

Le rythme de publication, et ce à quoi il engage

PHP publie une nouvelle version par an, fin novembre. Chaque branche reçoit ensuite deux ans de support actif, c’est-à-dire des corrections de bugs comme de sécurité, puis deux ans de correctifs de sécurité seulement : quatre ans de support au total avant que la branche n’arrive en fin de vie.

VersionSortieFin du support actifFin du support de sécurité
PHP 8.28 déc. 202231 déc. 202431 déc. 2026
PHP 8.323 nov. 202331 déc. 202531 déc. 2027
PHP 8.421 nov. 202431 déc. 202631 déc. 2028
PHP 8.520 nov. 202531 déc. 202731 déc. 2029

Ce tableau est la pièce la plus utile de ce chapitre, parce qu’il transforme la question « PHP est-il bien maintenu ? » en une date vérifiable, propre à la version que vous faites réellement tourner. Une branche dont la fin du support de sécurité est passée ne reçoit plus de correctif pour les vulnérabilités nouvellement découvertes, de la part de personne, et c’est un fait sur votre déploiement, pas une opinion sur le langage.

Version majeure de PHP en service sur les sites web qui utilisent PHP Version majeure de PHP en service sur les sites web qui utilisent PHP PHP 8.x (64,1 %) PHP 7.x (28,1 %) PHP 5.x (7,8 %) PHP 4.x (0,1 %) W3Techs, w3techs.com/technologies/details/pl-php, vérifié le 17/09/2026

Ce que le processus RFC exige vraiment

Les modifications du langage sont proposées et votées publiquement, sur un wiki consacré à ce processus, et la règle de PHP exige une majorité des deux tiers pour qu’une modification du langage lui-même soit adoptée, une barre plus haute qu’une majorité simple. Ce seuil existe justement pour freiner les changements qui casseraient du code existant ou fragmenteraient la cohérence du langage, au prix d’une progression plus lente que sous un modèle de dictateur bienveillant. Aucun des deux côtés de cet arbitrage n’est gratuit, et je le présente dans les deux sens plutôt que de faire de cette barre haute un bien sans mélange : la majorité des deux tiers protège la stabilité, et elle signifie aussi qu’une proposition soutenue par une nette majorité, mais pas écrasante, peut quand même échouer.

Une salle des fêtes où un éléphant à un pupitre se tient près d'une urne et où la plupart des éléphants de l'assistance lèvent la main ; au mur, un calendrier annuel avec un mois entouré, au-dessus de quatre étagères de boîtes dont la plus basse est poussiéreuse.

Qui finance le travail

La PHP Foundation a été créée en novembre 2021, face à une inquiétude précise : la maintenance du cœur du langage dépendait du temps rémunéré qu’une poignée de contributeurs obtenaient de leurs employeurs, plutôt que d’une base de financement assez large pour survivre à la décision d’un employeur de réduire ce temps. La Fondation publie son financement sur un registre public, qui montre des contributions régulières d’un éventail d’entreprises technologiques et d’organisations open source ayant intérêt à ce que PHP reste maintenu. Le mécanisme compte davantage que le nom de tel ou tel contributeur. Un financement réparti entre plusieurs organisations indépendantes, visible sur un registre public plutôt qu’annoncé dans un communiqué de presse, est un arrangement différent, et plus durable, qu’une maintenance suspendue à la bonne volonté d’une seule entreprise.

Ce financement paie un travail précis et sans éclat : relire et intégrer les RFC, trier et traiter les signalements de sécurité visant le moteur du langage, et assurer l’ingénierie de publication qui fait que le rythme annuel du tableau ci-dessus tombe bien fin novembre au lieu de glisser. PHP dispose d’un processus spécifique pour les signalements de sécurité visant le cœur du langage, distinct du processus RFC utilisé pour les nouvelles fonctionnalités, précisément parce qu’une vulnérabilité demande un circuit plus rapide et mieux contrôlé qu’un débat public sur une fonctionnalité. Je n’ai pas de décompte daté et de première main du nombre de vulnérabilités du cœur traitées par ce processus sur une période récente, et je préfère laisser ce chiffre de côté plutôt que d’en emprunter un à un agrégateur tiers qui ne serait pas le compte rendu du processus lui-même.

Comparez avec l’autre modèle que vous avez sans doute en tête : un langage ou un framework dont la direction est fixée entièrement par une entreprise, où une modification sort parce que cette entreprise l’a décidé, pas parce qu’elle a survécu à un vote public. Ce modèle peut aller plus vite à court terme. Il rend aussi l’avenir du langage exactement aussi stable que l’intérêt de cette entreprise, un risque que le financement multi-sponsors de PHP et son processus RFC public sont tous deux conçus pour éviter, même au prix de la barre des deux tiers et de la lenteur qu’elle impose.

Là où le calendrier bien rangé rencontre une réalité plus désordonnée

Le tableau des versions décrit ce que PHP publie. Il ne dit rien de ce qui tourne vraiment. L’exploration par W3Techs des sites web en service qui utilisent PHP, au 17 septembre 2026, en trouvait 64,1 % sur la branche 8.x, 28,1 % encore sur la 7.x, dont la dernière branche est arrivée en fin de vie en novembre 2022, et 7,8 % encore sur PHP 5.x, hors support depuis 2018 ou 2019. Un reliquat de 0,1 % tournait encore, de façon détectable, sur PHP 4.

C’est une réserve sur la réalité du marché, pas une affirmation sur le langage actuel, et la distinction mérite d’être tenue fermement : le support de PHP 8.x, tel que le décrit le tableau, est exactement aussi prévisible que ce chapitre le dit. Ce qu’une part non négligeable du parc installé fait de cette prévisibilité est une autre question, qui relève de la discipline d’exploitation de certaines organisations, pas de la gouvernance. Ce chiffre va de pair avec la répartition déclarée des versions dans Qui fait vivre PHP, mais ne doit jamais s’y mélanger. L’un décrit des serveurs qui tournent réellement sur Internet, l’autre ce que les développeurs disent utiliser eux-mêmes, et un graphique qui mêlerait les deux comparerait des choses qui ne se comparent pas.

La limite. Un processus de gouvernance aussi prévisible ne vous protège que si votre propre organisation suit le rythme. Le tableau de support est une promesse sur ce que les mainteneurs soutenus par la PHP Foundation feront selon un calendrier fixe ; ce n’est pas une promesse que votre déploiement sera mis à jour avant la fin du support de sécurité de sa branche. Environ un tiers du web qui tourne sous PHP ne suit pas ce rythme aujourd’hui, et Là où PHP est le mauvais choix traite de front le risque d’hériter de l’un de ces déploiements.

À vérifier vous-même. Confrontez php.net/supported-versions.php à la version que vous faites tourner ou que vous évaluez, car les dates du tableau seront tôt ou tard remplacées par un nouveau cycle. Consultez ensuite w3techs.com/technologies/details/pl-php pour la répartition actuelle des versions, et comparez-la à celle imprimée ici pour voir de combien le parc installé a rattrapé son retard, s’il l’a rattrapé.

La gouvernance et le support des versions décrivent la maintenance de PHP quand tout se passe comme prévu. Là où PHP est le mauvais choix regarde le cas où c’est le langage lui-même, et non la négligence d’un déploiement, qui est le mauvais outil, et le dit aussi franchement que tout le reste.

Là où PHP est le mauvais choix

PHP est le mauvais choix pour le vrai calcul parallèle, pour l’apprentissage automatique et la science des données numérique, et pour une organisation qui ne peut pas s’engager à mettre à jour avant la fin du support de sécurité d’une branche ; c’est un choix plus faible, mais pas impossible, pour les applications natives de bureau ou mobiles et pour les charges de calcul lourd et soutenu. Ce chapitre existe pour que le reste puisse être cru. Il nomme chacun de ces cas franchement, preuves à l’appui, sans adoucir ceux qui compliquent une histoire simple.

Pas de vrai parallélisme, par construction

Le runtime a déjà nommé cette limite : PHP n’a pas de multithreading natif dans le code utilisateur. Les Fibers, arrivées avec PHP 8.1, apportent une concurrence coopérative, où une fiber se suspend pour en laisser tourner une autre. C’est très utile pour le travail limité par les entrées-sorties, mais ce n’est pas du parallélisme, puisqu’une seule fiber exécute son code à un instant donné. Les extensions PECL parallel et pthreads offrent un vrai parallélisme par threads du système d’exploitation ; elles existent bel et bien, et méritent d’être citées plutôt que passées sous silence. Elles sont aussi tierces et peu adoptées, ce qui justifie de les traiter comme une exception plutôt que comme la réponse par défaut. Si votre charge se définit par le besoin de faire tourner deux tâches de calcul au même instant précis dans un seul processus, rien dans l’outillage par défaut de PHP ne le fait, et aucune couche de service ni bibliothèque asynchrone n’y change rien, parce que la limite se trouve dans le runtime du langage lui-même, pas dans la façon dont vous le déployez.

Le même trou d’architecture apparaît dans la communication bidirectionnelle en temps réel. Une connexion WebSocket qui doit rester ouverte et pousser des données vers le client sans que le client les demande ne s’insère pas proprement dans le modèle de PHP-FPM, où une requête entre et une réponse sort. Elle devient praticable grâce aux mêmes bibliothèques asynchrones, Swoole ou OpenSwoole en particulier, déjà présentées dans Le runtime, ou grâce à une couche de service conçue pour les connexions longues. C’est une réponse réelle, qui fonctionne, pas une impasse. Mais c’est une brique d’infrastructure en plus, dont un langage né pour la requête-réponse comme PHP a besoin pour une tâche que d’autres runtimes traitent nativement.

La comparaison sur le calcul pur, bien posée

Performances a déjà montré la moitié contre-intuitive de cette limite : sur les microbenchmarks limités par le CPU, PHP est plus rapide que Python, pas plus lent. La version défendable de « PHP est lent » est plus étroite, et toujours vraie : PHP reste derrière les langages compilés et ceux dont le JIT est mûr, Go, Rust, Java et C#, sur le débit de calcul soutenu.

ComparaisonCe que montrent les données
PHP face à Python, tâches limitées par le CPUPHP plus rapide, d’environ 1,5 à 2 fois
PHP face aux langages compilés ou à JIT mûrPHP plus lent ; je n’ai pas de multiplicateur unique et propre à donner

Une charge vraiment limitée par le CPU (simulation numérique lourde, transformation de gros volumes de données en mémoire, tout ce dont le goulot d’étranglement est l’arithmétique plutôt que l’attente d’un réseau ou d’une base de données) est une charge pour laquelle PHP n’est pas, par son architecture, l’outil le plus rapide disponible. Cela ne veut pas dire que PHP ne sait pas le faire. Cela veut dire que la comparaison honnête se fait avec Go, Rust, Java et C#, pas avec Python, et qu’un fournisseur ou une équipe qui pose cette limite face à la mauvaise référence est mal informé, ou arrange la comparaison en faveur de PHP.

Applications natives, mobiles et de bureau : un manque moins net qu’on ne le croit, mais pas comblé

La réponse traditionnelle était simple : PHP n’a aucune boîte à outils officielle pour construire des applications natives de bureau ou mobiles, point. Cette réponse a un an ou deux de retard. NativePHP, un projet communautaire construit spécifiquement sur Laravel, l’un des frameworks de la liste fixe de ce livre, empaquette une application PHP en version de bureau et en version pour les magasins d’applications mobiles, et sa propre documentation revendique des déploiements en production en 2026. Le citer une fois, ici, avec cette date, est plus honnête que de prétendre que le manque reste absolu. Le citer à répétition, ou le traiter comme aussi mûr que Swift, Kotlin ou une boîte à outils multiplateforme établie, surestimerait ce qu’un seul projet communautaire, jeune et lié à un framework, a réellement prouvé à grande échelle. La formulation honnête tient en trois constats : aucune boîte à outils officielle n’existe, une solution communautaire existe, et elle n’a pas encore la maturité qu’un décideur attendrait avant d’y miser un produit phare.

Au comptoir d'une location d'outils, un éléphant tend un marteau tandis que le commerçant secoue la tête et désigne une perceuse à colonne sur l'étagère ; sur le comptoir, le croquis d'une pile de plaques de métal à percer.

Apprentissage automatique et science des données numérique

Ce manque est réel, et je préfère l’argument de la densité de l’écosystème à une statistique d’usage empruntée qui ne parlerait pas vraiment de PHP. Il n’existe pas d’équivalent PHP à NumPy, pandas, PyTorch ou TensorFlow qui leur soit comparable en maturité, en taille de communauté ou en prise en charge de l’accélération matérielle. Vous pouvez le vérifier vous-même : cherchez dans les catégories de Packagist, ou dans l’index des extensions de PHP, des outils de calcul numérique ou d’apprentissage automatique, et comparez avec la même recherche dans l’index des paquets de Python. Ce manque n’est pas une affaire d’opinion, et il n’a pas besoin d’une statistique d’enquête empruntée pour être démontré : il se voit directement dans ce que chaque écosystème a construit.

Les processus longs : une réponse partielle, décrite au plus juste

Le runtime et Montée en charge en parlent déjà. La documentation de FrankenPHP dit sans détour que PHP n’a pas été conçu à l’origine pour des processus de longue durée, et le mode worker atténue le risque de croissance mémoire qui en découle sans le supprimer. C’est pourquoi le redémarrage périodique des workers est la parade standard et documentée, et non un aveu d’échec. Le constat est juste et sans esprit de défense, et il vient de la franchise de l’éditeur lui-même plutôt que de la plume d’un critique.

Pas de génériques

Le langage PHP n’a pas de génériques. PHPStan et Psalm, les deux outils d’analyse statique cités tout au long de ce livre, lisent la même convention de docblock @template pour approcher les types génériques. Vous obtenez ainsi une vérification de types réelle et utile pendant le développement, mais entièrement hors du moteur du langage : rien d’un type générique déclaré de cette façon n’est vérifié quand le code s’exécute. Une base de code qui s’appuie sur cette convention choisit un substitut réel et fonctionnel, pas la fonctionnalité du langage elle-même, et la distinction compte si vos critères d’évaluation exigent explicitement des génériques vérifiés à la compilation plutôt qu’une approximation facultative par l’analyse statique.

Une réserve sur le marché, pas sur le langage

Gouvernance et versions vous a déjà donné le chiffre : environ 28 % des sites web sous PHP tournent encore sur la branche 7.x, sans support depuis novembre 2022, et près de 8 % sont encore sur PHP 5, sans support depuis 2018 ou 2019. Hériter de l’un de ces déploiements, par un rachat, un vieil outil interne ou la relation avec un fournisseur, c’est hériter d’un vrai passif de sécurité et de maintenance. Ce n’est pas une affirmation sur le langage actuel, maintenu activement selon le calendrier décrit dans Gouvernance et versions ; c’est une affirmation sur ce qu’une organisation donnée a fait, ou n’a pas fait, d’une vieille version. Si vous menez une due diligence sur une base de code existante, traitez ces deux risques comme deux évaluations entièrement séparées.

La limite, dite une dernière fois, sans détour. Aucun des manques de ce chapitre ne se résout en choisissant un autre framework PHP, et je ne laisserai pas entendre le contraire. Quand ils se résolvent, c’est en ajoutant à côté de PHP un second outil conçu pour la tâche, pas avec PHP seul.

À vérifier vous-même. Lisez la documentation de PHP sur les Fibers et jugez par vous-même si la concurrence coopérative couvre vraiment votre charge, plutôt que de prendre le résumé de ce chapitre pour le dernier mot. Faites ensuite tourner la tâche numérique ou gourmande en données la plus proche de votre charge réelle, une fois en PHP, une fois dans le langage que vous utiliseriez sinon. C’est la même exigence de refaire la mesure vous-même que Performances vous a déjà posée, et un vrai benchmark de votre propre tâche vaut mieux que toute comparaison générale imprimée ici.

Toutes les limites de ce chapitre ont la même forme : PHP plus une brique d’infrastructure conçue pour la tâche, pas un remplacement complet. L’évaluation referme le livre en transformant cette forme, et chaque chiffre sourcé qui précède, en vérifications que vous pouvez faire vous-même, sur votre propre machine, avant de décider quoi que ce soit.

L’évaluation

Chaque chiffre de ce livre était vérifiable le jour où je l’ai écrit, et chacun aura bougé le jour où vous le lirez ; ce chapitre vous donne donc les vérifications elles-mêmes, pas un chiffre de plus à croire sur parole. Une revue de due diligence ne s’achève pas sur la lecture des conclusions d’un autre. Elle s’achève quand vous refaites vous-même les mesures dont dépend votre décision, et ce chapitre ne contient rien d’autre que les moments où les neuf chapitres précédents vous demandaient déjà de le faire.

À une table de cuisine, une personne tape sur un ordinateur portable pendant qu'un éléphant à côté d'elle tient une liste imprimée et coche la troisième case, en comparant la feuille avec l'écran.

Ce que votre propre machine sait déjà

Avant de vérifier quoi que ce soit sur l’écosystème, regardez l’installation de PHP sur laquelle vous déploieriez vraiment. Le script ci-dessous, volontairement court, rapporte les faits que Le runtime a passé un chapitre à expliquer : la version qui tourne, si opcache est réellement chargé et pas seulement disponible en théorie, et si le JIT est activé.

<?php

declare(strict_types=1);

function reportRuntimeStatus(): array
{
    return [
        'php_version' => PHP_VERSION,
        'sapi' => PHP_SAPI,
        'opcache_loaded' => extension_loaded('Zend OPcache'),
        'jit_enabled' => function_exists('opcache_get_status')
            && (opcache_get_status(false)['jit']['on'] ?? false),
    ];
}

foreach (reportRuntimeStatus() as $fact => $value) {
    printf("%-15s %s\n", $fact, var_export($value, true));
}

Lancez-le avec php status.php sur chaque environnement que vous évaluez, y compris celui qu’un fournisseur vous livre avec ses garanties. Quand un fournisseur affirme qu’« opcache et le JIT sont activés », c’est une phrase. La sortie de ce script est un fait établi sur cette machine précise, et les deux ne pèsent pas le même poids comme preuve.

Toutes les vérifications du livre, au même endroit

Chaque chapitre se terminait sur une chose à vérifier en un après-midi. En les refaisant ensemble, dans l’ordre, vous reconstruisez toute la base de preuves du livre à partir des sources vivantes, et non de la photographie qu’en a imprimée cette édition.

# Chapter 1 and 8: current adoption and version fragmentation
# https://w3techs.com/technologies/details/pl-php

# Chapter 2: your own install's runtime state
php -v
php -i | grep -i opcache

# Chapter 3: professional developer adoption by language
# https://survey.stackoverflow.co (current year's technology results)

# Chapter 4: CPU-bound benchmarks, still actively maintained
# https://benchmarksgame-team.pages.debian.net/benchmarksgame/

# Chapter 6: the PHP core's own contributor activity
# https://github.com/php/php-src

# Chapter 7: live package, version, and install counts
# https://packagist.org/statistics

# Chapter 8: the current support window for your PHP version
# https://php.net/supported-versions.php

Aucune de ces vérifications ne demande d’accès particulier, de compte payant ou de contact bien placé. C’est voulu. Vous demander de croire un chiffre que vous ne pourriez pas atteindre seul, ce serait vous demander la même confiance que la réputation décrite dans La réputation : croire des impressions de seconde main sur PHP plutôt que regarder le langage tel qu’il est aujourd’hui. J’ai passé neuf chapitres à combattre cette habitude.

Lire les affirmations d’un fournisseur comme j’ai lu les miennes

La méthode compte plus que la liste, parce que la liste vieillira et que la méthode ne devrait pas. Quand un fournisseur, la documentation d’un framework ou un collègue vous tend un chiffre de performance, une promesse de sécurité ou une statistique d’adoption, posez-lui les trois questions que je me suis posées avant d’imprimer quoi que ce soit. D’où vient le chiffre, dans les mots mêmes de la source et non dans un résumé ? Qu’a-t-on mesuré exactement, et cela correspond-il à ce qui vous importe ? Performances a dû séparer un micro-benchmark du JIT d’un benchmark de requêtes web avant que l’un ou l’autre veuille dire quelque chose. Enfin, que dit la source elle-même de ce qu’elle ignore ? Une source qui énonce ses propres limites mérite plus de confiance qu’une source qui n’en a aucune.

Un exemple concret, avec mes citations les plus fragiles

Le meilleur test de cette méthode consiste à la retourner contre ce livre. Qui fait vivre PHP cite une enquête de JetBrains qui annonce elle-même sa faiblesse : ses résultats penchent sans doute vers les utilisateurs des produits JetBrains. Cette source passe le test. Elle n’est pas impartiale, aucune enquête auprès de répondants volontaires ne l’est, mais elle vous dit de quel côté elle penche avant que vous ayez à le deviner. Performances fait un autre travail honnête : il nomme une série de benchmarks, TechEmpower, qui a cessé de paraître, avec la date exacte, au lieu de citer sa dernière édition comme si rien n’avait changé. Gouvernance et versions, lui, écarte de ses affirmations fermes quelques chiffres, dont les montants exacts du financement de la PHP Foundation, parce qu’au moment de l’écriture je ne les avais confirmés que par un récit de seconde main et non sur la page de la Foundation. Sources marque chacun d’eux comme en attente de vérification directe, plutôt que d’imprimer un chiffre que je ne peux pas défendre. Une source qui vous dit ce qu’elle ignore, dans ses propres mots, fait le travail que j’ai essayé de faire tout au long de ces pages, et c’est le signal le plus net à chercher dans tout ce qu’on vous remettra pendant votre propre évaluation.

La limite. Une liste de vérifications ne vaut que pour le jour où on l’a passée. Chaque commande et chaque URL ci-dessus renverra un autre chiffre au trimestre prochain, de la même façon que chaque chiffre imprimé plus haut aura bougé quand vous le lirez. Ce chapitre ne peut pas vous donner une réponse à jour pour toujours. Il vous donne une façon reproductible d’en obtenir une, et c’est ce qui durera le plus longtemps.

À vérifier vous-même, une dernière fois. Choisissez le chiffre du livre dont votre décision dépend le plus, quel que soit le chapitre d’où il vient, et retournez à sa source avant d’agir. S’il dit toujours ce que j’ai écrit qu’il disait, vous tenez une confirmation indépendante. Sinon, vous avez pris ce livre en flagrant délit de péremption avant qu’il vous coûte quoi que ce soit, et c’est exactement pour cela que toute la démarche a été construite.

J’ai ouvert ce livre en séparant la réputation de PHP du langage que vous avez aujourd’hui sous les yeux. Je le referme en vous rendant cette séparation sous forme de méthode, pas de conclusion. Le modèle d’exécution, les chiffres d’adoption, les comparaisons de performances, la structure des coûts, le processus de gouvernance et les limites dites sans détour ne valent que ce que vaut votre volonté de les vérifier à nouveau. Sources donne l’origine exacte de chaque chiffre, chapitre par chapitre, pour que la vérification ne soit jamais à plus d’un lien.

Annexe A : Sources

Chaque chiffre et chaque affirmation sourcée de ce livre figure ci-dessous, rangé sous le chapitre où il apparaît, avec son éditeur, son URL et la date à laquelle la donnée se rapporte ou a été vérifiée. Quand un chiffre vient d’une page recalculée en continu (W3Techs, Packagist), la date est celle de la consultation et non celle d’une publication, et le chapitre le précise à l’endroit où il cite le chiffre.

Quelques entrées portent la mention en attente de vérification directe. Au moment de l’écriture, chacune n’avait été confirmée que par un extrait de moteur de recherche ou par un récit de seconde main, sans lecture directe de la page d’origine, et chacune est rédigée dans son chapitre de façon assez étroite pour ne pas dépendre d’un chiffre précis encore non confirmé. Je les laisse ici plutôt que de les supprimer en silence, pour que la personne qui achèvera la production du livre sache exactement ce qui reste à vérifier avant publication.

Chapitre 1 : La réputation

  • Part de PHP parmi les sites dont le langage côté serveur est connu : 69,9 %, vérifié le 17 septembre 2026 ; 71,8 % en mars 2026 ; 70,2 % le 3 septembre 2026. W3Techs, w3techs.com/technologies/details/pl-php.

Chapitre 2 : Le runtime

  • Modèle d’exécution de PHP (Zend Engine, une requête par processus ou par thread, shared-nothing par défaut). Le manuel PHP, version courante, vérifié le 17 septembre 2026.
  • Opcache livré avec PHP depuis la version 5.5 ; chargé comme zend_extension dans php.ini, inactif par défaut avec le seul cœur. php.net/manual/en/opcache.installation.php, vérifié le 17 septembre 2026.
  • Benchmark WordPress de la RFC du JIT elle-même : 326 requêtes par seconde avec le JIT, contre 315 sans. RFC JIT de PHP, wiki.php.net/rfc/jit, vérifié le 17 septembre 2026.
  • declare(strict_types=1) et comportement du contrôle des types scalaires et des types de retour. Le manuel PHP, version courante, vérifié le 17 septembre 2026.
  • Mode worker de FrankenPHP : superglobales réinitialisées automatiquement entre deux requêtes, sauf $_ENV ; la documentation du projet indique elle-même « PHP was not originally designed for long-running processes » et recommande de redémarrer périodiquement les workers. frankenphp.dev/docs/worker/, vérifié le 17 septembre 2026.
  • RoadRunner, serveur d’applications écrit en Go qui gère un pool de workers PHP de longue durée. En attente de vérification directe de docs.roadrunner.dev ; la description actuelle vient d’un comparatif tiers, pas de la documentation du projet.
  • AMPHP, famille de bibliothèques fondées sur une boucle d’événements pour la concurrence limitée par les entrées-sorties, décrite en termes généraux et non citée. En attente de vérification directe du README de github.com/amphp/amp ; pas revérifié de façon indépendante lors de cette passe.
  • ReactPHP, qui se décrit comme une bibliothèque bas niveau fondée sur une boucle d’événements, pour la programmation événementielle. README de github.com/reactphp/reactphp, vérifié le 17 septembre 2026.
  • Swoole, qui se décrit comme un moteur de concurrence événementiel à base de coroutines, écrit en C pour PHP. README de github.com/swoole/swoole-src, vérifié le 17 septembre 2026.
  • Fibers (PHP 8.1) : coroutines coopératives à pile unique via Fiber::suspend() et Fiber::resume(), de la concurrence sans parallélisme au niveau du système d’exploitation. php.net/manual/en/language.fibers.php, vérifié le 17 septembre 2026.
  • parallel et pthreads, extensions PECL tierces qui offrent un vrai parallélisme par threads du système. PECL et le manuel PHP, référence générale, vérifiés le 17 septembre 2026.

Chapitre 3 : Qui fait tourner PHP

  • Chiffre d’adoption de W3Techs : voir l’entrée du chapitre 1 ci-dessus.
  • Stack Overflow Developer Survey 2025 : PHP 19,1 %, JavaScript 68,8 %, Python 54,8 %, TypeScript 48,8 %, C# 29,9 %, Java 29,6 %, Go 17,4 %, Ruby 6,9 %, sur 24 759 répondants développeurs professionnels. survey.stackoverflow.co/2025/technology, vérifié le 17 septembre 2026.
  • MediaWiki, écrit à environ 70 % en PHP, soit près de deux millions de lignes de PHP maintenues par Wikimedia, réparti sur sept centres de données (trois aux États-Unis, deux en Europe, un en Asie, un en Amérique du Sud) derrière Varnish, Apache Traffic Server et Apache HTTP Server, avec APCu et Memcached comme caches. Wikimedia, wikitech.wikimedia.org/wiki/MediaWiki_at_WMF et wikitech.wikimedia.org/wiki/Wikimedia_infrastructure, pages tenues à jour en continu, consultées le 17 septembre 2026.
  • Meta et Slack font tourner Hack sur HHVM, pas PHP. En attente de vérification directe auprès des publications techniques actuelles de chacune des deux entreprises ; tenu pour un fait établi pour appliquer la règle d’exclusion du livre.

Chapitre 4 : Performances

Chapitre 5 : Montée en charge

  • Modèle de processus de PHP-FPM, à base de workers et shared-nothing. php.net/manual/en/install.fpm.php, vérifié le 17 septembre 2026.
  • Répartition des centres de données de Wikimedia : voir l’entrée du chapitre 3 ci-dessus.

Chapitre 6 : Qui fait vivre PHP

  • JetBrains, « The State of PHP 2025 » : 1 720 répondants spécifiquement PHP sur 24 534 développeurs interrogés au total, enquête menée d’avril à juin 2025, avec la réserve de l’enquête elle-même : les résultats peuvent pencher vers les utilisateurs des produits JetBrains. Chiffres utilisés : 88 % ont au moins trois ans d’expérience en PHP ; 58 % ne prévoient pas de migrer vers un autre langage dans l’année (Go et Python sont les plus cités par ceux qui le feraient) ; versions déclarées : 89 % PHP 8.x, 33 % 7.x, 8 % 5.6 ou antérieure ; PHPStan utilisé par 36 %, soit 9 points de plus en un an ; PHPUnit 50 % ; Pest 17 % ; 32 % déclarent ne pas avoir de tests automatisés ; 42 % déclarent ne pas faire d’analyse statique. blog.jetbrains.com/phpstorm/2025/10/state-of-php-2025/, vérifié le 17 septembre 2026.
  • Résolution des dépendances de Composer par fichier de verrouillage, comme garantie de reproductibilité. Documentation de getcomposer.org, référence générale, vérifiée le 17 septembre 2026.

Chapitre 7 : Coût

  • La licence PHP version 3.01 s’applique à PHP 8.4 et 8.5 ; la licence version 4 (BSD modifiée, BSD-3-Clause) s’applique à partir de PHP 8.6. php.net/license/index.php, vérifié le 17 septembre 2026.
  • Statistiques de Packagist : environ 468 201 paquets publiés, 5 822 307 versions publiées et environ 199,8 milliards d’installations cumulées depuis le 13 avril 2012. packagist.org/statistics, vérifié le 17 septembre 2026, compteur en direct.
  • Contrôle des installations de Composer par empreinte, à partir du fichier de verrouillage du projet. Documentation de getcomposer.org, référence générale, vérifiée le 17 septembre 2026.
  • Exigences d’hébergement minimales de PHP-FPM : voir l’entrée du chapitre 5 ci-dessus.
  • password_hash et password_verify, l’API standard de hachage des mots de passe. php.net/manual/en/function.password-hash.php, version courante, vérifié le 17 septembre 2026.
  • Liaisons Libsodium livrées avec PHP depuis la version 7.2. php.net/manual/en/book.sodium.php, version courante, vérifié le 17 septembre 2026.
  • Requêtes préparées de PDO, qui séparent la structure de la requête des données. php.net/manual/en/pdo.prepared-statements.php, version courante, vérifié le 17 septembre 2026.

Chapitre 8 : Gouvernance et versions

  • Rythme de publication et durées de support : une version porteuse de nouvelles fonctionnalités par an, fin novembre ; deux ans de support actif, puis deux ans de correctifs de sécurité seulement. PHP 8.2 sorti le 8 décembre 2022 (support actif terminé le 31 décembre 2024, support de sécurité jusqu’au 31 décembre 2026) ; PHP 8.3 sorti le 23 novembre 2023 (actif jusqu’au 31 décembre 2025, sécurité jusqu’au 31 décembre 2027) ; PHP 8.4 sorti le 21 novembre 2024 (actif jusqu’au 31 décembre 2026, sécurité jusqu’au 31 décembre 2028) ; PHP 8.5 sorti le 20 novembre 2025 (actif jusqu’au 31 décembre 2027, sécurité jusqu’au 31 décembre 2029). php.net/supported-versions.php, vérifié le 17 septembre 2026.
  • Processus RFC : proposition et vote sur le wiki public, majorité des deux tiers requise pour un changement du langage. En attente de vérification directe de wiki.php.net/rfc/change_required_votes_to_two_thirds pour la formulation exacte et la date d’adoption.
  • Création de la PHP Foundation en novembre 2021. En attente de vérification directe du récit fondateur publié par la Foundation sur thephp.foundation ; le récit utilisé ici vient du billet de blog d’un sponsor, pas de la page d’histoire de la Foundation.
  • Un registre public des financements, qui enregistre les contributions régulières de plusieurs organisations indépendantes. En attente de vérification directe des totaux cumulés actuels sur opencollective.com/phpfoundation ; le livre mentionne l’existence et la transparence du registre sans imprimer de montants qui n’ont pas été confirmés directement.
  • Un processus propre au traitement des signalements de sécurité sur le cœur du langage, distinct du processus RFC des fonctionnalités. En attente de vérification directe de php.net/security.
  • Fragmentation des versions selon W3Techs : PHP 8.x 64,1 %, 7.x 28,1 %, 5.x 7,8 %, 4.x 0,1 % des sites sous PHP. w3techs.com/technologies/details/pl-php, vérifié le 17 septembre 2026.

Chapitre 9 : Là où PHP est le mauvais choix

  • Fibers, parallel et pthreads : voir les entrées du chapitre 2 ci-dessus.
  • Comparaison PHP contre Python sur des calculs limités par le CPU : voir l’entrée du chapitre 4 ci-dessus.
  • NativePHP, projet communautaire construit sur Laravel, qui empaquette des applications PHP pour les boutiques d’applications de bureau et mobiles ; sa documentation revendique des déploiements en production en 2026. nativephp.com/docs/, vérifié le 17 septembre 2026.
  • Absence d’équivalent PHP à NumPy, pandas, PyTorch ou TensorFlow : un constat sur la densité de l’écosystème, que l’on vérifie directement avec la recherche par catégorie de Packagist et l’index des extensions de PHP plutôt qu’avec une citation datée unique.
  • Position de FrankenPHP lui-même sur les processus de longue durée : voir l’entrée du chapitre 2 ci-dessus.
  • PHPStan et Psalm simulent tous deux les génériques par une convention commune de docblock @template, que seule l’analyse statique fait respecter, pas le moteur du langage. En attente de vérification directe de phpstan.org/writing-php-code/generics et de psalm.dev/docs/annotating_code/templated_annotations/ ; la source actuelle est de seconde main.
  • Fragmentation des versions selon W3Techs : voir l’entrée du chapitre 8 ci-dessus.

Chapitre 10 : L’évaluation

Aucun chiffre nouveau. Ce chapitre refait les mesures à partir des sources vivantes déjà listées ci-dessus : w3techs.com/technologies/details/pl-php, survey.stackoverflow.co, benchmarksgame-team.pages.debian.net/benchmarksgame, github.com/php/php-src, packagist.org/statistics et php.net/supported-versions.php. Le script de contrôle du runtime utilise PHP_VERSION, PHP_SAPI et opcache_get_status(), tous documentés dans le manuel PHP, version courante, vérifié le 17 septembre 2026.

Annexe B : Calendrier des versions

PHP publie une version porteuse de nouvelles fonctionnalités par an, fin novembre. Chaque branche reçoit ensuite deux ans de support actif, corrections de bugs et de sécurité comprises, puis deux ans de correctifs de sécurité seulement : quatre ans de support au total, de la sortie à la fin de vie. Le tableau ci-dessous est celui de Gouvernance et versions, reproduit seul pour s’y reporter vite.

VersionSortieFin du support actifFin du support de sécurité
PHP 8.28 décembre 202231 décembre 202431 décembre 2026
PHP 8.323 novembre 202331 décembre 202531 décembre 2027
PHP 8.421 novembre 202431 décembre 202631 décembre 2028
PHP 8.520 novembre 202531 décembre 202731 décembre 2029

Source : php.net/supported-versions.php, vérifié le 17 septembre 2026. La page change à chaque nouvelle version et à chaque branche retirée ; prenez ce tableau pour ce qu’il est, une photographie prise ce jour-là, et consultez la page en ligne avant toute décision qui dépend d’une date précise.

Ce que veulent dire « actif » et « sécurité seulement »

Pendant le support actif, une branche reçoit à la fois les corrections de bugs et les correctifs de sécurité, et c’est la version que le projet PHP recommande lui-même. À la fin du support actif, elle passe aux correctifs de sécurité seulement : une vulnérabilité découverte sera encore corrigée, un bug ordinaire ne le sera plus. À la fin du support de sécurité, la branche ne reçoit plus rien du projet, quoi qu’on y trouve ensuite. Un déploiement en production qui tourne encore sur une branche arrivée en fin de vie n’a pas seulement des fonctionnalités en retard ; il n’a plus aucun chemin vers un correctif pour la prochaine faille qu’on y découvrira.

Ce tableau face à ce qui tourne réellement

Gouvernance et versions et Là où PHP est le mauvais choix s’appuient tous deux sur un autre chiffre pour donner le contexte. Le 17 septembre 2026, W3Techs comptait 64,1 % des sites sous PHP sur la ligne 8.x que couvre ce tableau, 28,1 % encore sur la ligne 7.x, dont la dernière branche a quitté le support de sécurité en novembre 2022, et 7,8 % encore sur PHP 5.x, sans support depuis 2018 ou 2019. Le tableau décrit ce que le projet PHP s’engage à publier et à maintenir. Il ne dit rien de ce que votre organisation, ou celle d’un fournisseur, fait réellement tourner : seul un contrôle direct du déploiement concerné peut l’établir.

En septembre 2026

PHP 8.6 n’était pas sorti au moment où j’écris. Je ne lui prête pas de date de sortie, par la même discipline que pour tous les autres chiffres : un calendrier annoncé est décrit comme annoncé, et ne devient un fait qu’une fois la version publiée. Le seul détail confirmé qui s’y rattache est traité dans Coût : la licence PHP version 4 s’applique à partir de PHP 8.6 et remplace la licence 3.01, qui régit les versions que ce tableau donne aujourd’hui comme supportées.

Annexe C : Vocabulaire

Les termes sont définis au sens où je les emploie, en langage courant, avec un renvoi au chapitre qui les explique en situation.

Analyse statique. Rechercher les erreurs d’un code, dont les incohérences de types, sans l’exécuter. PHPStan et Psalm sont les deux outils d’analyse statique cités dans ce livre ; tous deux simulent aussi les types génériques grâce à une convention commune de docblocks que le moteur du langage, lui, ne fait pas respecter. Voir Qui fait vivre PHP et Là où PHP est le mauvais choix.

Composer. Le gestionnaire de dépendances de PHP. Il résout les paquets demandés par un projet à partir de Packagist, note dans un fichier de verrouillage les versions exactes installées, et contrôle chaque installation par une empreinte, si bien qu’une dépendance ne peut pas changer en silence sous un projet après sa revue. Voir Coût.

Coroutine. Une unité d’exécution qui peut se mettre en pause et rendre la main, puis reprendre plus tard au même endroit, sans que le système d’exploitation la détruise et la reconstruise. Les Fibers de PHP et des bibliothèques comme ReactPHP et Swoole reposent sur cette idée. Voir Le runtime.

Fibers. Une fonctionnalité du langage arrivée avec PHP 8.1, qui apporte la concurrence coopérative : une fiber se suspend avec Fiber::suspend() et reprend avec Fiber::resume(). Le code d’une seule fiber s’exécute à un instant donné ; c’est de la concurrence, pas du parallélisme. Voir Le runtime.

FPM (FastCGI Process Manager). Le gestionnaire de processus standard de PHP : un pool de processus, chacun traitant une requête à la fois, chacun ne partageant rien avec les autres. C’est la façon classique, et la plus répandue, de servir une application PHP. Voir Le runtime et Montée en charge.

JIT (compilation à la volée). Arrivé avec PHP 8.0. Il traduit en code machine, pendant l’exécution, les portions de code les plus sollicitées. Le gain est net sur les calculs numériques limités par le CPU ; sur une requête web ordinaire, qui passe l’essentiel de son temps à attendre des entrées-sorties, il reste faible. Voir Le runtime et Performances.

Mode worker. Une façon de servir l’application, proposée par FrankenPHP et RoadRunner, qui garde l’application PHP démarrée en mémoire d’une requête à l’autre au lieu de la détruire après chacune. Les superglobales sont réinitialisées automatiquement entre deux requêtes ; tout ce que votre code conserve délibérément ne l’est pas, et c’est pourquoi le redémarrage périodique des workers est la parade standard, documentée, contre la mémoire qui grossit au fil d’un long processus. Voir Le runtime.

Opcache. Une zend_extension livrée avec PHP depuis la version 5.5, qui garde en mémoire partagée le bytecode compilé pour ne pas le recompiler à chaque requête. Elle doit être chargée explicitement dans php.ini ; le cœur de PHP ne l’active pas tout seul. Voir Le runtime.

Packagist. Le registre public de paquets dans lequel Composer résout les dépendances. Publier y est gratuit, s’en servir aussi. Voir Coût.

PSR (PHP Standards Recommendation). Une convention commune, que les auteurs de frameworks et de bibliothèques adoptent volontairement au terme d’un processus de normalisation, et que le langage n’impose pas. Les PSR couvrent par exemple le chargement automatique des classes, les interfaces de journalisation ou la forme des messages HTTP, pour que des bibliothèques écrites séparément fonctionnent ensemble à coup sûr. Voir La réputation.

RFC (Request for Comments). Le processus public par lequel on propose puis vote une modification du langage lui-même, sur un wiki prévu à cet effet. Un changement du langage doit réunir une majorité des deux tiers. Voir Gouvernance et versions.

SAPI (Server API). L’interface entre le moteur PHP et ce qui le fait tourner : FPM, la ligne de commande ou un autre module de serveur. PHP_SAPI indique sous laquelle tourne un processus donné. Voir L’évaluation.

Shared-nothing. Le modèle d’exécution par défaut de PHP, où rien n’est partagé d’une requête à l’autre : chaque requête démarre l’application, s’exécute, envoie sa réponse puis disparaît, sans transmettre ni mémoire ni état à la suivante. C’est ce qui rend la montée en charge horizontale si simple, et c’est pour cela que tout ce qui doit durer vit hors du processus PHP. Voir Le runtime et Montée en charge.