Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129366
Precedence: list
MIME-Version: 1.0
References: <CAMW7n8D0QshP8VhGOUqVnC+Uwf88TC_yy_mQdeNZW_go5YLdcw@mail.gmail.com>
 <C58ADF49-6E21-4E25-8859-2A0769829E38@php.net> <e8625214-1c6f-40b8-b24f-e592e6f92012@beccati.com>
 <CAMW7n8Dy3=QyCrG4BMwVXWAipgOr2Vyhy_jbLVTYeq2Jc5v15g@mail.gmail.com>
 <dbc31109-a43d-4afc-9f4f-62c6439328e5@rwec.co.uk> <ea59722c-2c84-4a59-a442-a8b217ff577d@gmail.com>
 <b151687a-f4bd-48cf-90e6-440f763ccd6b@rwec.co.uk> <CAMW7n8CLZ7yFhUhh89wx7L+YwQ25LA7HZoGWUFB3R76KgXko2w@mail.gmail.com>
 <CAEKnhAHRPbiU4auDuTtFL2ueNnACjmYm_ff9c3VciYE9HfeGZg@mail.gmail.com>
 <CAMW7n8D5B=XVX_Jes+LV=2fPwjQr_RBVphPi_Cxm8-_Rwpdo_Q@mail.gmail.com> <CADK1yX+jGtqQVYFTo5YmkenPrNcXz7Dd7RCUKWGrq+50pnKOnw@mail.gmail.com>
In-Reply-To: <CADK1yX+jGtqQVYFTo5YmkenPrNcXz7Dd7RCUKWGrq+50pnKOnw@mail.gmail.com>
Date: Fri, 21 Nov 2025 15:45:28 +0200
Message-ID: <CAMW7n8Dogjj2JFJBNArk-BfvOHRqHKMAFReXJAhDm2UPV1TF7A@mail.gmail.com>
Subject: Re: [PHP-DEV] [VOTE] True Async RFC 1.6
To: Deleu <deleugyn@gmail.com>
Cc: Jakub Zelenka <bukka@php.net>, "Rowan Tommins [IMSoP]" <imsop.php@rwec.co.uk>, internals@lists.php.net
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: edmond.ht@gmail.com (Edmond Dantes)

Hello.

To use AMPHP you don=E2=80=99t need to run its server. But let=E2=80=99s si=
mplify the situation.

You have Fiber.
With Fiber you can build an EventLoop + Scheduler, create two
coroutines, and then run code inside them that, for example, renders a
template.

It will require a fair amount of code, but it=E2=80=99s possible.
At the same time, ob_start/ob_end will immediately break, because they
don=E2=80=99t support Fiber switching. This is a known bug.
And if you pass global state into closures, and that state changes
unpredictably, the application logic will essentially break.

**What=E2=80=99s different with TrueAsync**

1. You don=E2=80=99t need to write a lot of code. Yes, just spawn();
2. `ob_start` and `ob_end` will work correctly.
3. If closures share a variable that multiple coroutines write to
unpredictably, the application will still break.

In other words, no matter how asynchrony is implemented in PHP (and
other langs), it will always require correct handling of shared
memory.
And I want to clarify a bit. This is not about a global variable. It=E2=80=
=99s
about shared memory. These are not the same things. A local variable
can be passed into a closure by reference.
But if you don=E2=80=99t call WP() inside a coroutine, nothing prevents you
from using asynchrony.

In TrueAsync there is a Dockerfile for FPM, you can install it locally
and try running WordPress. I=E2=80=99m sure something will break, but not
everything at once :)

> My understanding of AMPHP is that things only become async if you explici=
tly run AMPHP as your web server. It either has no effect
> if your application is running Apache + mod_php OR your application 100% =
breaks with nothing getting executed at all. Is this not true?

You can use it without a server. The only difference is that the
coroutines won=E2=80=99t live longer than the HTTP request. The same applie=
s
to TrueAsync when running under FPM.

> When I try to open my website locally it will either have everything brok=
en or it will just work regularly and nothing will be running async. There =
is no other option.
It won=E2=80=99t break on its own.
It will only break if that =E2=80=9Csomething=E2=80=9D shares a variable or=
 resource
with your code. If you write code according to SOLID principles, the
chance of breakage is very low.

If someone writes coroutine code and completely ignores memory
handling, it=E2=80=99s the same as writing an infinite loop. Can they do th=
at?
Yes. Can you download that code? Yes. Can it break everything? It can.
What=E2=80=99s the conclusion?

> I do `composer update` one day and test my home page and it works. But de=
eply nested somewhere there is a feature that will use Package A which
> then spawns a coroutine and leads to my global state code behaving weirdl=
y. It's not a fatal error. It's not very clear at all to me that something =
changed,
> but now my array indexes are triggering DB updates out of order.

The exact same thing will happen in code without coroutines if, for
example, you have a class, you pass an array to it by reference,
and that class silently corrupts your values. You don=E2=80=99t need
asynchrony for that to happen.

```php
<?php

class Storage
{
    private array &$data; // holds a reference to the external array

    public function __construct(array &$data)
    {
        // store the reference
        $this->data =3D &$data;
    }

    public function loadUser()
    {
        // looks like a harmless read
        return $this->data['user'] ?? null;
    }

    public function updateInternally()
    {
        // silently mutates the external array
        $this->data['user'] =3D 'hacked';
        $this->data['counter'] =3D ($this->data['counter'] ?? 0) + 1;
    }
}

// ---------------------

$shared =3D [
    'user' =3D> 'admin',
    'counter' =3D> 0,
];

// create the class, passing the array by reference
$storage =3D new Storage($shared);

echo $storage->loadUser() . PHP_EOL; // admin

// somewhere else this method is called, modifying the shared array
$storage->updateInternally();

print_r($shared);
// the array is now corrupted unexpectedly

```

There is no asynchrony in the example above. It=E2=80=99s just normal code.=
 It
breaks application logic because the class secretly holds the array
and modifies it without permission.

And a coroutine is just a regular object. If you pass a referenced
array into a coroutine and then say something =E2=80=9Caccidentally=E2=80=
=9D broke, it
wasn=E2=80=99t accidental. Did the array get there by accident? No. Did som=
e
developer write the code by accident? No. It=E2=80=99s a bit different from
synchronous code, but the meaning is exactly the same.
I have a mental habit: when I write asynchronous code, I always assume
that any object shared between coroutines can change at any moment.
Similarly, if you hand off memory ownership to another class or share
memory, you have to keep in mind that there is a chance some developer
might accidentally do something wrong.

The only difference between synchronous and asynchronous code is that
you don=E2=80=99t have a precise moment in time when the change happens. An=
d
yes, that makes debugging harder. It makes finding bugs harder. But
it=E2=80=99s not something fundamentally new.

Yes, making the same mistakes with AMPHP is harder, because you need
to install a whole package and so on. But that=E2=80=99s not a guarantee :)