Fulgen

This is about raw_sql, which is explicitely documented to not use prepared statements and thus doesn't support query parameters; not about the actual query() API SQLx offers.

> Note: query parameters are not supported.

> Query parameters require the use of prepared statements which this API does support.

> If you require dynamic input data in your SQL, you can use format!() but be very careful doing this with user input. SQLx does not provide escaping or sanitization for inserting dynamic input into queries this way.

> See query() for details.

C++20 actually [changed the semantics of consume](https://devblogs.microsoft.com/oldnewthing/20230427-00/?p=10...), but Rust doesn't include it. And last I remember compilers still treat it as acquire, so it's not worth the bytes it's stored in.

In Rust or in general? Because an arbitrary "too old" moniker is not something I've seen happening, and the only target that was removed instead of demoted in recent times was i586-pc-windows-msvc, aka Windows 10 without SSE, which was...utterly pointless since Windows 10 requires SSE.

If anything, I quite like the way Rust handles it with target tiers and easy switching between targets, because it's an honest approach about how well a target is supported. Having a win7 target that is tier 3 is a reflection of the support it has, and much better than stringing it along in the main Windows target that promises tested support when there isn't even a Windows 7 CI to test on.

Nobody noticed because Windows special cased InstallShield.

https://devblogs.microsoft.com/oldnewthing/20131031-00/?p=27...

The problem is, as usual, that some people want that support, but nobody is actually interested in helping out with that support - and that doesn't only include people willing to help out with the code, it includes things like CI. Just how the riscv targets won't be able to reach tier 1 without GH or someone else offering CI support.

Rust's target tiers, while historically not as enforced as they are today, have requirements attached to them that each target has to fulfill; demoting a target or removing support isn't done for fun, but because of what the reality reflects. In Windows 7's case, support from the Tier 1 Windows target was not so much removed as it was acknowledged that the support guaranteees just didn't exist - host tools had long been dead with LLVM having removed support for running on Windows 7, and tier 1 support wasn't guaranteed without any CI to test it on. Thus support was removed, and very soon contributors popped up to maintain the win7 target which is tier 3 and accurately reflects the support gurantees of that target.

(Not a jab at your situation btw, and I wish I could offer you a solution beyond the win7 target - but as it's essentially the preexisting Windows 7 support extracted into a target that matched its reality, it works quite well in practice)

> You should absolutely be XP pair programming with your LLM.

If you want AI slop everywhere, that is.

In some ways, Windows already does that too - the 32-bit syscall wrappers [switch into a 64-bit code segment](https://aktas.github.io/Heavens-Gate) so the 64-bit ntdll copy can call the 64-bit syscall.

> You're starting to feel it absolutely everywhere

Starting to? 30-50% of the HN front page has been consisting of articles about LLMs for months now, to the point that a user script to hide all AI articles vastly improves the experience.

The Netherlands proved you can do bike lanes quite well, not every country has to be a nightmare for life quality like the US aspires to be.

So the point is to use technological advancements only to increase company profit and not pass any on to the actual workers. If a junior costs 1/4 of a senior, they could easily paid more from the 3/4s saved (since they're also more valuable now), but I guess shareholder millions come first.

> 1/4th of their salary

If they + AI are a replacement for senior devs, shouldn't they be paid accordingly?

As the previous commenter said - you don't need a new runtime instance per button, so the comparison doesn't really work (for the smallest binary size, you could provide a native application doing the bare minimum to display the UI too, if the platform has an OS-provided UI framework).

It's still a neat toolkit, since not every website needs a big framework - but comparing runtime sizes is like choosing C over C++ because a `int main() { printf("Hello World\n"); }` binary is smaller.

Fortunately for everyone, the Western world that the comment you replied to was talking about is not just the US.

> There are very limited things you are supposed to do in an APC, but these are poorly documented and need one to think carefully about what is happening when a thread is executing in a stack frame and you interrupt it with this horrorshow.

One must not throw a C++ exception across stack frames that don't participate in C++ stack unwinding, whether it's a Win32 APC, another Win32 callback, a POSIX signal or `qsort` (for the people that believe qsort still has a place in this decade). How the Win32 API is designed is absolutely irrelevant for the bug in this code.

Focusing on the GUI applications: There have been a few GUI automation solutions over the years - since the post's software is from MS, I'll take UI Automation as an example. Works well with Win32 controls, not sure how well it works with the XAML-based toolkits.

But not all software is written with those UI frameworks. Some use different widget frameworks, some immediate GUIs, others just render a webpage and either use HTML or fully render the controls themselves. And without everybody using the same standard, the only standard we have for parsing their output is the pixels they render to.

(Also not the point, C# can be AOT-compiled as well these days)

As the other commenter said, `unreachable!()` panics. You'd need https://doc.rust-lang.org/core/hint/fn.unreachable_unchecked...

> linux for example doesn't have true IO async API

io_uring has been around for a few years at this point, with vulnerabilities having been fixed to the point that it's fit for broadband usage.

Or notepad++ could just use the WinAPI (WideCharToMultiByte) to convert UTF-16 to UTF-8 instead of hand writing their own conversion routine.