infogulch

Yes buffering / dropping on buffer overload is the right frame and the right way to do it in practice. I have seen it done properly. Yes it can cause some social friction but as long as your conversation partner is aware that because you are driving you may buffer/drop conversation packets and they accept that they might have to occasionally exercise patience or repeat themselves then it's fine.

This week I built https://github.com/infogulch/caddy-zone-manager, "A Caddy app that performs desired-state synchronization of DNS records to a target zone using Caddy’s existing libdns DNS-provider ecosystem."

I thought that since caddy is already managing dns records anyway to pass DNS-01 ACME validations and update HTTPS records, wouldn't it be nice if I could just have it manage all of them and keep my desired DNS state checked into git?

This is exactly the duct tape scenario. There are a bunch of systems that bound the problem: Caddy's app lifecycle, the Caddyfile configuration system, libdns interfaces, DNS semantics, the Go language. Sure, there are a lot of little decisions that need to be made that fall into the "taste" category (no promises), and the sync engine itself is a new brand component, but by and large once the idea was formulated the problem domain is narrow enough for an LLM to stitch the systems together.

It was done in about two days of personal time. I read through all the code and rewrote a good portion of it manually. I probably could have written it from scratch myself with two weeks of full time effort (honestly I would have stumbled a bit on DNS recordset semantics which I was not very familiar). Instead it cost me $100. (I will reconsider my LLM usage patterns for the next project...)

In my experience the driving-behavior part of my brain can run virtually autonomously, like how you don't really have to spend 100% of your brain to walk down the street. This means that the words-thinking part of my brain is almost completely free, with the exception of short high-attention spikes for risky maneuvers like onramp merging. This is why listening to music or podcasts is a very popular driving activity. In many places even handsfree phone calls are allowed as long as both hands are available and your vision isn't obstructed.

I would contend that listening to a podcast or being on a handsfree phone call would be on par with the Claw Phone.

Does it use ffmpeg to render inline images to ASCII?

SQLite is remarkably versatile. Just a couple weeks ago an extension to do cross-process queues, streams, pub/sub etc in SQLite was released:

Show HN: Honker – Postgres NOTIFY/LISTEN Semantics for SQLite | 327 points | 94 comments | https://news.ycombinator.com/item?id=47874647

Live notifications was one of the big missing pieces to implement whole apps on a sqlite backend, and now there's a decent solution.

The full quote:

> Gofmt's style is no one's favorite, yet gofmt is everyone's favorite - Rob Pike https://go-proverbs.github.io/#:~:text=Gofmt%27s%20style%20i...

The best part about gofmt is there is no discussion about how to format Go code. The style itself is fine, skipping endless hours of pointless debate is priceless.

AV2 video codec delivers 30% lower bitrate than AV1, final spec due in late 2025 (videocardz.com) | Oct 2025 | 277 points | 223 comments | https://news.ycombinator.com/item?id=45547537

While I agree that it doesn't make much sense to use a minimizer on code the reader could understand, the code-golfed byte count of a CVE repro communicates its complexity in a certain visceral way.

Radicle stores issue & PR data as git objects. This approach interests me because issue data is as important as the code so we should treat it with the same care as the code. I.e. a tamper-proof cryptographic chain, signed objects, distributed redundancy, well-tread management features like synchronization and packfiles, etc.

I'm happy that raw git + mailing lists works great for the linux project, but can the rest of us all agree we actually do need issues & PRs? And that it's super painful to lose all this context when platform hopping, or when the service unilaterally decides to deplatform someone?

So where are we going? Mitchell will be deciding for Ghostty. If github's current trajectory is anything to go by, everyone else will need to decide where to go sooner rather than later.

I'm worried that it will be a Babel scattering event and this open source superpower that github catalyzed (how to describe it?) will just evaporate.

I'm also worried that wherever we go next could have the same fate as github.

So what then? Radicle is the only thing that I've seen that could theoretically 'solve' the problem, though it still needs a lot of work: https://radicle.dev/

133882 / Oct 1st 2009

Maybe one of the reasons why hosted postgres often disallows extensions is due to security concerns from loading arbitrary machine code on a shared host. I wonder if pgrx changes the calculus here.

I've never heard of Wi-Fi Aware, thanks for sharing. Are there any devices/chips that support it today?

Can you do the same thing for websites with playwright/selenium?

Really? That's the opposite of what I understand the docs say.

Care to share your code? This may become a bug report.

I guess the idea is to have all writes go through a central server with local read replicas for improved read perf. The default litestream sync interval is 1s. I bet many use-cases would be satisfied with a few seconds delay for cross-region notifications.

How big is the cache? Could you just evict the cache into cheap object storage and retrieve it when resuming? When the user starts the conversation back up show a "Resuming conversation... ⭕" spinner.

Oh nice it works as an ssh-agent too. Definitely checking this one out.

Yeah the C API seems like a perfect fit for this use-case:

> [SQLITE_FCNTL_DATA_VERSION] is the only mechanism to detect changes that happen either internally or externally and that are associated with a particular attached database.

Another user itt says the stat(2) approach takes less than 1 μs per call on their hardware.

I wonder how these approaches compare across compatibility & performance metrics.

He mentions Litestream, maybe this also works for litestream read-only replicas which may be in completely different locations?

Neat idea!

Would it help if subscriber states were also stored? (read position, queue name, filters, etc) Then instead of waking all subscription threads to do their own N=1 SELECT when stat(2) changes, the polling thread could do Events INNER JOIN Subscribers and only wake the subscribers that match.

Government regulations weren't necessary for Framework to make the most open laptop product line in history which includes a the 'Pro' 13" laptop chassis which is both backwards and forwards compatible with components that were sold 5 years ago on day 1.

You can flash GrapheneOS on a Pixel from another pixel, no pc required at all. I've done it several times, this is what sold me on the utility of WebUSB. You can use GOS' own distribution of chromium, Vanadium, if you have a GOS device and you want to avoid Chrome.

It's interesting that you can remove a future state machine instance for an async function that returns a constant value by just returning impl Future<Output = [return type]> with return std::future::ready(return_value). They even developed a lint[1] to help users find these cases. https://github.com/rust-lang/rust-clippy/pull/16244

Could the compiler not identify this case and perform the transformation automatically?

> how much money out user accounts have in this microsecond

My understanding is that if you want aggregations or sub accounts then you need to duplicate transactions and maintain them yourself. This may seem like it would be annoying, but I suspect it would mostly be a matter of code organization.

I expect typical TigerBeetle (TB) clients will develop and maintain an application-level library that builds up a set of TB transactions that encode each business-level transaction. For example, if a "business transaction" is "marking a purchase order as received", the corresponding set of TB transactions might include: 1. moving the received qty from the pending receipt qty account to the inventory qty account for the received line items, 2. adding the total cost to the inventory value account for this item, 3. adding the price to the Accounts Payable (AP) account for this vendor, 4. adding the shipping price to the AP account for the delivery company, etc. But then you might want some aggregations, so you'd do the same thing again and add the price to the "total inventory value" and "total accounts payable" accounts, etc.

In fact you might want 3, 4 or even more parallel ledgers at different levels of aggregation, which could all be maintained within the application library. I wonder if there's a name for this technique. My only concern is that if you break down your business transaction into fine grained detail like this and then duplicate it with multiple aggregations then that 8000 transaction limit starts looking a lot smaller.

Well it says "indirectly". How much indirect do they mean?

I remember coming across egg ( https://egraphs-good.github.io/ ) via some virtual conference a few years ago. I'm happy to see this idea land in a real compiler!

Another interesting tree filesystem data structure is the Bε-tree ("b epsilon tree"), which also tries to bridge the gap between small writes and the large pages of modern drives. The first paper/talk from 2015 has a fun name "BetrFS: A Right-Optimized Write-Optimized File System" and they published a few dozen times until 2022. https://www.betrfs.org/

I found out the hard way that backblaze just deletes backed up data from external hard drives that haven't been connected in a while. I had like 2TB total.

How about webusb?