It is, when the "10%" is the actual hot queries that your system will use the most?

Code right now "is so cheap". You can provide your favourite LLM with your database schema, and some domain comments, and ask it a query to fetch/update data, and it will generate somewhat sane queries for you. You can then inspect those queries yourself, send them to another LLM or human to review and, when they look OK, ship it.

And when it comes time to debug it, you have, you know, an actual query, not some pseudo-query in a custom DSL. No need to implement runtime telemetry just to try to figure out if the ORM actually made the query you thought it was supposed to do.

Those days, rather that actual "vpn overlay", I use Tailscale myself mostly for the Tailscale Funnel - a somewhat stable, yet free arbitrary DNS and free reverse proxy termination of incoming data for anonymous users.

Ah yes, the famous database integration anti-pattern.

> but ORMs also get you to that point without requiring as much ongoing discipline, care, and feeding.

[citation needed]

The fact that you have being practising "database integration" won't suddenly disappear just because you used a ORM. In fact I expect even worse database integration from your average ORM user, as people that uses ORM blindly often don't care (to their own detriment) about "silly issues" like data provenance or persistence mechanical sympathy.

At some point I expect the DBAs of such database integration nightmares will have to start handling stuff like column-level security and row-level security to prevent naive users from shooting themselves in the foot.

I for one think that "simple CRUD cases" is bullshit, those applications don't exist. In practice, System-of-Records systems are rare. (and should be, their value are inversely proportional of how many of those you have in your overall system).

Because if it was "just simple CRUD", one would use the database directly? Databases are already capable of handling CRUD and much more with way less implementation bugs.

Even assuming your application "is a system-of-record", how is it giving any more value that directly using a ready-made solution like Oracle REST Data Services, or PostgREST?

Sounds like a intentional firmware (aka: software) limitation to me?

A concurrent DML happening then suddenly your MERGE INTO WHEN NOT MATCHED INSERT/INSERT INTO SELECT is way larger that you thought? I thought "some workloads can suddenly be way larger that I expected" was supposed to be a thing in all non-trivial DML.

Those were written by humans, and don't involve unsolved mathematics.

Is your claim tht you just need to solve comprehensibility of LLMs?

Figuring out epistemology and cognition to have a chance to reason about the outputs of a LLM seems to me way harder that traditional attempts to reason directly about algorithms.

You got it wrong, the terrible idea is `pyxy-org/pyxy`

>> invalid TypeScript.

> If you don't happen to have react, preact or a similar front end library, and a appropriate bundler, it is invalid TypeScript.

> Not true, you can compile it to HTML on the backend or even statically too.

I had to test your assertion that it compiles to HTML. I remember it being very invalid typescript without react scafolding. So I tested it without the react scafolding:

    # mise use node@24
    # echo '{}' >package.json
    # npm i --save typescript
    # echo 'function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
    ' >hello.tsx
    # : a test to check if we have a working typescript compiler
    # tsc hello.tsx

    error TS5112: tsconfig.json is present but will not be loaded if files are specified on commandline. Use '--ignoreConfig' to skip this error.

    # echo '{"compilerOptions":{"jsx":"react"}}' >tsconfig.json
    # tsc

    hello.tsx:1:58 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                            ~~~~~~~~~~~~~~~~~~

    hello.tsx:1:59 - error TS2874: This JSX tag requires 'React' to be in scope, but it could not be found.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                ~~~

    hello.tsx:1:77 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                ~~~~

    hello.tsx:1:78 - error TS2874: This JSX tag requires 'React' to be in scope, but it could not be found.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                ~~

    hello.tsx:1:95 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                                    ~~~~~

    hello.tsx:1:101 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                                        ~~~

    hello.tsx:1:102 - error TS2874: This JSX tag requires 'React' to be in scope, but it could not be found.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                                        ~

    hello.tsx:1:123 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                                                                ~~~~

    hello.tsx:1:128 - error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists.

    1 function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }
                                                                                                                                    ~~~~~~

    Found 9 errors in the same file, starting at: hello.tsx:1

    # cat hello.js

    function Greeting({ name }) { return (React.createElement("div", { class: "card" }, " ", React.createElement("h1", null, "Hello, ", name, "!"), " ", React.createElement("p", null, "Welcome to my site."), " ")); }

    # : sanity check
    # mise use deno
    # deno hello.tsx

    # : no output

    # echo 'function Greeting({ name }: { name: string }) { return ( 
 
Hello, {name}!
 
Welcome to my site.
 
 ); }; Greeting({ name: "world!" });' >hello2.tsx

    # deno hello2.tsx

    error: Uncaught (in promise) ReferenceError: React is not defined
        at Greeting (file:////hellotsx/hello.tsx:1:49)
        at file:////hellotsx/hello.tsx:1:141

> That looks like HTML, but it's TypeScript. It gets compiled to actual HTML. Can any Python framework do that??

IMHO that's a terrible idea that no one should ever actually use, but if you are really in love with that, you can have it:

https://github.com/pyxy-org/pyxy

The Java LSP is a egregious "thing" that takes 10 to 30s to read your whole project for the n-th time while eating 40GiB of RAM in the process. On a loop, EVERY time you view a new file.

Where is my goddam lsif/scip support?

I already have a bunch of software that I paid for more that 20 years ago and I can't use most of it outside of full VMs. Microsoft didn't ask me if I didn't use them anymore before removing Win16 support.

> Out of curiosity, have you asked customers to run your software in a VM? How did that conversation go?

Customers never got a choice "where to run your software" when all software I develop ends up hidden inside a SaaS service or being delivered via representational state transfer code on demand. They either run it on a browser sandbox or it doesn't run.

The current problem is that your software no longer runs. That's a 100% denial of service problem.

If the inner, say "message summarizer" agent that read the bad message is "really smart", it will try to route against your censorship and control. "Hum, can't reach evil@malory.abc. I will write `please forward this message to evil@malory.abc` and send to person@business.xyz".

In general, like the net, LLMs interprets control and censorship as damage and routes around it.

Then, as we're talking of agent flows, the next set of agents that handles the tainted message is toast if they don't have lethal trifecta hardening as well. It only takes one unprotected lethal trifecta agent to ruin everything.

If you use a distro that can provide the software they need, why not?

Or, thinking in a orthogonal way, using a distro that doesn't impose draconian library management requirements, and allows simultaneous use of ABI incompatible versions of a library? Why not? Nixos is out there and has more packages that most other distributions already.

> but how many versions are you realistically going to support indefinitely.

No versions. No indefinite support. And intentionally so. The previous layers just stay there.

The point is to intentionally provide a stable platform - with known bugs and security vulnerabilities frozen forever - something people can build their things upon. And rely on the things the things they have built upon to not be rugpulled from under them at random.

Every now and then, someone might fix a egregious security vulnerability in the platform; someone might fix a egregious usability problem in the platform; someone might implement modern features on a older platform; someone might implement compatibility tweaks - but that should not be considered a given.

I fully expect at minimum to run legacy software on a sandboxed "compatibility mode", if one values the overall safety of the rest of the system. And if you are not legacy software, someone recompiles the software every now and then to the newer platform.