selkin

If they don't care, why should you?

They found a deal that seems to be ok for them. To get them to change providers, you need to suggest one that would be a better value, and to be honest, I don't think you can find one.

Tell me you haven't run a large email server without telling me.

There's a reason even large corporates that can easily afford the resources to run email their email themselves decide against it.

There are a handful of good providers, not just Google and Microsoft, but the two hyperscalers do have very good offerings, so of course they have a lot of the market.

Even when they don't, it doesn't matter. Email wasn't designed for privacy or security, and can't accommodate those. Lucky for us, we now have much better tools for those use cases, so we don't need to clumsily try and fail to ducktape those use cases to email.

It can be summarized that the romanticized ideal of Email is long gone, if it ever existed. Today email is a way for others, mostly automations, to send you notifications.

Once you realize this, the "just keep whatever I have right now" is often the best solution.

> The problem with email is that everything is transmitted in plain text.

That's not a Gmail problem, and no reason to migrate. Some use cases just don't fit email, and for those, we have other, more fitting platforms.

> So, I went with mailbox.org that still offers integrated PGP encryption, and if you want, you can always use external PGP too (which I was already doing with Gmail).

Ok, so now you have two problems.

You don't need his level of skill to open a car door (you attack the latching mechanism, not the barrel itself).

It's not ease, it's efficiency: opening a locked car door is 1-2 minutes for an experienced person. Smashing the window is 2 seconds (though you also need some experience, as modern car side windows are also laminated).

Being outside the US doesn’t shield you from it.

And worse, it is harder for the American government to eavesdrop on US soil than it is outside America.

Of course, if a national spying apparatus is after you, regardless of the nation, pretty good chance jurisdiction doesn’t matter.

Your ideas on nationality are 200+ years out of date.

Yet shoving and pushing you into the modern world isn’t something for randos on the internet to do, but on yourself. Good luck!

You must’ve slept through both civics and history classes.

The 14th amendment to the US constitution grants unconditional (and thus, irrevocable) citizenship jos soli.

Naturalization indeed is mandated by the nationality law and not the constitution, yet it ain’t a courtesy. There’s a list of requirements, which once fulfilled mandate the US to grant a person a citizenship.

As for revoking US citizenship, this just not a thing: a person can rescind their own citizenship, but this requires a deliberate action from the person rescinding it. And naturalization can be deemed void, which is not the same as revoked, as it requires a failure in the granting, not a decision after it.

Furthermore, the UN declaration of human rights (ratified by the US, and drafted by one Eleanor Roosevelt), mandates that “No one shall be arbitrarily deprived of his nationality nor denied the right to change his nationality".

So no, it ain’t courtesy. It’s a universal right, that is ratified in the US constitution, US nationality law, and multiple court decisions.

As for Emma Lazarus, she died in 1887, thirty three years before the US constitution was amended to stop denying voting rights from women.

Emma Lazarus would beg to differ.

H1B is also for fashion models, which AFAIK, do not need their employer to prove they can not hire an American person for the role before being granted permission to hire a temporary foreign employee.

Modern keyfobs keep listening and transmitting all the time, as you no longer need to push a button. Just get close enough to the car and it opens.

Only this isn’t a submarine, as it operates at surface and doesn’t dive. This is semi-submersible. When built right, it’s hard to detect from a boat.

I guess the goal of automation here is like it always is: remove the cost of human labor.

It seems to work on macOS 15 as well, with some limitations[0].

[0] https://github.com/apple/container/blob/main/docs/technical-...

It looks like nothing here is new: we have all the building blocks already. What Apple done is packaged it all nicely, which is nothing to discount: there's a reason people buy managed services over just raw metal for hosting their services, and having a batteries included development environment is worth a premium over the need to assemble it on your own.

Podman Desktop, and probably other Linux-containers on macOS tools, can already create multiple VMs, each hosting a subset of the containers you run on your Mac.

What seems to be different here, is that a VM per each container is the default, if not only, configuration. And that instead of mapping ports to containers (which was always a mistake in my opinion), it creates an externally routed interface per machine, similar to how it would work if you'd use macvlan as your network driver in Docker.

Both of those defaults should remove some sharp edges from the current Linux-containers on macOS workflows.

This doesn't look like WSL1. They're not running Linux syscalls to the macOS kernel, but running Linux in a VM, more like the WSL2[0] approach.

[0] https://devblogs.microsoft.com/commandline/announcing-wsl-2/...

There were many more than four in total. Right now they have more then four (there are completely separate messaging apps hidden inside Docs and Maps).

It is easy to confuse them all, considering those apps got renamed often. By my count, there were four different apps called Hangouts (!), some existing at the same time:

(1) The original Google Hangouts, which replaced Google Talk.

(2) Google+ Hangouts, which was video only. Google+ also had a text messaging app called Huddle.

(3) Google Hangouts Meet, a video chat aimed mostly at the workplace. By the time it was launched Google+ was dead and buried. The “hangouts” was later dropped, making it just “Google Meet”.

(4) Google Hangouts Chat, the equivalent text chat device. They also dropped the word “hangout” from the name, but it was launched as “Hangouts”.

It's exactly the same reason: gram referenced a known quantity. Changing it by a few insignificant digits because of the kilogram update wouldn't force people to realign their perception of it.

Changing it to ~1,000 times what it used to be, or giving it a new name, would force people to realign.

There's reason many people still prefer customary and imperial units, and it's not just bigotry and nationalism (even if they play a part in that preference).

For the same reason it was not renamed "Wug".

> Good concurrency should make the code simpler to understand and reason about as it grows.

As an ideal.

But you can only go so simple once you have a piece of data that is read at the same time by many, while also maybe mutated by at least one. And as simple you can get version 1.0, as software grow, it gets new features which necessitate more interactions with that data, which makes synchronization more complex.

I think I wasn't clear about the point I was trying to make, because your comment seems unrelated to it.

Pre-metrification there wasn't a French unit system, like we think about those today, where a meter in Paris is the same meter used in Limoges. The actual length of a ligne changed from one region to the next. There was no country wide standard of exactly how much a certain unit is. Such standards were regional, at best, sometimes the regions being as small as a single village.

This is one of the most important results of the French resolution: a consistent system of measurements, regardless of the units chosen for it.

It’s an historical artifact, as it was easier to manufacture a reference kilogram than a reference gram.

Considering today we set the kilogram by fixing the Planck constant and deriving it from there, we can just divide each side of the definition by 1000 and use that as a base unit. Using kg as the base unit is completely arbitrary, as we can derive each unit of weight directly from the meter and the second, not from the base unit.

The pre-metric measurements in France weren’t imperial, but local: units had the same name, but different cities defined them differently. A livre[0] in one village was almost, but not quite, the livre used by the one only a couple toise[1] away.

[0] about a modern pound, depending where you were. Toulouse’s livre was almost 1.3 modern pounds, for example.

[1] about 13853/27000 meter.

“The Measure of All Things” by Ken Adler[0] is a good, extremely readable book about their adventure, which was indeed wild.

[0] https://en.wikipedia.org/wiki/Special:BookSources/978-0-349-...

> Initially, I avoided Swift because of my previous experience with it […] without native async/await at that time, writing concurrent code compared to Go or JS/TS felt clunky and boilerplate-heavy.

I have to disagree. Async may makes concurrent code easier to write, but also less simple to reason about as it grows. In a complex async codebase, I find it harder to reason about code flow and concurrency.

If the goal is to reduce the cost of executing threaded code, we have a solution in green light weight threads.

If we aim to reduce the cost of maintaining threaded code, I expect async to end up costing more effort in the long run.

s/they’d let/would have let/

According to a recent interview[0], the president has an uncontrolled phone (maybe in addition to other, approved devices).

[0] https://archive.ph/2025.05.07-050707/https://www.theatlantic...

Last year Shopify was named as a customer[0], which I found both surprising and not.

[0] https://blocksandfiles.com/2024/07/04/oxide-ships-first-clou...

Final is an access modifier. It controls who can change a value (in this case, no one). And like other access modifiers, you can use reflection to remove or change those modifier. It is a security barrier the developer asks the system to uphold.

The Stable annotation is an optimization mechanism: a promise the developer makes to the compiler. It is on the developer to uphold.