On Tue, Mar 4, 2025, at 23:54, Eugene Sidelnyk wrote:
> 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
Huh. Reminds me of SSA, which can identify independent computations like that. It’s used by go,
and many other compiled languages, but not in the same way this bend language does it. So, that’s
interesting.
I don’t know if php could implement SSA (maybe opcache could), but with how dynamic php is, I’m
not sure it would be helpful.
An interesting application nonetheless, thanks for sharing!
— Rob