A single product meant for all the users will inevitably be a poor fit for most of them. We need more variety of products for the different segments of the market. Alternatively we need more knobs to tune things to user needs. One promise of AI is enabling folks to personalize product experiences, but so far it's all been surface level.
I think the desktop Linux ecosystem is an example of something healthier, but it goes too far in the other direction. There are too many options to choose from that it's hard to find the one for your needs.
Anti trust laws do not generally apply to these situations. The government has had an appetite for antitrust, but the cases are far from a slam dunk. We need modern laws for modern problems.
This is optional functionality which a subset of their important customers want. You will continue to have options that do not make use of this feature.
As someone with children, I see benefits in how age verification will help me manage my kids relationship with technology. Even if it was not the law, I would choose products with support. The point of open source is to allow for both options.
The two couldn't be more unrelated. The idea that age verification in an OS is bad is a niche position by a select few. You don't hear dissenting views on hackernews because the majority here belong to that group and going against the grain is down voted. On the other hand, you're comparing it to killing humans. Making everything into a moral dilemma cheapens the argument. Just because you disagree with the law doesn't give you moral high ground to ignore it. I think cookie consent questions are terrible but I'd not dream of not adding one if compelled by law
I always approve a change with comments for nits that are optional to address. I only hold back approval if there is a legitimate flaw of some sort. Generally this leads to small changes almost always getting approved on the first shot, but larger changes needing at least one back and forth. AI code review tools make it much easier to spot legitimate problems these days.
Or the reviewer feels responsible for the output of the code from the person they are reviewing or the code they are modifying. For instance a lead on the team gets credit for the output of the team
Also, wanting to catch bugs on review before they make your on call painful can be a large motivation.
You should look into how go manages goroutines. It is indeed 2kib stacks by default without the need for guard pages. They use a different mechanism to determine overflows. Other runtimes can do similar things.
Unfortunately (or fortunately depending on what side of the fence you live), boot chain security is not taken as seriously in the PC ecosystem as it is on phones. As as a result, even if you relying on os features, you cannot trust them. This is doubly the case in situations where the user owns the kernel (eg Linux) or hypervisor. Attestation would work, but the number of users that you could probably successfully attest are on on a trustworthy setup is fairly small, so it's not really a realistic option. And that is why they must reach for other options. Keep in mind that even if it's not foolproof, if it reduces the number of cheaters by a statistically significant amount, it's worthwhile.
I really thought this might change over time given strong desire for useful attestation by major actors like banks and media companies, but apparently they cannot exert the same level of influence on the PC industry as they have on the mobile industry.
I largely agree with you, but there are limits to what a tui can do well. If analyzing a flame graph or performance trace, web UI is a better fit. However, most things are not that.
It also bloats binary size if you statically link libc++ because of localization, regardless if you care for it. This wasn't true for fmtlib because it doesn't support localization. stringstream has this same problem, but it's one of many reasons embedded has stuck with printf.
In theory it improves battery life by doing more for less power. It also future proofs it for future workloads giving it an extended lifespan. Also note that thermals will limit what this is capable of compared to your laptop.
Even rust let's you turn panics into asserts. It saves a lot of binary size and arguably is equally debugable. We also see improved performance from being more cache friendly. C++ usage wouldn't be nearly as high if there wasn't such an option. As far as I'm concerned the primary downside is not being able to return errors in constructors and handle allocation failures but both are solve able via some common idioms (static methods and custom placement new)
What's the purpose of making such a comparison? The implication is that we're being wasteful, but I'm not certain that's the point you're trying to make.
I don't think it's that large. Keep in mind embedded projects take few if any dependencies. The standard library in most languages is far bigger than 600k loc.
They aren't making money on the vast majority of those 800 million monthly actives. I wonder how many will stick around once they roll out ads. If they keep those users with ads, they definitely will be worth their valuation.
cbindgen is woefully inadequate. Have you tried to use cbindgen to make interop between complex c++ work with rust? You will end up writing a significant amount of shim code manually, on both sides. Newer efforts like crubit seem promising, but still have some challenging edge cases.
The reason folks still use c/c++ is because of ecosystem. Chances are you have a lot of code you depend on and don't have straightforward ways to port it (and all the transitive deps). Especially in the case of larger enterprise software where there are 10s of millions of lines keeping you entrenched. Foundational things like your threading model, async executor, etc can make it difficult. If you're operating in a micro service environment and your core does are both minimal and ported, the journey becomes much more tractable.
Note that Firefox doesn't have market dominance. It is under 5% market share. That said I imagine Firefox users to be the most likely to make the jump. However, the web is a minefield of corner cases. It's hard to believe it will be enough to make the browser largely useful enough to be a daily driver.
It depends. I migrated a 20k loc c++ project to rust via AI recently and I would say it did so pretty well. There is no unsafe or raw pointer usage. It did add Rc<RefCell in a bunch of places to make things happy, but that ultimately caught some real bugs in the original code. Refactoring it to avoid shared memory (and the need for Rc<RefCell<>> wasn't very difficult, but keeping the code structure identical at first allowed us to continue to work on the c++ code while the rust port was ongoing and keep the rust port aligned without needing to implement the features twice.
I would say modern c++ written by someone already familiar with rust will probably be structured in a way that's extremely easy to port because you end up modeling the borrow checker in your brain.
They seem to have just optimized its integration with their existing tooling and workflows. That doesn't sound largely useful to the broader community. It's also probably different enough from goose at this point that rebranding it makes sense. I do think such integrations are hugely important for productivity and usefulness of this sort of tool. It seems like the post is advocating for doing deep 1p integration to further improve the utility of coding agents.
Feel free to cite some sources. I have plenty of anecdotes to suggest the problem exists, although I've not looked for data to prove it either way. However if you would like suggest it's not real you should prove it.