I just made this #rustlang `sql!` macro to write compile-time checked database queries similar to how `format!` works public:

Good thing about the decline of Twitter: since I stopped using it on a regular basis, I don’t know anything about the most recent JS frameworks anymore

Made a v2 with focus on being quieter. Happy with how the stabilisers turned out – not perfect but a huge improvement compared to v1 which my partner heard two rooms away. No custom printed keycaps this time as they didn't last very long – missing the red Esc key though #keeb

It saddens me, that Frankfurt is the worst upon the test regions for both ...

It is possible that either of both is closer / in the same data center as the servers the tests were run from. So the results need to be taken with a grain of salt. Main takeaway for me is at least that it doesn't seem like I'd deteriorate the latency of my app.

Did some non-scientific latency tests. Instances (on @flydotio) instead of workers on a CDN looks good. First picture is CDN, second is multiple instances. I've been running an instance in each of those test regions, and the CDN has nodes in all of those test regions (AFAIK).

… and getting tracing integrated would be much easier within my private network and with a simple node process (even though I dislike running non-compiled code on my own instances).

Contemplating moving my frontend back from workers to instances, due to the local dev experience being a recurring headache / to be as close to production as possible …

New must have for editors: custom treesitter language injection queries. Makes an sql! macro (and similar use-cases) even better:

That‘s a first. Had such a big refactor that the quickest way was to write a #Rustlang proc macro, `cargo expand` it, and copy the result over. 😵‍💫

Most recent major change was to move element attributes before their content. Even though having attributes at the end like SwiftUI is somewhat pretty, it is very hard to read / reason about for large / deeply-nested tags ...

My my #Rustlang-based server-first components entered the next phase. I've started to build internal tooling using it to evolve it further from real-world usage. Still not entirely happy with the API, so I expect it to change further ...

"Conflicting implementations of trait" is my worst enemy in #Rustlang 😑

Helix to the rescue

My PC is cursed. Doesn't want me to work on it. I can game on it all day (so hardware seems fine I suppose), but VSCode crashes every couple of minutes, Sublime Text has frequent freezes, Fleet bluescreens my PC, and even Firefox crashed while I tried to write this tweet ...

Not the greatest error message to work with though (even worse on stable where it is a u64 hash instead of the actual column name; e.g. 189237198 instead of "name"). But all I can do since I want the type to be inferred (rather than having to use `sql!(User, "SELECT ...")`.

This #rustlang sql! experiment escalated a bit. First steps towards basic compile-time query checks are done ...

Http routes is a #rustlang topic where I always end up using a simple and verbose match (with helper get!/post!/... macros for readability). Not ideal, but each time I try to use a popular library with a flexible builder-pattern, I get frustrated trying to get the types right ...

100% me 😬

Dang it, I got sidetracked again – but I have to admit, I quite like the idea of a #Rust sql! macro that behaves as close as possible as format! (but creates parameterized queries) ...