It's not.

You are correct. I apologize. I seemed to have read the next pragma’s depreciation notice!

Aside from this - SQLite has tons of cool features, like the session extension.

Yep, definitely still in use. Do yall above have an opinion if the pragma is better than the syscall? What are the trade offs there? Another comment thread mentioned this as well and pointed to io uring. I was thinking that dism spam is worse than syscall spam.

Depends on what to mean by better.

I may be wrong, but I think you wrote somewhere that you're looking at the WAL size increasing to know if something was committed. Well, the WAL can be truncated, what then? Or even, however unlikely, it could be truncated, then a transaction comes and appends just enough to it to make it the same size.

If SQLite has an API it guarantees can notify you of changes, that seems better, in the sense that you're passing responsibility along to the experts. It should also work with rollback mode, another advantage. And I don't think wakes you up if a large transaction rolls back (a transaction can hit the WAL and never commit).

That said, I'm not sure what's lighter on average. For a WAL mode database, I will say that something that has knowledge of the WAL index could potentially be cheaper? That file is mmapped. The syscalls involved are file locks, if any.

Interesting, thank you for the response and explanation. Honker workers/listerners are holding an open connection anyway. I do trust SQLite guarantees more than cross-platform sys behavior. I will explore the C API angle.

What do you think is missing? I'm a big SQL fan and the idea of direct SQL to X seems appealing at least on the surface.

Probably the biggest issue is that it's primarily useful in the context of exploratory analysis and makes iteration on a plot much slower, requiring you to re-run the query to get a new viz. Iterating on a viz is best done with the data cached locally or elsewhere.

In the context of a query used for a dashboard in prod, you're likely using a different viz environment so it's not useful at all there.

What’s interesting here is that with AI, all our interfaces should evolve away from previous generation rigid forms / buttons / tables etc. towards something more fluid / dynamic / “natural”. Yet all the AI coding is geared towards producing more of the former.

Do you have examples of "natural" UI that you like?

Most of the software we interact with is at the end of the day some db tables, queries to read/write, and some ui to read/write. There have been so many times I wished I could just do my own db joins on the underlying db to get the views I wanted. But I can’t - because the app has pre-defined ui/query paths.

With AI, I should be able to ask for things the product designers didn’t anticipate or left out and the system could query, create ui on the fly, etc…

Mind-reading brain implants. That's what he wants.

i think of them as tiers of expertise— need to master the basics of structure and form before the robot has the learned representations to competently model user interactions with more fluid instantiations (by downprojecting into the overlearned fixed-semantics)

Why would a remix engine move away from what it was trained on?

Why would we want to move away from hard fought UX design lessons? Dynamic and fluid UX is infuriating.

I did the EBC trek last year and at ~4400 meters, we heard about a local Nepalese woman dying from complications of AMS in the local clinic. There might be fishy things going on with the rescues, but the health risks are real.

Related, I’d love an editor that’d let me view/edit identifier names in snake_case and save them as camelCase on disk. If anyone knows of such a thing - please let me know!

This is actually possible with glasses-mode in Emacs: https://codelearn.me/2025/02/24/emacs-glasses-mode.html

I think it sees very little usage though.

Sure. Presumably you could have localized source presentation, too.

But, yeah, I think a personalized development environment with all of your preferences preserved and that don't interfere with whatever the upstream standard is would be a nice upgrade.

Could you share some samples / pointers on how you do this?

Yeah, this upsert_cell tool does it

https://observablehq.com/@tomlarkworthy/forking-agent#upsert...

format: { type: "grammar", syntax: "regex", definition: cellsRegex },

Where cellRegex is

cellsRegex = { const CELL_OPEN = String.raw`<cell>\s`;

  const INPUTS_BLOCK = String.raw`<inputs>.*<\/inputs>\s*`;

  const CODE_BLOCK = String.raw`<code><!\[CDATA\[[\s\S]*\]\]>\s*<\/code>\s*`;

  const CELL_CLOSE = String.raw`<\/cell>`;

  return "^(" + CELL_OPEN + INPUTS_BLOCK + CODE_BLOCK + CELL_CLOSE + ")*$";

}

And the extraction logic is here https://observablehq.com/@tomlarkworthy/robocoop-2#process

function process(content) { const doc = domParser.parseFromString( "<response>" + content + "</response>", "text/xml" ); const cells = [...doc.querySelectorAll("cell")]; return cells.map((cell) => { const inputsContent = cell.querySelector("inputs")?.textContent || ""; return { inputs: inputsContent.length > 0 ? inputsContent.split(",").map((s) => s.trim()) : [], code: (cell.querySelector("code")?.textContent || "").trim() }; }); }

BTW that agent is under development and not actually that good at programming. Its parent https://observablehq.com/@tomlarkworthy/robocoop-2 is actually very good at notebook programming

They launched March 2025. It’s great that’s considered a long time ago.

Does anyone actually compute / use this key feature? Or do you rely on implicit caching? I wish HN had a comment with a poll feature.

It would be important to use for relatively high traffic use cases

Let's say you have a chatbot with hundreds of active users, their requests could get routed to different machines which would mean the implicit caching wouldn't work

If you set the cache key to a user id then it would be more likely each user's chat could get cached on subsequent requests

Google Maps or any other aggregator has an inherent interest in market participant diversity. A lot of suppliers would mean competition, which results in ad spend, which result in higher revenue for the aggregator. Same with Google Search.

It's an interesting equilibrium point. They want local businesses to suffer enough to pay up for ads. But also not too much that they die. A good local business that does not need to advertise because it is simply good is actually a burden to the aggregator even though it is exactly what the end users want to see.

In the past, when I was a in position to build a search engine, we took the trouble of always including organically ranked results that were genuinely good, regardless of whether we got paid or not. I felt it was a long term investment into creating real value for our end users and therefore our service.

25 years ago Perl allowed you to express what was in your head 10x more concisely as in other mainstream language (which have since caught up with some of the features).

This was not the best when it came to others (or even yourself 6 months later) reading the code. But it was great for cranking stuff out that was simply too tedious in other languages.