MFormations
Modern PHP Engineering

Chapitre 24

24 — Tendances PHP 2024-2026

24 — Tendances PHP 2024-2026

Tendances PHP 2026+

Introduction

PHP n'a jamais été aussi moderne. Après des années perçues comme un langage "legacy", PHP a opéré une transformation radicale depuis PHP 7.0 (2015). Avec PHP 8.x, le langage rivalise avec les meilleurs en termes de fonctionnalités, performance et sécurité.

Ce chapitre explore les tendances qui façonnent l'avenir de PHP et comment se positionner pour les 5 prochaines années.

1. PHP 8.4 : Property Hooks et Asymmetric Visibility

PHP 8.4 introduit deux fonctionnalités majeures.

Property Hooks

class User
{
    public string $name {
        set => ucfirst(strtolower($value));
        get => $this->name ?? 'Anonymous';
    }

    public string $email {
        set (string $value) {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new InvalidArgumentException('Email invalide');
            }
            $this->email = $value;
        }
    }
}

Asymmetric Visibility

class Invoice
{
    public private(set) string $id;   // Lecture publique, écriture privée
    protected public(set) float $total; // Lecture protégée, écriture publique
    
    public function __construct()
    {
        $this->id = uuid_create();
    }
}

Impact : Élimine le besoin de getters/setters manuels. Réduit le boilerplate de ~60% pour les DTO et Value Objects.

2. FrankenPHP : Le Serveur PHP Moderne

FrankenPHP est un serveur d'application PHP écrit en Go, créé par Kévin Dunglas (créateur d'API Platform).

Architecture :

┌─────────────────────────────┐
│         FrankenPHP           │
│  ┌───────────────────────┐   │
│  │     Go Server          │   │
│  │  (net/http, Caddy)     │   │
│  ├───────────────────────┤   │
│  │    PHP Worker Pool     │   │
│  │  ┌───┐ ┌───┐ ┌───┐    │   │
│  │  │P1 │ │P2 │ │P3 │    │   │
│  │  └───┘ └───┘ └───┘    │   │
│  ├───────────────────────┤   │
│  │  Built-in Features     │   │
│  │  - HTTP/2, HTTP/3      │   │
│  │  - Mercure (SSE)       │   │
│  │  - TLS auto (Caddy)    │   │
│  │  - Compression         │   │
│  └───────────────────────┘   │
└─────────────────────────────┘

Avantages :

  • Démarrage instantané (pas de FPM)
  • Auto TLS via Caddy (Let's Encrypt)
  • Push SSE via Mercure intégré
  • Mode worker natif (une instance PHP persistante)
  • Compatible Symfony, Laravel, API Platform
FROM dunglas/frankenphp:latest

COPY . /app
RUN frankenphp php-cli composer install --no-dev
    
CMD ["frankenphp", "run"]

3. NativePHP : PHP Desktop Apps

NativePHP permet de créer des applications de bureau avec PHP et Laravel, en utilisant Electron sous le capot (ou Tauri récemment).

// app/Native/Controllers/MainWindow.php
use Native\Laravel\Facades\Window;

class MainWindow
{
    public function show(): void
    {
        Window::open()
            ->title('Mon App Desktop')
            ->size(1200, 800)
            ->route('dashboard')
            ->show();
    }
}

Cas d'usage : Applications internes d'entreprise, outils de développement, POS systèmes.

4. Async PHP avec Revolt

Revolt est une bibliothèque d'event loop pour PHP, utilisée par Laravel Octane, Amp, et ReactPHP.

use function Revolt\EventLoop;

$timer = EventLoop::delay(1, function () {
    echo "Exécuté après 1 seconde\n";
});

// Async HTTP avec amphp/http-client
$client = new Amp\Http\Client\HttpClientBuilder::build();
$response = $client->request(new Amp\Http\Client\Request('GET', 'https://api.example.com'));

$body = $response->getBody()->buffer();

Avec PHP 8.1+ et Fibers, l'async devient plus accessible :

$fiber = new Fiber(function (): void {
    $result = Fiber::suspend(fetchFromApi());
    processResult($result);
});

5. Laravel Reverb : WebSocket Natif

Reverb est le serveur WebSocket first-party de Laravel, remplaçant Pusher pour le broadcasting.

// config/broadcasting.php
'connections' => [
    'reverb' => [
        'driver' => 'reverb',
        'key' => env('REVERB_APP_KEY'),
        'secret' => env('REVERB_APP_SECRET'),
        'app_id' => env('REVERB_APP_ID'),
        'options' => [
            'host' => '0.0.0.0',
            'port' => 8080,
        ],
    ],
],

Performance : Reverb gère des centaines de milliers de connexions simultanées avec une empreinte mémoire minimale.

6. AI/ML en PHP

L'IA générative n'est plus réservée à Python. L'écosystème PHP s'enrichit :

LLPhant : Bibliothèque PHP pour interagir avec les LLM (OpenAI, Anthropic, Ollama)

use LLPhant\Chat\OpenAIChat;
use LLPhant\Embeddings\OpenAIEmbeddingGenerator;

$chat = new OpenAIChat();
$response = $chat->generateText('Explique SOLID en PHP avec des exemples');

// RAG (Retrieval Augmented Generation)
$embeddings = (new OpenAIEmbeddingGenerator())->embedText($document);

OpenAI PHP SDK :

$client = OpenAI::client($apiKey);
$result = $client->chat()->create([
    'model' => 'gpt-4o',
    'messages' => [
        ['role' => 'system', 'content' => 'Tu es un expert PHP.'],
        ['role' => 'user', 'content' => 'Génère un contrôleur Laravel pour une API REST'],
    ],
]);

7. PHP + WebAssembly

PHP peut maintenant compiler vers WebAssembly, ouvrant des cas d'usage côté client :

# Compiler PHP en WASM
docker run -it --rm -v $(pwd):/app wasmphp/php:8.3 php -v

# Utiliser PHP Wasm dans le navigateur
const php = await PHPWebAssembly.create();
const result = php.run('<?php echo "Hello from WASM!";');

Cas d'usage : Plugins WordPress en WASM, exécution sécurisée de code PHP, sandboxing.

8. Platform Engineering PHP

L'essor des Internal Developer Platforms (IDP) arrive aussi dans l'écosystème PHP :

  • Laravel Cloud : Platform as a Service de Laravel (similaire à Vercel)
  • Laravel Forge API : Automation de provisioning
  • Docker + Laravel Sail : Standardisation des environnements
┌─────────────────────────────────────┐
│         Internal Developer Platform  │
│  ┌─────────┐ ┌──────────┐ ┌──────┐  │
│  │Laravel  │ │Laravel   │ │ CI/CD│  │
│  │Cloud    │ │Forge     │ │GH    │  │
│  ├─────────┤ ├──────────┤ ├──────┤  │
│  │Horizon  │ │Reverb    │ │Pulse │  │
│  │(Queues) │ │(WS)      │ │(Perf)│  │
│  └─────────┘ └──────────┘ └──────┘  │
└─────────────────────────────────────┘

9. Performance : Laravel Octane et FrankenPHP

Octane + RoadRunner :

// config/octane.php
'server' => 'roadrunner',
'llisten' => 8000,
'max_requests' => 500,

Les performances comparées (requests/sec) :

StackRequests/sec
PHP-FPM + Nginx1x (baseline)
Laravel Octane + RoadRunner5-10x
Laravel Octane + Swoole8-15x
FrankenPHP10-20x
Native PHP Worker3-5x

10. Évolution de l'Écosystème

Filament 3

Filament est devenu le standard pour les panneaux d'administration Laravel :

class BlogPostResource extends Resource
{
    protected static ?string $model = BlogPost::class;

    public static function form(Form $form): Form
    {
        return $form
            ->schema([
                TextInput::make('title')->required(),
                RichEditor::make('content'),
                Select::make('status')->options([
                    'draft' => 'Brouillon',
                    'published' => 'Publié',
                ]),
            ]);
    }

    public static function table(Table $table): Table
    {
        return $table
            ->columns([
                TextColumn::make('title')->searchable(),
                BadgeColumn::make('status'),
            ])
            ->filters([...])
            ->actions([...]);
    }
}

Laravel Pulse

Monitoring production intégré :

// app/Providers/AppServiceProvider.php
Pulse::user(fn ($user) => [
    'name' => $user->name,
    'avatar' => $user->avatar,
]);

Pulse::record('performance', 'slow_queries', $duration)
    ->with(['query' => $sql, 'bindings' => $bindings]);

11. Symfony 7+ : Adapterless Architecture

Symfony 7 simplifie radicalement la configuration :

// Avant Symfony 6 (adapters requis)
// config/packages/mailer.yaml
framework:
    mailer:
        dsn: '%env(MAILER_DSN)%'

// Symfony 7+ (auto-configuration)
// .env
MAILER_DSN=smtp://user:pass@smtp.example.com:587

// Symfony 7+ utilise directement les DSN sans configuration YAML

12. PHP et l'Edge Computing

PHP commence à s'implanter sur l'edge avec des solutions comme :

  • Laravel Vapor : Serverless sur AWS Lambda
  • Bref : PHP serverless sur AWS Lambda
  • FrankenPHP : Déploiement edge-ready
# vapor.yml
id: 12345
name: my-app
environments:
    production:
        memory: 1024
        cli-memory: 512
        runtime: 'php-8.3:al2'
        database: my-db
        queues:
            - my-queue
        scheduler: true

Résumé : La Stack PHP 2026

┌────────────────────────────────────────────┐
│              Application Layer              │
│  Laravel 12 / Symfony 7 / API Platform     │
├────────────────────────────────────────────┤
│              Presentation                   │
│  Livewire 3 + Alpine.js / Filament 3       │
├────────────────────────────────────────────┤
│              Server                         │
│  FrankenPHP / Octane (RoadRunner) / FPM    │
├────────────────────────────────────────────┤
│              Queue / Events                 │
│  Horizon / Reverb (WebSocket) / Messenger  │
├────────────────────────────────────────────┤
│              Database                       │
│  PostgreSQL 17 + Redis 7 + Meilisearch     │
├────────────────────────────────────────────┤
│              Infrastructure                 │
│  Docker / Laravel Vapor / Forge            │
├────────────────────────────────────────────┤
│              Monitoring                     │
│  Pulse / Sentry / Laravel Cloud            │
└────────────────────────────────────────────┘

PHP n'a jamais été aussi performant, moderne et agréable à utiliser. Les avancées du langage (JIT, Fibers, types) combinées à l'écosystème (Laravel, Symfony, FrankenPHP) en font un choix de premier ordre pour le développement web en 2026.

PrécédentChapitre 23 — 23 — Annexes