jallmann

git : github :: wireguard : tailscale

> I believe the poster was referring to requests from the client to the server having to traverse the HTTP stack, not data coming down from the server via the SSE stream.

Ah that's probably correct, I mis-read.

Sure, but SSE connections in the browser - the typical use case - are persistent, so there shouldn't be frequent re-connecting.

Unlike WebSockets, browser SSE also has a built-in recovery mechanism so you don't miss events across reconnects (`Last-Event-ID` header), although this does require explicit support from the server-side app.

Given that the WebSocket handshake has an additional round-trip, SSE would typically be faster in terms of time-to-first-byte.

> you’re still travelling through an entire HTTP stack implementation rather than the incredibly simple WebSocket protocol

Both protocols have their own minimal framing, but "an entire HTTP stack" is a stretch. It's hard to argue that `data:value\n\n` is more complex than the WebSocket binary protocol. Simplistic, sure (no binary payloads), but also simple enough to, say, pipe through a regex. Good luck doing that with WebSocket.

> I find that if you put a decent bit of engineering effort into that "disaster recovery" synchronisation, it can often act as the main or only synchronisation process for quite a lot of systems.

Another benefit is that you get to exercise those disaster recovery mechanisms regularly as part of the normal functioning of the system, rather than a specialized path that is only rarely exercised (and thus may be broken when you need it the most).

A while ago, I noticed some very small oscillations in my Cloudflare R2 bill (1-2 cents / month) and decided to ask about it out of curiosity. Support was tepid - understandable for my $1 / month account - and it wasn't until later that I realized the difference probably had to do with the number of days in the month.

Would this API have helped?

Depending on the error, the grammar, and the parser, it may not be possible to close the function body. Most compilation units are file-based for this reason.

That leads to the cross-device usability issues from the original post. Even for an experienced engineer, it's a headache to manage multiple devices across multiple sites.

With the "cloud password manager" angle there is some hope of being user friendly, although we're certainly not there yet for most folks.

I thought the same, too. Generally some small amount of inflation is preferable to encourage spending, rather than deflation which discourages it.

If you know a $100 item will probably cost $102 later then you're more likely to buy it now. But if that item will cost $98 in a deflationary environment, then maybe you'll wait to buy it later. Wages also tend to fall in deflation, which makes it harder to pay back debt, so lending slows down - people won't buy houses or cars, etc. Businesses hold back on capital spending. The economy slows to a standstill: if no one is spending money, how can anyone make money?

Which translations would you recommend for Crime and Punishment or Dostoyevsky in general?

When I'm starting to read a non-English novel, the process of deciding which translation to use is half the fun. The Kent and Berbera (revised Garnett) version of Anna Karenina was mesmerizing.

Agreed it's a bummer.

There's a lot of low-density sprawl in San Diego county which makes effective transit difficult, and because you have to drive everywhere, sentiment trends anti-bicycle. The previous CEO of SANDAG tried to push a mobility-centric vision but left because of intense pushback from folks who wanted more funding for roads and freeways, rather than transit and bike paths.

The accepted norm is, increasingly, full disk access, regardless of how bad of an idea it is. At a minimum, agents typically will have a way of obtaining new access tokens.

Refresh tokens don't solve anything in this case; they just shuffle the problem around, and introduce other complications of their own.

What you want are capability scoped credentials that are enforced on the backend. That is agnostic to credential issuance mechanism, although passkeys are the best.

Using these credentials effectively still presupposes hygiene that might not exist in a typical developer environment, eg no root credentials (or access to such) sitting anywhere. There's probably a good product and market for whoever can solve this in a low-friction way.

> OAuth with refresh tokens.

Then the LLM slurps up your refresh token. What's next?