orclev
That can be true and she can still be the best candidate. There’s a very long list of people I would rather see elected president but unfortunately the reality is that only one of two people are going to win. It’s either Harris or Trump, and while I don’t like Harris for many many reasons, she’s not an existential threat to democracy like Trump is so she gets the votes. The only way to fix this is to get some kind of proportional voting implemented at the federal level. Personally I like STAR voting, but even the worse choice of ranked choice is still better than first past the post.
That would be fine if it weren’t for the fact that the races are so tight that every vote matters. If Harris had a healthy lead on Trump to the point where a couple hundred votes here and there could be thrown away and she’d still win nobody would worry, we’d say “sure, throw away your vote, or you know, just stay home, you do you”, but unfortunately that’s not the case. So yes, the vast overwhelming majority of people disagree with you, but unfortunately even being wrong your vote is still important.
On the topic of whether there are more than two parties, first past the post means no, there aren’t, there can’t be more than two parties. Fix first past the post if you want an actual democracy. Until that happens, voting 3rd party is functionally the same as not voting, in either case your vote isn’t being counted to determine the winner.
Also on the whole “the king his book” thing, I think the video kind of agrees with you but in an awkward sort of way. He points out that the belief that it’s an abbreviation for “his” was incorrect, but where it gets confusing is that it’s implied that that incorrect belief is why the apostrophe is used as a possessive, rather than as a marker for the elision of the “e” in “es”. The overall impression is that grammatically it would be correct to just leave the apostrophe off and just add s to show possession. The reason I think he brought up the debunked “his” theory was to highlight where that leads to incorrect over correction by some writers where they replace the possessive with an expanded incorrect “his” version.
Ultimately though, the thing with English is that it’s a complete dumpster fire of a language, and literally every rule has nearly as many exceptions as it does cases where it applies. The language didn’t evolve so much as it metastasized in fits and starts. Nearly every feature of the language from its words, to spelling, to grammar was either awkwardly bolted on from some other language, or it was just invented from whole cloth by some random printer or author (often with highly dubious logic driving it). This is just the latest iteration of that process with people inventing distinctions between characters that didn’t really exist in the past. Single quote is already a bit of an aberration, eventually it will likely just die out in actual usage and we’ll be left with this abortive calcified single quote character in the UTF character set to mark where it used to be.
I think technically I made a mistake there, re-watching it, while the left “single quote” character is an inverted comma, the matching right “single quote” is just an apostrophe, but the apostrophe itself isn’t an inverted comma, it’s its own character. I got confused between the left and right single quote.
Which is still stupid as a single quote is an apostrophe. Quotation marks of any kind didn’t really exist prior to the creation of the printing press (this is also why there are many many local variants). There were several marks that were used to emphasize or highlight passages, but not to directly mark something as a quotation. When printers found themselves in need of a character they didn’t have they re-used existing characters (since characters were literally hunks of metal and they couldn’t exactly go out and whittle a new one).
For apostrophe they just flipped a , upside down, and thus the apostrophe was born (a similar mark used to denote where something was omitted was used in writing, so the apostrophe did exist prior to that point, but it was written more in the style of a carat above the word typically).
When they needed a way to mark quoted text different printers used different characters. For some they re-used the same trick as they used for apostrophe and just used upside down commas and thus the single quote was born. Others did the same, but in order to differentiate it from the apostrophe they double it up, hence the " character is literally a double upside down apostrophe. Some used either single <> or double << >> brackets to denote quotations. Some use a comma and apostrophe E.G. ,a quote’ or doubled it E.G. ,another quote’’ (N.B. it looks like the comment renderer on here is eating the double , replacing it with a single , and possibly replacing the double ’ with a single " character). It was all down to whatever the local printers had available and felt was appropriate.
Hence getting bent out of shape about if a ’ is an apostrophe or a single quote is utterly stupid, it’s both as they’re literally the same character.
if you use a garbage collector which is perfectly suitable unless you write low level embedded systems or oses
Or games, or realtime systems, or high reliability/mission critical systems, or high performace systems. There’s a long list of programs that GC isn’t suitable for for one reason or another.
and even if you use something like C or C++ where you manually allocate or deallocate, if the app is properly tested memory issues won’t happen.
There’s about four decades of security vulnerabilities in extensively tested and widely used software that says this is absolutely false.
Cargo is doing too many things at once. It’s a build system but also a package manager but also manages dependencies? Idk what to even call it.
Somewhat agreed, but it’s a very difficult problem to solve. No language has yet come up with the perfect build tool. JS is on what, like the 12th build tool in as many years now? Some serious throwing stones in glass houses vibes here.
Syntax is very confusing for no reason. You can’t just look at rust code and immediately know what it does.
Strongly disagree on this point. Those extra glyphs in Rust are not just cosmetic, each one means something very specific and conveys very important information.
Having to pollute your code &, ? and .clone() everywhere to deal with ownership
You don’t “deal with” ownership, it’s an incredibly powerful tool you use. This just sounds like you haven’t really understood what the borrow checker is actually doing and the hundreds of problems it solves for you. I can not count how many times now I’ve been working in another language and had the thought “I could solve this with the borrow checker”
Js is way more readable.
JS is not more readable, JS is just far less detailed. It omits a vast swath of information such that you have almost no idea what it’s actually doing. It feels easier to you because you don’t care about any of the details, but those details become vitally important when things stop working and you’re trying to figure out why. This sounds to me like you’ve never had to write any actually complicated code. If all you’re trying to do is chain together a series of HTTP calls and maybe parse a tiny bit of JSON, yeah, Rust is like using a nuke to kill an ant.
Similarly, Async code starts to look really ugly and overengineered in rust.
A little bit, but mostly because doing async right is really complicated. Once again no language has a really great solution to this problem yet, they all involve tradeoffs.
Multiple string types like &str, String, str, instead of just one “str” function.
Once again it seems you don’t really understand the difference between owned and borrowed values or stack vs. heap allocation and why it matters. Really there’s only one type of String which is String, the others are just different ways of borrowing a String (with different tradeoffs).
i32 i64 i8 f8 f16 f32 instead of a single unified “number” type like in typescript. Even in C you can just write “int” and be done with it
If all you want is a “int” you can just use i64 for everything and “be done with it” as you say, you’ll just be adding a ton of wasted memory and needless overhead for no good reason. Seems like you just don’t like strong typing. I’m surprised you even bother with TypeScript instead of just using JavaScript.
Having to use #[tokio:main] to make the main function async (which should just be inbuilt functionality, btw tokio adds insane bloat to your program) yet you literally can’t write code without it.
You absolutely can write code without using , you can even use tokio without that, it just saves you having to write a bunch of boilerplate to initialize tokios executer and pass your async functions to it. You can even use async functions without tokio, you just need to provide your own executor. Async in Rust is still pretty new and some of the rough edges are still being worked out, it will get smoother, but honestly the things you’re complaining about aren’t even the annoying parts about it.
Speaking of bloat, a basic get request in a low level language shouldn’t be 32mb, it’s around 16kb with C and libcurl, despite the C program being more lines of code. Why is it so bloated? This makes using rust for serious embedded systems unfeasible and C a much better option.
I have no idea what you’re doing to generate code sizes like that, but I guarantee you could get a significantly smaller program in Rust that does exactly what the C code is doing. As for embedded this is patently false. I personally use Rust regularly on embedded devices that don’t even have 32mb of RAM on them.
With cargo you literally have to compile everything instead of them shipping proper binaries. Why???
This isn’t a cargo thing, this is a Rust compiler thing. The Rust ABI hasn’t been standardized which means currently there’s no guarantee that Rust code compiled by one version of the compiler can successfully link against code compiled by a different version. Until not that long ago C++ actually had the same problem. This will eventually get fixed, but the language team feels things are still moving too fast to define a concrete standard yet.
Another major issue I’ve encountered is libraries in Rust, or lack thereof. Every single library in rust is half-baked.
Rust is still pretty new, so a lot of libraries are still in active development, but there are already many excellent and very well documented libraries. Axum is literally one of the newest web frameworks in Rust and didn’t even exist that long ago. I’ve seen far worse documentation for JS libraries (and don’t even mention C, the gold standard there is practically a man page that’s just a glorified header file).
As for “memory safety”, it’s a buzzword. Just use a garbage collector.
Memory safety is not “just a buzzword”, there’s a reason all the top vulnerabilities for decades now are all memory safety issues. As for a garbage collector, good luck with that when writing embedded software or a kernel.
The rest of your rant basically boils down to “my particular simple use case doesn’t see much value from what Rust provides”, which is fine. If you don’t need the power of Rust, use something weaker, not every problem needs the nuclear option, sometimes you just need something quick and dirty that will run a few times before it falls over. Hell, sometimes a quick Perl script is the right solution. I mean, not often, but it does sometimes happen. When you do find a problem that your quick and dirty approach isn’t working on then you’ll see the value in Rust.