> The TideWays benchmark doesn't show the peak, it shows the rps for 15 sustained users.
Yes. And it's also not entirely representative of a production set-up. As an example Vegata is running on the same machine as PHP and the same is true for the MySQL server used by WordPress and Laravel. The tests are also running against a - except for worker count - stock installation to possibly highlight improvements by better INI defaults in newer PHP versions. This is all good enough to compare the different PHP versions against each other, since they are all equally affected by this. But it is thus by no means representative of what you can get out of a properly tuned production setup.
Disclosure: I set up the benchmark and performed the measurements.
PS: It's Tideways, lowercase 'w'.
And add a few more unknown CVE, as perpetual Beta and DevOps culture does by design.
The old approach of out-pacing adversaries though mutation rates is over, given an entire FOSS code-audit looking/fuzzing for 0-days can now be done in under a day. In retrospect, over 700 reported LPE and 280 kernel CVE were dropped in the past 3 months from "LLM". This is not going to stop anytime soon.
To be honest, its very nostalgic as kids would clown each others servers in the early days. Ultimately leading to a more robust OS for everyone. =3
The vast majority of designers prefer animations. Without animations, there would be less jobs for designers. But I haven't seen any evidence that ordinary people prefer animations. Most ordinary people aren't even aware that it's possible to turn animations off, because the designers make this difficult.
> But I haven't seen any evidence that ordinary people prefer animations.
There are mountains of evidence supporting the idea that people prefer animated UIs over static UIs going back decades. This is true even in the world of TUIs, again, going back decades. I genuinely don't understand how you can make this statement so confidently.
Maybe if the question is “hey was that fancy animation really cool?”
Animation, used judiciously to communicate valuable information about the UX, is good. Most of the rest is only tolerable so long as it doesn’t slow anything down or change how scrolling works.
A UI should be reactive rather than proactive. Any state changes should be explicitly requested by the user, who naturally knows what they requested, making "informative" animations redundant.
However, there is one legitimate use for UI animations: making it easier for spectators to follow what's happening. Spectators aren't the ones making the requests, so they can be confused if things happen too fast. Most computer use is not done for the benefit of spectators, so animations should be disabled by default, but it's beneficial to have the option of enabling them.
> Any state changes should be explicitly requested by the user, who naturally knows what they requested, making "informative" animations redundant.
I can't really follow your thought process here for two reasons:
1. "Informative animations" (I interpret this as not-feedback-for-UI-interaction animations) are usually based on the response, not the request. So the user doesn't know the info which the animation communicates.
2. Most users immediately want some tiny acknowledgement of their request, e.g. a button's state changing (base -> pressed -> active/disabled). If the request takes longer than a few seconds, users really want a loading animation - otherwise they're less likely to wait until the response comes back, even if they know that it takes a long time. At least that's been my experience.
We had functionally complete GUIs in the 90s. If something takes more than a few milliseconds to respond after 3 decades of hardware progress there's definitely something wrong.
If we're talking about local CRUD, sure, but that's a tiny minority of use cases. As soon as your application does network requests outside your LAN, less than a few milliseconds is impossible for most regular users and developers. That's not to mention tons and tons of processes that definitely take more than a few milliseconds, like: compiling a meaningfully big codebase, compressing/uncompressing most files, rendering a video, ...
Those are just a few examples. What is the "something" that's wrong with all of us?
Again, the vast majority of people prefer animated UIs to non-animated ones. My own anecdotal experiences in building UIs and talking to end users over both short and long time frames supports this.
The package is marked as abandoned on Packagist [1]
> This package is abandoned and no longer maintained. No replacement package was suggested.
Both adding it as a dependency using composer and installing it from a lockfile results in:
$ composer require jakeasmith/http_build_url
[…]
Package jakeasmith/http_build_url is abandoned, you should avoid using it. No replacement was suggested.
[…]
$ rm -r vendor/
$ composer install
[…]
- Installing jakeasmith/http_build_url (1.0.2): Extracting archive
Package jakeasmith/http_build_url is abandoned, you should avoid using it. No replacement was suggested.
[…]
Replacement is defined in the github repo, in composer you can only define an replacement package, but there is no real replacement, just alternative ways.
The examples in TFA are terrible and I don't get why it was necessary to jump the gun by submitting that article instead of actually waiting for the release and the official release page with more carefully designed examples.
> The examples in TFA are terrible and I don't get why it was necessary to jump the gun by submitting that article instead of actually waiting for the release and the official release page with more carefully designed examples.
Google Container Registry provides a pull-through mirror, though, just prefix `mirror.gcr.io` and use `library` as the user for the Docker Official Images. For example `mirror.gcr.io/library/redis` for https://hub.docker.com/_/redis.
Indeed. It might even result in out of range values due to implicit rounding (`3.5 + (4.5 - 3.5) * (the largest float smaller than 1)` results in 4.5, which is unexpected).
I'm a contributor to the PHP programming language and a maintainer of the randomness functionality and did some research into this topic to provide a floating point generation method that is as good as possible and came across the "Drawing Random Floating-point Numbers from an Interval" paper by Frédéric Goualard.
PHP 8.3 ships with a method generating random floats from arbitrary intervals based on the γ-section algorithm described in that paper. The PHP documentation goes into additional detail:
As part of the implementation I also reached out to Prof. Goualard with some questions for clarification regarding the behavior for extreme values, which resulted in an Corrigendum being published, since the algorithm was buggy in those cases (https://frederic.goualard.net/publications/corrigendum.pdf). The entire exchange with Prof. Goualard was really pleasant.
Yes. And it's also not entirely representative of a production set-up. As an example Vegata is running on the same machine as PHP and the same is true for the MySQL server used by WordPress and Laravel. The tests are also running against a - except for worker count - stock installation to possibly highlight improvements by better INI defaults in newer PHP versions. This is all good enough to compare the different PHP versions against each other, since they are all equally affected by this. But it is thus by no means representative of what you can get out of a properly tuned production setup.
Disclosure: I set up the benchmark and performed the measurements. PS: It's Tideways, lowercase 'w'.
reply