petmon

Why? Did Fuschia enable any new features on Google Home Hubs which would have been more difficult/impossible with a Linux kernel? It's an honest question, my bias is that Fuschia is a solution in search of a problem but I am happy to be convinced otherwise.

Imagine if what were Trump? Per the article, the Trump administration sought "help from the tech companies to combat misinformation."

China has already banned Google which is of a similar scale and impact.

Apple in many cases goes out of their way to avoid collecting your data. See Maps for example. Users' usage of Maps is associated with a random rotating identifier not tied to their accounts. This is quite different from Google Maps.

https://www.apple.com/legal/privacy/data/en/apple-maps/

How would you handle clicks and stuff?

Is the neutron similarly complicated?

> historically they have never told my spouse about my affair

Have we forgotten Google Buzz? Google changed GMail to publicly list the people you email most. In one case, this de-anonymized a woman's blog and enabled her abusive ex-husband to stalk her. https://fugitivus.wordpress.com/2010/02/11/fuck-you-google/

This is IMO the most likely way that "bad stuff" will happen: not maliciously, but through privacy-invading misfeatures connected to pushing people to share more.

It's of note that Trump wanted to reduce the SPR by half. The plan was rebuffed by Congress. https://www.cnbc.com/2017/05/24/trumps-strategic-oil-reserve...

It's common in other programming languages for string literals to have type string. It's weird and confusing that they do not in both Rust and in C++.

I think you DO have to know about those, or close analogs, in writing Rust. I like both C++ and Rust but I will rise to defend C++.

1. Exception safety becomes "catch_unwind." You might object that nobody cares about that, but major C++ codebases (Google, LLVM, Mozilla) don't care about exceptions; they are built with -fno-exceptions.

2. Move semantics in C++ are annoying, and so is the borrow checker. In Rust you get hit by things like "this code is fine here, but you aren't allowed to refactor it into a function" because there's no interprocedrural visibility into struct fields.

3. Meta-template higgery-jiggery is real and bad in C++, but has a mirror in Rust. With C++ duck-typed generics you write dumb code that does the thing, and then you can refine it with hilariously awful techniques like SFINAE. In Rust you're googling higher-ranked trait bounds before you can even write the thing. What does `for` do again? I think "strongly-typed language, duck-typed generics" is a bit of a sweet spot and C++ has lucked its way into it.

4. "30 years of cruft" means things like "I speak C preprocessor" which is practical. C compat is why C++ is both so awkward and so successful. There's no smooth ramp from C++ to Rust, the way there was from C to C++; that's a choice and maybe the right choice but it has a price.

Rust's "feature surface area" reaches or exceeds that of C++ through procedural macros, which surfaces the entire Rust AST to the developer. Major Rust crates like serde use this feature, and when it goes wrong the errors are actively misleading. I've personaly been bitten by this, it's incredibly frustrating to debug. https://serde.rs/derive.html#troubleshooting

It's about personal taste: some people want no ketchup on a burger, others only a little, some want a lot. Separate ketchup gives the customer that choice.

Those little ketchup packs get thrown out a lot. The bottled stuff tastes better anyways.

The C++ stdlib (aka STL) is 100% usable without exceptions. This is deliberate: major players and code bases disable exceptions, including Google, LLVM, Firefox, so it has to work and work well. And disabling exceptions is easy, simply pass `-fno-exceptions` to the compiler.

Fallible C++ functions do return an error code. errno is part of C++.

https://en.cppreference.com/w/cpp/error/errno

The chief perceived benefit of Bitcoin is its speculative asset value. We may try to unseat this with a new, less environmentally harmful speculative asset, but it's unethical to deliberately attempt to suck people into a negative-sum scheme, plus it won't work: crypto coins move in tandem with each other.

How does Go handle allocation failure? In my understanding objects may be allocated on the stack or heap per the compiler's whims. If a heap allocation fails, you just get "fatal error: runtime: out of memory" and an abort.

The case for particles is quantization. We've never seen half a photon or half an electron. This dates back to the ultraviolet catastrophe. If it was all about waves that would be easy; we reluctantly acknowledge particles because Nature has forced us to.

Yes Chrome installers install themselves. Chrome is bundled with installers for unrelated products, and you have to deliberately uncheck it to not install it. Example:

https://www.reddit.com/r/antivirus/comments/on99mk/avg_antiv...

Microsoft got in legal trouble for coercing OEMs like Dell to ship IE. The OEMs, not Microsoft, should decide what ships on their own hardware. Here Apple is the OEM and is being coerced.

It is possible to allocate every object in its own page. In practice this is useful as a debugging tool but far too expensive for day-to-day operation.

A few years back we had this same discussion orbiting around Service Workers. Here's a post from 2017 where the top comment argues that what's holding back the web is the lack of Service Workers in Safari: https://news.ycombinator.com/item?id=14489577

Apple shipped Service Workers in WebKit in 2021. Are web apps much better now than in 2017? Frankly it seems about the same. The best web apps are still exercises in minimalism like Wordle, which don't need Service Workers or Web Push.

The cost of a bitcoin transaction is not adequately captured by transaction fees. There's two alternative ways to look at it:

1. Divide miner revenue (fees + seignorage) by the number of transactions, yielding the total amount that miners extract. It was $34m today, with ~261k transactions, yielding a cost per transaction of $130. [1]

2. Estimate energy cost at 1,173 kWh per transaction [2]. If you assume cheap electricity at say $.09/kWh you get a cost of $105 per transaction in electricity alone, which ignores hardware capital costs, etc.

Either way the cost is over $100 per transaction, and would be reflected in a falling value of BTC. But it may be masked if there's an influx of new money into the system.

1: https://ycharts.com/indicators/bitcoin_miners_revenue_per_da...

2: https://fortune.com/2021/10/26/bitcoin-electricity-consumpti...

We have several single photon sources, including nitrogen vacancy centers and quantum dots. Nobody has ever produced a "half-photon source" though.

"A Perl regexp, sure." is not part of the grammar of English because it lacks a verb.

But iOS has supported basic PWAs for years.

Chrome achieved desktop dominance in part by Google paying for it to be bundled with Flash, graphics drivers, and other popular software. It also got banners on google.com, gmail, etc. It's not some pure organic "user choice" growth story and Google would presumably re-use those same tactics given the opportunity.

Are you affiliated with this site? If so, please make a post introducing yourself.

For the same reason that developers build iOS-exclusive apps all the time.

The MS antitrust ruling was that MS can license Windows to Dell, but Dell ultimately gets to configure the OS for their own customers, including replacing the web browser. This doesn't apply easily to Apple who does not license their OS: Apple is both MS and Dell in this analogy.

It applies to Google through Android. Amazon sells a Fire TV, which uses AOSP; but now Google's licensing forbids Amazon from also offering an Android TV product.

Perhaps Apple should face antitrust action, perhaps not, but the MS ruling doesn't really apply as Apple does not license their software. The ruling was meant to empower OEMs and Apple IS the OEM.

So build something great that doesn't run on iOS. Lots of software is exclusive to Mac or iOS; why not software that is exclusive to Android or Chrome? If it's compelling enough, Apple will change its tune.

Non-GC languages are bad in general at handling cyclical references (mutable or not), and Rust is especially ill suited for it because of the borrow checker. For example should an arbitrary reference in tsc become an rc::Rc or an rc::Weak? You have to tease out the implicit ownership model and one may not even exist.

tsc was designed expecting GC and it makes perfect sense to port it to another fast GC language.