eximius

Who is this article for? I don't disagree with it, but manufacturers aren't somehow unaware of any of it. They don't want to manufacture dumb TVs. They're the ones _currently_ manufacturing smart TVs.

Plus, there is the problem that the vast majority of consumers want smart TVs due to a combination of subsidized lower price and "simplicity" (e.g., they may be worse but they are simpler)

I don't think anyone is advocating xenophobia towards _Russians_. However, skepticism towards stances known to be propagated by the _Russian government psyops groups_ meant to destabilize... well, just about anything they can... sure.

This complaint and thinking of other simple but sliiiightly more advanced permission/privacy systems reminds me of G+ circles - kinda wish it'd have taken off. I thought it was a pretty neat system.

This is basically the outcome of not having fulfilled this: https://ntietz.com/blog/rust-needs-a-web-framework-for-lazy-...

I am unapologetic about despising Ruby - Rails is pretty darn good, though. The Rails and Djangos of the programming worlds are critical for many teams that shouldn't be building their own frameworks from scratch (for any number of reasons).

Attempts are being made (https://loco.rs/) and time will tell if Rust can put together a compelling story for this use case.

Sounds like "unlearning" is really just "reduce the probability of sampling" from some latent "learned space" and quantizing reduces the efficacy of the slight change in sampling.

What is the difference between the normal and pro? I can't find any meaningful difference on the product pages.

Anyone gotten them working with Linux or some kind on android VM/container?

It doesn't seem likely that the military has a private model that is dramatically better. If we did, it would likely be exposed in a way similar to GPS.

Damned if you do, damned if you don't.

Is this satire? It has to be, right?

If I need to do compile-time pre-computation, I'd probably do it using "code generation" using something like this: https://github.com/linzhp/codegen_example/tree/master

* integrated into bazel rather than go-compiler-hacking * your "normal" code just imports the result - which can be go-to-definition-ed to see the generated code

Hmmm that was an autocorrect I hadn't noticed. Thanks for the correction!

My understanding was that it was on its way for true AR, just with limited display capabilities. e.g., if I only wanted augmented information, monochrome is just fine.

I don't really need to be able to play pong badly to consider it AR.

Still feels like Intel Vault was the best iteration of AR. I desperately wish someone would pick that back up.

Every time this sentiment comes up I'm reminded that it's a spectrum.

Hm, sounds like the recent rent fixing collusion. Which was ruled illegal.

Well, yes. Or by having stacked branches and rebasing your branches, etc.

The point is that GitHub/git's default experience makes this harder to do than a system that bakes it in.

> If Ford starts snooping on our in-car conversations and injecting ads into our Spotify streams, we can just refuse to buy Fords.

If Ford does this, every other car company will find ways to license or come up with competing patents then do the same.

There is every incentive for informal collusion here and regulatory bodies are meant to express public sentiment that things like this are something that we, as a society, do not want.

Why on earth would a startup's code not be reviewable?

If I'm doing a big chunk of work, I still do it in small PRs. That first PR (or a design doc) might outline a strategy for the ones that follow, but still try to have small PRs. Or, worst case, I do a big chunk of work and break it out into small logical chunks for review.

And even startups can have deadlines.

While there is a certain exciting aspect to this in the same vein as any cyberpunk dystopia might have, it also sounds exceedingly wasteful.

The security properties are interesting but largely overshadowed by economic forces. Things become centralized because they're cheaper and easier for users.

If this system existed, it would have to have _such a good user experience_ to overcome its many inefficiencies.

Because the vast majority of new works are not done by one of the few who would be qualified to check it.

You can think of the cryptography community as similar to the math community. If some nobody makes a new proof of a big conjecture, it is considered with skepticism until some big name comes around to verify it. If Terence Tao comes out with a new proof in one of his specialities, people are going to assume it's basically correct or will have only very minor errors that are easily fixed.

Uninformed response: if two different universal approximators can have different modes/rates of learning, then even if they're usable in theory, they could be less good in practice.

They're spending their money on development, just really irresponsibly.

Yes, but a _significant_ portion of those are marketing. If you look only at development costs, nothing comes close to Star Citizen.

Feels like the theatre of war where opsec literally means life or death to yourself, you'd be willing to leave your device at base or faraday it or something.

In most languages, you don't need to be an expert to use it.

In Ruby/Rails, your entire team has to be an expert at it or you'll struggle. Even then, you can struggle with some spooky action at a distance idioms.

It is such a draining experience.

And I recognize that it doesn't have to be that way. But Ruby enthusiasts should recognize that it is common enough to have earned that reputation.

What 'leftist ideas' collapse?

Does anyone know how to find good solar contractors? Every time I seem to search for professionals I find a bunch of blogs about superficial details about solar installations instead of someone to actually install a system.

My experience is that there is a great, big in-between where folks are just chugging along and aren't thinking about project/codebase level architectural decisions. Without that active thought and foresight, you end up shooting yourselves in the foot, a bit. With DI frameworks, the _default_ ends up typically being the right thing to do so it unburdens people from a particular slice of cognitive load.

code generation is a mostly disjoint topic from DI. Granted, some solutions like https://github.com/google/wire use code generation, but you're exactly right about their pitfalls. If your dev environment doesn't have good support for generated code, it is a nightmare. If you can goto-definition the generated code, then it is suddenly feasible, but perhaps still a bad choice.

But the DI frameworks I've used are typically just... normal code files. Uber/fx, Go/Guice, etc

No traits, const generics, probably no turbofish equivalent for when inference struggles.

I've never really had that trouble. There are typically relatively few places that

1. a given interface is provided via a DI module 2. said modules are included in a binary

With decent codesearch, finding the implementation of a particular injection for a given deployed binary is usually a fairly short search.

I'm sure there is all sorts of extra voodoo you can get up to, but the straightforward DI case is, well, straightforward.