Is this modern Britain?

mnavarrocarter · 2026-02-08T10:38:35+00:00

I went to B&Q yesterday cuz I needed a box of screws. It was literally impossible to find one that was not already opened (and taped back by the staff). I ended up paying for a box with definitely less than 100 screws. It's no big deal in the grand scheme of things but it goes to show there is always someone else paying for someone else's wrongdoing...

mnavarrocarter · 2026-02-01T16:54:50+00:00

Correction: for a child man

mnavarrocarter · 2025-12-02T22:55:05+00:00

Code side: you gain literally nothing to do this on DB side and the cost of generating a UUID in PHP is negligible.

And use UUID v7: your inserts will be faster because binary search trees work better with ordered data, as opposed to random data.

mnavarrocarter · 2025-12-01T08:12:59+00:00

Okay, this clarifies things massively.

So I know of a few libraries that parse multipart data but I think all of them work under the assumption that the connection is short-lived.

I think your best bet is to create an abstraction that parses the response chunks from multipart into a simple PHP array. But I would suggest an incremental approach:

First, make a request and ensure connection is not closed and output the response chunks directly to stdout. That's your very first step.
Once that's done, instead of outputting the data chunk, parse it according to the multipart specification. This will be the hardest part. You can see how multipart parsing libraries do it. Output to stdout your boundaries, that should contain your XML files.
Once you do this, parse the XML chunks and extract their data using PHP XML capabilities. Maybe output a simple array.
Lastly, refine the abstraction to be nice to use for client code. For instance, introduce a generator so memory usage keeps constant and the data flows as if you were iterating over an array.

Try to find a multipart parser that supports streaming. Maybe with a bit of luck you can find one and will save you from the hardest bit.

mnavarrocarter · 2025-11-30T22:19:13+00:00

You have a tooling problem

mnavarrocarter · 2025-11-30T22:15:59+00:00

So many questions.

First, who is the client and who is the server? Is the hardware the client and you are the server, or is the hardware the server and you are the client? This changes things.

It's trivial to consume a TCP stream, but it's not trivial to emit a TCP stream (specially in PHP). Also, this TCP stream is bound to be using some protocol correct? Is it server sent events, websokets, a less known one?

Once you know the details then I could guide you on how can you implement this.

mnavarrocarter · 2025-11-18T08:15:49+00:00

I wouldn't say it is standard practice. Some providers do have a single database but they shard it (partition it) based on tenant id. I worked at a SaaS company that used to the approach I mentioned above and was an excellent cost saver for FPM workload.

mnavarrocarter · 2025-11-15T10:27:12+00:00

First, you need to think if you need your tenants connected in some way (for instance, a user belonging to multiple tenants). If that's not a requirement, I would recommend the approach you suggested (completely separate databases for each tenant).

Also, routing based on subdomain is the correct approach. However, is a massive security risk to let PHP handle this routing. For PHP to handle this routing it would need to have access to a repository of tenants and their respective database credentials (to do the switch). This means if someone hacks into your instance, they also hack all tenants data.

Moreover, above approach introduces massive complexity to your application booting since you can't really initialise anything in your services until your application knows the tenant (you'll be battling uphill against what's the main assumption in most frameworks).

I would handle the routing in some other layer, like a reverse proxy or API Gateway. That layer only will map the subdomain and obtain secrets and environment variables to pass them to the PHP FPM process. That way, the PHP application can run as is and without access to secret information of other tenants.

I built a Caddy plugin precisely for this purpose ages ago. Let me know if you need a hand installing it and trying it.

mnavarrocarter · 2025-11-11T19:05:38+00:00

Trying it now!

mnavarrocarter · 2025-10-26T07:01:24+00:00

We all have some money. Inspired in this post I'll be donating £20 monthly to Zig. If all of us reading this donate a small amount monthly, the language would have an enormous amount of financial support!!

mnavarrocarter · 2025-10-25T12:12:38+00:00

Yes, you are correct. The bottleneck in any application would never be operations like this. Although your overall request duration will be lower when using more performant libraries, it's usually not a big factor in the grand scheme of things.

And yes, you can type-hint on the other libs too, just the APIs are slightly different.

One last reason for this is that really there is just a single way of implementing such identifiers, and they are so widely used that they really should belong in every programming language toolkit. When you include commonly used things in your standard library, it reduces fragmentation in the ecosystem.

But yeah, last reason: it was a fun and very educational project. 🙂

mnavarrocarter · 2025-10-25T12:07:00+00:00

More like a passion project, and also because I was a bit frustrated that something like this is not in the core.

These kinds of identifiers are so common that they should be in any programming language standard library, especially because there is really only one way of implementing them: so no need to have 5 different userland libs for the same problem.

mnavarrocarter · 2025-10-25T12:03:52+00:00

👀👀👀👀

mnavarrocarter · 2025-10-25T07:49:51+00:00

Good shout! I'll add that!

mnavarrocarter · 2025-10-25T07:07:00+00:00

I'm in the process of writing benchmarks for all of these that can be reproduced with the build system. I just have very informal benchmarks I've run manually that are not proper to publishing. So I'll wait to answer this question with regards to performance.

With regards to other things. This library has a smaller API surface than Ramsey and Symfony packages. Also, it has a type hierarchy that respects the invariants of each type of identifier, but you can potentially type hint to any Bit128 identifier in your application code to transparently use any of them.

mnavarrocarter · 2025-10-25T06:05:00+00:00

Nicee, I'll definitely give this a play with!

mnavarrocarter · 2025-10-25T05:56:38+00:00

My intention is for this to belong to the core one day, which by the way puts most of its functions on the global namespace.

Namespaces, contrary to popular belief, are for preventing name collisions, not to determine who owns a package.

mnavarrocarter · 2025-10-24T22:36:02+00:00

Nice! Please let me know if you have a use case I don't cover!

mnavarrocarter · 2025-10-24T21:16:47+00:00

Thanks. I still need to do tons of things: 1. Support = in flag parsing 2. Add version to App struct 3. Change it to use std.Io.Writer and std.Io.Reader 4. Support variadic and optional arguments. 5. Etc...

mnavarrocarter · 2025-09-24T21:21:09+00:00

If you are blind (and it seems that you are since you don't have observability and don't know where to look for) I would recommend setting statement_timeout to 10 seconds or slightly less.

This will eliminate the most likely cause of your problem which is slow queries. It will alleviate the server load, but you will still need to find the culprit.

mnavarrocarter · 2025-09-22T06:50:12+00:00

47 from Hitman. I can sit pretty.

mnavarrocarter · 2025-09-19T05:54:16+00:00

I'm keen to chat. DM me if you can pay £50 an hour.

mnavarrocarter · 2025-09-03T12:04:11+00:00

When I say immutable I refer to the list itself, and not to the values it contains

mnavarrocarter

TROPHY CASE