In the specific context though, it is relevant. So the aside is more closely related to the behavior being outlined.

Really wish I could use Gemini without linking it to my personal Google account.

I observed the same, and generalized it as inability to recognize salience and more broadly apply discretion.

In turn it makes me wonder how do humans do those things? Perhaps it is our human job to apply discretion going forward.

In the context of PHP it is notable to be able to run a production grade web server without nginx/apache/docker in front of it.

PHP doesn't have a production grade built-in server like .NET's Kestrel.

And get rid of all the hardcoded paths, domains, things that only make it work on the specific OS the previous person was using even though there's nothing in the app that would justify it. And then one day, someone introduces Docker, that will make it work everywhere, only now you have to start the containers in some specific order and comprehend some complicated volume setup and it runs 10x slower.

Docker isn't used because it helps run unstable programs.

It's used because it combines the entire environment so I know the app runs the same locally as it does when deployed, without needing to install or configure anything on the server.

You just start the image and it runs.

The claim is presumably that a web server running SQLite is that much better than a web server running Postgres or Redis. So they end up including it in the calculation anyway but only on one side... so it's just simply not even apples to apples.

I meant a server dedicated to the database, but yes, I agree. Never said the web server had to be bare metal.

I wonder if the misconception is from relying on managed database services. Maybe instead of installing their own database, they order one from a service provider like AWS or GCP. That would explain how they'd think that a database like Postgres would have to live on a different machine.

I saw someone promote their new simple framework today. It was all TODOs.

I feel like HN has had posts like this for 15 years. This one is just an opportunity to discuss where php falls with llms in the mix.

Just because LLMs can write copy for webpages doesn't mean they should. A landing page should not warrant a tl;dr.

https://news.ycombinator.com/item?id=49665895

I think that is far to harsh actually.

It has some interesting ideas and architecture.

I agree. Nginx, Caddy, Apache, etc have found and fixed a million edge cases you'd never think of just from reading and implementing the spec. I guarantee there's code in each of these along the lines of:

  # Send an extra 0x20 space character after this header's value, because
  # otherwise Chrome on Android 15 shifts into compatibility mode and
  # it takes 37x longer to render the page, which everyone will blame on
  # "the slow webserver". The spec doesn't say we *can't* add this, and
  # tells clients to ignore trailing space, and we've tested this with 483
  # other clients to demonstrate that it doesn't cause problems. ¯\_(ツ)_/¯ .

Now, as a very cool hack, or for easier local development with one less dependency, or just to scratch a personal itch and see if it can even be done, right on! That's clever and I'm glad they did it!

BTW, in your showdead (for wholly unclear reasons) comment about it using copy-on-write RAM semantics, that's just the Unix process model. The OS does all that courtesy of fork() and the server gets it for free.

I was kind of wondering too. I assume this only works if you load a lot of classes before touching request specific variables. That might work for big framework, but you probably have to rewrite a lot if not using one.

From a pragmatic perspective, its unclear to me how much this actually speeds things up. I would assume if using php you probably have complex logic and start up time is not dominating the runtime.

I think we are all afraid that an LLM could generate a ridiculously fast webserver and be production viable. But I'm still glad we are taking this through the ringer.

def tripped over those asterisks

I love the idea of being able to remove the webserver from my stack, and be able to give that job to php too. Less deps!

Workerman does something else.

Yeah, and surely they also wrote the 131KB unreadable-wall-of-text README themselves.

That's like 1/9th Moby Dick, to put into perspective.

There are very clear signs this was mostly built by an LLM. Just an example: https://github.com/Qbix/webserver#%EF%B8%8F-architecture misaligned lines, the commit history, etc.

over 100K lines of code materialized over the course of 3 weeks and is full of em dashes. I think we can reasonably assume here...

I think there's opcache enabled by default.

Indeed, it's on by default in 8.5 and is no longer considered a non-optional extension (it's compiled in) - you can turn it off at runtime but it will be bundled, largely so they could have it on my default[1][2] and it simplifies integration of something that was universally integrated de facto before that.

It was probably due/overdue but I actually like that they are conservative with which extensions become part of the "core" and in reality almost every packaging of PHP has included it back to 5.5 and having worked on large production systems written in PHP I can't think of a single one that didn't use it it in production.

There is also FrankenPHP (and others) which negate much of that overhead (in worker mode).

While introducing other issues you do have to be careful of that would be less of an issue in "classic" mode (literally what FrankenPHP calls it).

There isn't a tonne of good info out of what you gain in the switch from nginx/php-fpm to FrankenPHP though it does seem like you do gain in some ways (but it's very application dependent).

[1] https://wiki.php.net/rfc/make_opcache_required

[2] https://www.php.net/manual/en/opcache.configuration.php

php-fpm re-bootstraps the framework on every request (10–50ms)

What is the setup/benchmark that caused you to see this?

1060 req/s

Nice! I remember 2010 when a single-core pentium 4 was happily doing 18k RPS with Glassfish. Ten more years of progress and you can match that!

Sort of unrelated, but I recently built an http server in Odin to learn the language. It’s a pleasant language, and very low memory usage, if managed well. Around 50k requests per second on my old laptop. The surprising thing was that Bun matched it (albeit at 50MB RAM usage vs 3MB for Odin).

It’s a lot of fun working on such things, but the reality is, for most apps, almost any stack is more than fine.

Outside of the prefork mode (which cannot compete even with just FPM/Apache mod), this has a bunch of isolation issues that I don't see mentioned anywhere; namely statics in functions (often seen as a request-lifetime cache in PHP), typed statics without defaults, define(), $_ENV, setlocale(), ignore_user_abort() or mb_internal_encoding() just to name a few. It also assumes all function/class declarations are guarded, so this isn't a drop-in replacement for a webserver that "just works"; for most code, it probably doesn't, so the "unmodified PHP" claim seems like a stretch.

EDIT: After reading through the fairly long README, this is mentioned. So you either use the provided server API to make it fast, or use the CGI mode - even for WP, Laravel or Symfony ("legacy", really?)). It'd be better advertised as a framework, using which is the only way to actually achieve the promised results.

I'm also a bit confused by the webserver code itself; it's PHP 5 code (with all the @class and @private annotations, even) that targets 8.1 (EOL) and yields deprecation notices on PHP 8.2.

The taken approach is interesting, but I'd not put this in front of anything that matters.

If you're this uncomfortable with having to run a webserver, but comfortable with a vibecoded webserver, consider switching to Go, .NET or any other stack where you don't have to fight the PHP's inherent shared-nothing model.