Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126570
Precedence: bulk
MIME-Version: 1.0
References: <CAMW7n8AJckEDzhGv9BdjNhq8zAdCqb4HsVr56vGi+izw50X6Dg@mail.gmail.com>
 <9964db8c-0ffe-43d5-8246-47fc76b07180@app.fastmail.com>
In-Reply-To: <9964db8c-0ffe-43d5-8246-47fc76b07180@app.fastmail.com>
Date: Wed, 5 Mar 2025 00:54:19 +0200
Message-ID: <CAM0CcxhgOCsy46gp1qd4Zrdw8v0TfTkTTMin5EiHW18EDZRzwg@mail.gmail.com>
Subject: Re: [PHP-DEV] PHP True Async RFC
To: Larry Garfield <larry@garfieldtech.com>
Cc: php internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="000000000000e51330062f8c274d"
From: zsidelnik@gmail.com (Eugene Sidelnyk)

--000000000000e51330062f8c274d
Content-Type: text/plain; charset="UTF-8"

Hi there,

I would also like to highlight some interesting ideas that I find being
useful to consider.

Recently Bend programming language has been released, and it incorporates a
completely different view on the conception of "code", in the definition of
"what it is" and "how it should be interpreted".

While we interpret it as a sequence of instructions, the proper way of
seeing it is the graph of instructions. On every step we reduce that graph,
by running the code of the nodes current node depends on.

Therefore, basically everything could paralleled w/o the need to have fancy
management of threads and other low-level things.

For example, having this code:

$foo = foo();
$bar = bar();
$baz = $foo + $bar;

If it was run in Bend, it would be interpreted so that foo() and bar()
functions are executed in parallel, and $baz = $foo + $bar is executed
afterwards, since this computation depends on the other two.

The key, most excellently beautiful feature
here is that all async management is under the hood, exposing nothing for
the developers to be bothered with.

That being said, I also want to mention that Bend has a primitive for
concurrent loops. Actually, they used another solution, different from
loops, since loops are sequential by their essense (iterative one by one).
They introduced a concurrent alternative for loops with "bend" keyword,
allowing data structures to be traversed in parallel.

I think this is actually "the right way" of doing parallel processing in
general and async programming in particular, and this is greatly to be
considered for having at least some principles applied in PHP.

What I think it could be.

async function baz(): int {
  $foo = foo();
  $bar = bar();

  return $foo + $bar;
}

// value is returned just like from any other ordinary function
$val = baz();

Function above could run foo() in one fiber, and bar() in another, both of
them being awaited at the return statement (at the first statement where
the value is actually used / referenced, if we put it more generally) so
that actual values could be taken.

In other words, async function is not promise-based as in other languages
that suffer from red blue function problem, but rather it is function with
coroutine flow of execution, so that foo() is executed as the first
coroutine, and when it blocks, then bar() is executed until it also blocks.
Then, at plus operator being evaluated, $foo is awaited, and $bar is
awaited, since they are necessary parts for + operation to complete.


Best regards

--000000000000e51330062f8c274d
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"auto"><div dir=3D"auto">Hi there,</div><div dir=3D"auto"><br></=
div>I would also like to highlight some interesting ideas that I find being=
 useful to consider.<div dir=3D"auto"><br></div><div dir=3D"auto">Recently =
Bend programming language has been released, and it incorporates a complete=
ly different view on the conception of &quot;code&quot;, in the definition =
of &quot;what it is&quot; and &quot;how it should be interpreted&quot;.</di=
v><div dir=3D"auto"><br></div><div dir=3D"auto">While we interpret it as a =
sequence of instructions, the proper way of seeing it is the graph of instr=
uctions. On every step we reduce that graph, by running the code of the nod=
es current node depends on.=C2=A0</div><div dir=3D"auto"><br></div><div dir=
=3D"auto">Therefore, basically everything could paralleled w/o the need to =
have fancy management of threads and other low-level things.</div><div dir=
=3D"auto"><br></div><div dir=3D"auto">For example, having this code:</div><=
div dir=3D"auto"><br></div><div dir=3D"auto">$foo =3D foo();</div><div dir=
=3D"auto">$bar =3D bar();</div><div dir=3D"auto">$baz =3D $foo + $bar;</div=
><div dir=3D"auto"><br></div><div dir=3D"auto">If it was run in Bend, it wo=
uld be interpreted so that foo() and bar() functions are executed in parall=
el, and $baz =3D $foo + $bar=C2=A0is executed afterwards, since this comput=
ation depends on the other two.</div><div dir=3D"auto"><br></div><div dir=
=3D"auto">The key, most excellently beautiful feature=C2=A0</div><div dir=
=3D"auto">here is that all async management is under the hood, exposing not=
hing for the developers to be bothered with.</div><div dir=3D"auto"><br></d=
iv><div dir=3D"auto">That being said, I also want to mention that Bend has =
a primitive for concurrent loops. Actually, they used another solution, dif=
ferent from loops, since loops are sequential by their essense (iterative o=
ne by one). They introduced a concurrent alternative for loops with &quot;b=
end&quot; keyword, allowing data structures to be traversed in parallel.</d=
iv><div dir=3D"auto"><br></div><div dir=3D"auto">I think this is actually &=
quot;the right way&quot; of doing parallel processing in general and async =
programming in particular, and this is greatly to be considered for having =
at least some principles applied in PHP.</div><div dir=3D"auto"><br></div><=
div dir=3D"auto">What I think it could be.</div><div dir=3D"auto"><br></div=
><div dir=3D"auto">async function baz(): int {</div><div dir=3D"auto">=C2=
=A0 $foo =3D foo();</div><div dir=3D"auto">=C2=A0 $bar =3D bar();</div><div=
 dir=3D"auto"><br></div><div dir=3D"auto">=C2=A0 return $foo + $bar;</div><=
div dir=3D"auto">}</div><div dir=3D"auto"><br></div><div dir=3D"auto">// va=
lue is returned just like from any other ordinary function</div><div dir=3D=
"auto">$val =3D baz();=C2=A0</div><div dir=3D"auto"><br></div><div dir=3D"a=
uto">Function above could run foo() in one fiber, and bar() in another, bot=
h of them being awaited at the return statement (at the first statement whe=
re the value is actually used / referenced, if we put it more generally) so=
 that actual values could be taken.</div><div dir=3D"auto"><br></div><div d=
ir=3D"auto">In other words, async function is not promise-based as in other=
 languages that suffer from red blue function problem, but rather it is fun=
ction with coroutine flow of execution, so that foo() is executed as the fi=
rst coroutine, and when it blocks, then bar() is executed until it also blo=
cks. Then, at plus operator being evaluated, $foo is awaited, and $bar is a=
waited, since they are necessary parts for + operation to complete.</div><d=
iv dir=3D"auto"><br></div><div dir=3D"auto"><br></div><div dir=3D"auto">Bes=
t regards</div></div>

--000000000000e51330062f8c274d--