It's terse but I can make sense of this. I read it as broadcast() wrapping a single live() somehow, because invoking live() per a connection on the server would lead to viewers (clients? callers?) potentially seeing different streams.
I don't know about some of those points (maybe you could expand on them)
> disparate documentation
I've never experienced this while using a Rust library. They all use rustdoc hosted on docs.rs (or locally with $ cargo doc). They all look identical and there's a single global search bar that searches all your dependencies.
> conflicting dependencies
Since you can install two different versions of the same library, this is only an issue if two of your dependencies both expose a transitive dependency with different versions in their external APIs. (E.g. libA returns a Foo 1.0 and libB expects an argument of Foo 2.0) Only library I've ever run into this with is raw-window-handle.
> supply chain risks
> enormous .cargo
These I agree with. Although honestly the supply chain risk is not as big with these foundational libraries as it would first appear, since they are almost all maintained by the same 5 rust compiler developers. Really the only difference is that they're not in the rust-lang github organization and not shipped precompiled with the standard library
I don't really understand the threat model here, how would one "exploit" these issues? It's not like we use Rust as a sandbox (like e.g. JavaScript). If an "attacker" wants to crash the process, they can just write std::process::abort(), or if they want to break memory safety, they can just use an unsafe block.
Sophisticated exploits often are a creative chain of prying open cracks that may just have looked like innocent bugs until they were used in the right moment ans right context that made them a very useful piece in a puzzle. The naive view of a buffer overflow was also just "yeah well great they can crash the program but they could get that cheaper". Until somebody had the idea of overwriting return addresses or putting executable code there. It may be hard to say how a bug can be exploited. As long as something says "safe" but suddenly an asterisk pops up, that's the first step down worry lane.
Is a language only memory-safe if its implementations are completely bug-free? I guess no language can ever be memory-safe then, might as well throw out the concept.
I understand what it means, I was wondering why it matters. Right now, it feels like we're splitting hairs to maintain an impractically absolute definition of "safety". But if there's some useful aspect to this, I'd be happy to hear it.
The thing you're a complaining about is a rebuttal to hmry's insistence that the language is not an implementation, which also meets your criteria for complaining about, even though you did not do so.
You're the one who brought it up, why would you expect me to complain about the same things you do? It might meet my "criteria for complaining" if I shared your point of view, but I don't, because I don't understand it. I've been asking how your argument applies to the point hmry was trying to make. I'll be happy to complain together with you if you get me to understand and care, but I can't read your mind.
I would rather take the 0.1% lie that Rust is memory safe than the 99.9% lie that competent C and C++ developers can properly deal with the UB they sprinkle throughout their code base without causing severe security vulnerabilities.
As pointed out above, this same logic applies to virtually every trait every language claims to have. And it's purposely obtuse and combative. You are implying the sentence "Rust is used to write buggy software" by saying "Rust is used to write ... not ... bug-free software" which is again the case for every language ever. Do you also write comments complaining about cargo culting proponents of seatbelts, fire alarms, and electrical breakers since people still die as a result car crashes, fires, and accidental electrocutions?
And no reasonable people are claiming that rust is used to write 100% bug free software. And yet people like you imagine such people daily apparently. It's certainly not a claim made anywhere upthread of your comment so if it's your claim feel free to take full ownership of it.
This is something I really appreciate about cargo/crates.io's source-only distribution, compared to e.g. npm or pip/PyPI.
You always know that the package contents match the source code. And you can always add a dependency by just downloading its source code and putting it into a subdirectory. You don't have to go and set up a different build system for each library if you want to avoid the pre-built artifacts.
One thing I never understood about the "Nx Engineer" trope is if it's supposed to mean "one team member who achieves as much as N average team members", "one solo dev who achieves as much as an average N-person team", or "one solo dev who achieves as much as N average solo devs". Those seem like wildly different scales, and it seems like everyone who talks about it means something different.
Every place has had some experience with some problem that entire different teams, with dozens or even small hundreds of people failed to solve for years and years, and then some individual came and did it.
And almost everybody has seen or heard some similar story.
The thing is, those stories don't have a lot of similarity to each other, and there isn't much you can conclude for anybody's competence without looking at all the details. But they happen all the time, and not only in software development (just not on the same frequency, for obvious reasons).
"One solo dev who achieves as much as a N-person team" or alternatively, "N developers who achieve as much as a 10*N person team" is the one most easily supported with evidence. Prior to their acquisition, WhatsApp had 55 employees of which 32 were engineers. Facebook Messenger had a team that was most likely 100x larger than that and could not displace them in the target markets. In 1995 when Microsoft effectively defeated IBM as the premier software company, Microsoft had just 17,000 employees to IBMs 225,000 employees. The entire reason why a startup can even succeed is because a smaller, skilled team can overcome a much larger team with much more resources.
Microsoft headcount vs. IBM is not a valid comparison. IBM is also a hardware company. IBM is also a service company. And IBM (at least at that time) did far more custom development than Microsoft. You'd have to compare the headcount of Microsoft's OS business to IBM's OS business (or OS development organization, if it wasn't a separate business).
You're right. That's precisely the problem. The "Nx Engineer" is catchy and we all know "what it means" when we first hear it. We most likely relate it with an early experience when we were juniors and a senior developer pair programmed with us. For me it was mind-blowing. So we can relate to it.
But the issue is the ambiguity. The multiplier is there, but not the unit/metric being measured. So it's just a shorthand for "someone exceptionally good" as said by a sibling comment.
Nowadays a single solo dev can outright achieve as much as entire _organizations_ could in the early 2010s. I know multiple people whos raw code output easily exceeds say everything Amazon/Google/Facebook (likely combined) could do in a single year in the 2010s.
Imagine a gaussian distribution of all engineers. It's a figure of speech to say someone's productivity falls in the right-side tail of that distribution.
The multiplier isn't meant literally. It's shorthand to say someone is exceptionally good in a way that is rare to find.
That reddit post is written from the perspective of someone who's actually pro AI ("It felt great for about 6 months ...") and only realizes retrospectively they ended up in a mess. So there's no internal inconsistency in the narrative.
Anyway most of reddit is dead internet and that post is just engagement farming... As is most of hn.
The author specifically claims to have written the article themselves and not used AI, so you are basically accusing them of being a liar. You might want to be a bit more cautious about committing direct defamation. Just sayin' :-)
I tried using it and yeah, GPUI felt very sloppy. Something about that lack of documentation + having to install it from some subdirectory in a giant monorepo + Tailwind-based API...
And the recommended component library for it (GPUI Kit) seems to have been 100% Clauded, down to the website and README.
reply