[–]▶ No.854901>>854922 >>854960 >>855356 >>855685 >>855921 >>856125 >>857653 [Watch Thread][Show All Posts]
Why do you guys make fun of Rust?
What is wrong with it?
t. complete newfag
▶ No.854910>>854914 >>854921 >>854922 >>854930 >>855568 >>855876
>>854907
I only see you guys discuss the SJW boogeyman but never discusses the technical aspects of the language.
▶ No.854914>>854922 >>856090 >>856115 >>856126
>>854910
This is something i'd actually like to know about. It sounds like a huge security improvement over things like C and C++, but I imagine there may be a catch of some sort.
▶ No.854920>>854925 >>854926
It's shilled to fuck, and all those claims are mostly unverified. They are all things that work in theory, and after Meltdown and Spectre there better be damn good proof that something is secure and not going to cause problems.
You can always tell when something is being shilled because it's really popular and controversial for a set amount of time, and then it suddenly falls off the internet. That's exactly what's happened with Rust and it's exactly how systemd got started.
▶ No.854921>>855003 >>855098
>>854910
For most critics here, that is the catch. Technical criticism tends to focus on instability and unsafety (which is not by design but due to compiler bugs), and long compile times, which also is something that can be fixed soon. IMHO what's much worse than that is Rust's type system which still lacks generics over constants, e.g. Matrix<5, 3> (see https://github.com/rust-lang/rfcs/pull/2000), and traits, e.g. Vec<Iterator> (a vector of anything that is an Iterator). Now this can sooner or later be implemented, too, but as this affects the language on a much more fundamental level, I wouldn't consider the language 'stable' nor 'as useful as C++' yet.
▶ No.854922>>854983 >>855003 >>855098
>>854901 (OP)
>What is wrong with it?
-It's sold has fail proof when it isn't and has proven itself to not be fail proof.
-It's VERY young
-Ada and D already exist and are more reliable
>Why do you guys make fun of Rust?
-It's shilled by horrible people who don't care about the technology and use a facade of caring about it to push their political agenda.
-CoCs
>>854910
>the SJW boogeyman
>implying they aren't relevant
>implying that they haven't succeeded to make 1984 a reality
m8 you need to read more
http://cartusers.curry.com/bolNMdb/enc/20180109110610_368688363-james-damore-vs-google-class-action-lawsuit.pdf
>the technical aspects of the language.
True
>>854914
>It sounds like a huge security improvement over things like C and C++
https://en.wikibooks.org/wiki/Ada_Programming
https://dlang.org/documentation.html
▶ No.854925>>854929
>>854920
>and all those claims are mostly unverified.
But so is your criticism. So many strawmen in a single post.
▶ No.854926>>855628
>>854920
> and after Meltdown and Spectre there better be damn good proof that something is secure and not going to cause problems.
There's no language that can protect from these two not even ada or D
▶ No.854929
>>854925
>But so is your criticism
Not the anon you responded to but it his massively shilled, if you have been here the past two years the number of rust threads or pseudo rust thread have been the same amounts of web browser threads, plus the whole crustacean and supporters who shill it like if it was a new religion/cult is a fucking turnoff.
Has for "does it work" of course it works but it's young and ultimately has big errors and other problems that of course can always be fixed like any other languages before it like ada or D.
▶ No.854930>>854936
>>854910
>never discusses the technical aspects of the language
Most of the people here don't code
▶ No.854936
>>854930
>Most of the people here don't code
True.
Question:
On 7billion people how much can code ?
▶ No.854944>>855003 >>855098
Rust was originally shilled as a language that "fixes the problems" with C and C++. I know how to code reasonably securely in C so for me, that means fixing code readability. When I look at Rust code, it somehow manages to be even noisier on the eyes than C++.
To add to that, the cognitive load of writing even a single line of Rust code is through the roof.
It's as if it was made just to stress people out more and waste time.
I understand the benefits of lifetimes and ownership, but the cpu architectures themselves are flawed at the hardware level and that's something no language can fix. Assuming you know how to wield C and C++ properly and don't need ridiculous amounts of compiler errors to lead you to success, why not just keep using C and C++ ?
▶ No.854960
>>854901 (OP)
>t. complete newfag
nice try rustfag
sage and report all rustfag threads
▶ No.854983>>855206 >>855221
It's better than C++ (not really hard to do), but not than C. But yeah, if you do use it, you'll have to distance yourself from the gay community.
>>854922
>D
GC in the stdlib.
>Ada
Go LARP elsewhere.
▶ No.854994>>855003
I just think Rust is too complicated for a general purpose language. As someone put it, the cognitive overhead every line has is just way too much to find it comfortable to use. It's also unlike C++, where things can get as hard as you need for specific parts of the project, but is generally comprehensible. Rust is hard all the time, and shit like vectors may need different type signatures depending on what you want to do with them, or worse, WHERE will you use them from. There is also the whole fucking type system, that may require nesting half a dozen types in a specific order you could achieve in two in a saner language; also, have fun unwrapping, or even worse, correctly handling every fucking possibility in a thousand levels of nesting. Also, did you just change a type signature because you realized you missed on a certain capability that you realized you needed for a certain function? Have fun rewriting your whole program.
Rust also has some gotchas with some of the features it teaches the user in its own fucking book. Enums are really fucking nice, but they never mention that defining struct type enums is akin to shooting yourself in the foot and nobody does it after their first time because accessing their contents is verbose as fuck. Then it has the whole deref operator inside match clauses that doesn't work like an actual deref operator but whatever. It also had some really basic features (like try-casting) as "EXPERIMENTAL DO NOT USE!!!!" months after the 1.0 release.
tl;dr mite become a nice language, but as is the language is amateurish and intentionally guides you towards bad practices that will make your code fucking unmaintainable.
The community is nice and helpful fuck off /tech/
▶ No.854997>>855003
The language itself is pretty good, I'd say it's better than C++ and slightly better than C, and it's getting better over time. Modern C++ is pretty good, but it doesn't matter because it still has to be backwards-compatible with the old code.
Yes, the syntax is terrible. Yes, the cognitive load is higher, but it's generally worth it. Just git gud.
Yes, there are some edge cases that are insecure, but it's better than the whole language being insecure, like C and C++.
The worst issue by far is the SJWs and their CoCs. One day, they will pay for their faggotry.
▶ No.855003>>855004 >>855035 >>855098 >>855610 >>856052
>>854921
>still lacks generics over constants
Not exactly true. https://docs.rs/typenum/1.9.0/typenum/
This is hacky and rapes compilation times even further though.
>Vec<Iterator>
The size of the type has to be known at compile time. So if you want to have a Vec of things that implement a trait you have to use a trait object. This isn't a limitation of the language.
>>854922
>It's sold has fail proof
Wrong. Do you have any proof to back up your claim?
>Ada and D already exist and are more reliable
D has GC and is not memory safe.
>>854944
>cognitive load
Complete bullshit
>>854994
Your whole post reads like you are a complete retard that has never used a statically typed language and decided Rust is shit because you couldn't understand it.
>vectors may need different type signatures depending on what you want to do with them, or worse, WHERE will you use them from
??? This makes no sense
>There is also the whole fucking type system, that may require nesting half a dozen types in a specific order
Yes that is how strongly typed languages work
>in a saner language
For example?
>also, have fun unwrapping
You don't unwrap in production unless you want your shit to crash.
>or even worse, correctly handling every fucking possibility in a thousand levels of nesting
What do you mean??? Are you trying to say that shit code is shit?
>Also, did you just change a type signature because you realized you missed on a certain capability that you realized you needed for a certain function? Have fun rewriting your whole program.
Again, that is how strongly typed languages work. If you don't want to deal with it use some shitty language that encourages runtime casting.
>It also had some really basic features (like try-casting) as "EXPERIMENTAL DO NOT USE!!!!" months after the 1.0 release.
Every language has experimental features. What is your point? Also Rust doesn't have try casting. It only has statically checked casting.
>The community is nice and helpful fuck off /tech/
Wtf? Now you are just trolling.
https://www.reddit.com/r/rust/comments/7o5ztn/where_we_discuss_drama_surrounding_ashley_williams/
>Kill all men
- Ashley Williams (Core Team, Community Team Leader)
>>854997
>reddit spacing
▶ No.855035>>855047 >>855098
>>855003
>??? This makes no sense
Have YOU used Rust?
>Yes that is how strongly typed languages work
You clearly have not.
In C++, std::vector<std::shared_ptr<T>> gives you a vector of smart pointers to T. It may look verbose due to the ise of the std namespace, but you can use std and forget about it. It's pretty clear what it does. Now, the equivalent in Rust is Vec<Rc<RefCell<Box<T>>>>. Rc provides the smart pointer, RefCell provides the mutability (because of course, mutability is a type; from a theoretical point of sense this is extremely cool, but it's just a pain in the ass in practice), and Box provides a pointer to heap because why would we couple that functionality into RefCell? But wait, if T happens to be a type implementing Copy (which is not Clone, because every single fucking small nuance spawns a new type; they can't affor suboptimal decisions after all the layers of pointer indirection they threw themselves into), which usually are primitive types and shit you will have to look in the documentation continuously? You could use Cell instead of RefCell, because OF COURSE there is a type for that. Except they are not the same and depending on whether you want to synchronize changes between different sections of your code reading the ssme object you may need to use RefCell over Cell, and also throw a couple more Rc in the type signature because why the fuck not. Not to mention naming conventions are overtly terse to overcome the fact they endlessly nest their types and having to linebreak less often during type definitions, and that makes what every shit does less obvious. The fuck is a Rc, and what's the difference between a Cell and a RefCell? I can kind of guess what a shared_ptr is, but Rc is unintuitive as fuck. You may also use Weak instead of Rc. What do these types do? Whenever you search when to use A or B, you usually get "they are totally different and have nothing to do at all" with a half assed explanation on why comparing things is bad that doesn't solve your question. Yes, you get used to it, but it's dumb.
>You don't unwrap in production unless you want your shit to crash.
Sometimes you do want your program to crash, but anyway, that's why I brought up the next point.
>What do you mean??? Are you trying to say that shit code is shit?
In the example above, Vec returns an Option, Rc may panic depending on how you access it (arguably not in our case, considering tbe other types are there to circumvent that) and RefCell may panic. And this is a relatively simple datatype for Rust, five levels of indentation or endless temporary variables are normal for Rust standards.
>Again, that is how strongly typed languages work. If you don't want to deal with it use some shitty language that encourages runtime casting.
Except other languages don't need changing type signatures every time you realized you forgot a specific guarantee continuously and write thousands of lines of error handling code whenever you do.
>Every language has experimental features. What is your point?
It is dumb to have basic features as experimental features. It is simply not mature enough yet.
>Also Rust doesn't have try casting. It only has statically checked casting.
Don't remember exactly the function, but I think it may have been related to parsing or coercion. I just remember the generally taught and accepted function or trait simply assumed the input was valid and did not even assume it should return a Result<T> instead of a T, and the trait that did was an experimental one. Which is stupid considering casting from an int to a C-style trait could fail just like any type with more possible values than those the target type accepts could and should fail. Although that was a year ago so I dunno.
Also, I must add the compiler has compilation stages and some really minor failures will halt the conpilation at all, while hiding more important errors in later stages that could have been detected even with the earlier failures. Tool support for Rust is shit, and their official vim plugins suck and don't even work, even though the fixes have been circulating around for a while but they can't be assed to accept the pull requests. I would like to shit on the type system again while we are at it, since it encourages thousands of indirections and RefCounting to the point your average program will be as slow as one made in a managed language,and the managed language will be more comfortable to use.
>Wtf? Now you are just trolling.
Go to their IRC and ask anything about Rust or programming in general. They usually answer pretty quickly. There used to be a claim that the whole Rust community was composed of retarded SJW who don't know how to program, but this is clearly not the case. Their Reddit is mostly cancer, but that's because it's Reddit.
Don't be surprised if you get banned if you go full kill all the niggers and the gays upon entering the chatroom, tho.
▶ No.855047>>855053 >>855098
>>855035
>Have YOU used Rust?
Yes
>Vec<Rc<RefCell<Box<T>>>>
Box gives you a T on the heap. RefCell gives you dynamically checked borrow rules. Rc gives you reference counting. Vec gives you a Vector of Ts.
>because why would we couple that functionality into RefCell
Yes please answer that question. Why should RefCell do a heap allocation?
>muh Copy and Clone
Copy is a marker trait that signals that the type can be cloned by a memcpy. It doesn't "spawn" a new type.
>mental diarrhea
I don't really get what you are rambling about. Maybe try learning some Rust first? Also if you use a lot of RefCell and Rc either you are doing something wrong or you should use a garbage collected language.
>Rc is unintuitive as fuck
It literally stands for reference counted.
>what's the difference between a Cell and a RefCell
Have you tried reading the docs? https://doc.rust-lang.org/std/cell/index.html
>You may also use Weak instead of Rc. What do these types do?
If you don't know what weak in the context of reference counting means, maybe you should read a book about programming?
>different things work differently
Exactly.
>Vec returns an Option
Vec is a type. It doesn't return anything.
>Rc may panic depending on how you access it
Wrong.
>and RefCell may panic
Yes. It shifts the borrow checking to runtime.
>five levels of indentation or endless temporary variables are normal for Rust standards.
If you say so.
>Except other languages don't need changing type signatures every time you realized you forgot a specific guarantee continuously and write thousands of lines of error handling code whenever you do.
Except they do.
>It is dumb to have basic features as experimental features.
The basic features are all stable though.
>Don't remember exactly the function, but I think it may have been related to parsing or coercion.
Do you mean TryInto/TryFrom? The Into/From traits are for infallible conversions. TryInto/TryFrom for fallible. But just because the Try* traits are currently unstable doesn't mean you can't have fallible conversions.
>I would like to shit on the type system again while we are at it, since it encourages thousands of indirections and RefCounting
Yeah you are just retarded as fuck. Rust doesn't encourage ref counting nor indirections. It is you either writing shit code or using the wrong language.
>Don't be surprised if you get banned if you go full kill all the niggers and the gays upon entering the chatroom, tho.
Ok. But if I go full kill all men?
▶ No.855053>>855057 >>855098
>>855047
>I can explain what does this stuff does using different words from your own so I am right and you are wrong
>I can also quote your words out of context so you look stupid haha
Yes, of course you can explain it. It's already coded, after all. Can you explain why is it so fucking overengineered compared to other languages, though?
>Rust totes encourages efficiency guise
Bitch, the "idiomatic" way to write n-trees is using linked lists. Even inside an arena that shit is going to be terrible.
>Ok. But if I go full kill all men?
Dunno. Why don't you try?
▶ No.855057>>855058 >>855098
>>855053
>>I can explain what does this stuff does using different words from your own so I am right and you are wrong
>>I can also quote your words out of context so you look stupid haha
Ok. Could you please quote me where I did that?
>n-trees
>linked lists
That are two completely different thing. But I don't expect anything else from a faggot who doesn't know what weak references are. Go LARP somewhere else.
>Dunno. Why don't you try?
I don't have to. The leader of the Rust Community Team already did that. The Rust cucks responded with "stop harrassing her" and shut down all discussion over it.
▶ No.855058>>855059
>>855057
>That are two completely different thing.
https://rust-leipzig.github.io/architecture/2016/12/20/idiomatic-trees-in-rust/
Oh, what is that? A tree that uses linked lists for children and siblings. And just like that, you outed yourself as the real LARPer. Conversation terminated,
>But I don't expect anything else from a faggot who doesn't know what weak references are
That's exactly what I mean with misquoting. Go read a book to improve your reading comprehension, nigger,
▶ No.855059>>855253
>>855058
>https://rust-leipzig.github.io/architecture/2016/12/20/idiomatic-trees-in-rust/
Yeah. That is not a tree. It is a Graph. Writing Graphs in safe Rust is hairy but Trees are no problem.
>That's exactly what I mean with misquoting. Go read a book to improve your reading comprehension, nigger,
You literally said you didn't know what weak in the context of reference counting means. And just like that, you outed yourself as the real LARPer. Conversation terminated.
▶ No.855094
Keep shilling it here and we'll attach swastikas to everything rust to make the internet and FOX News think you're internet nazis!
▶ No.855098
>>855057
>>855053
>>855047
>>855035
>>855003
>>854921
>>854922
>>854944
here comes rustfag arguing with himself to bump his shit thread and generate false conversation
▶ No.855110
everything.
it combines all the worst ideas
that could have been solved instead if the programmer had spent a little more time on getting the fundamentals right
▶ No.855206>>855623
>>854983
>its better than c++
>but c is better than everything else because muh c
t. /tech/ larper
▶ No.855211>>855223
It's syntax is perl-level of noise and It's downright unpleasant to program in. You will spend less time thinking about your actual program, and more time searching for the right "idiom" or mental contortion to tame the "borrow checker". Also, shit compile times ("incremental compilation" is supposed to assuage this, but I've only seen data from cherry-picked toy benchmarks to support that claim). I recommend it if you either:
a) don't actually enjoy the act of programming, but have an unhealthy single-minded obsession with MUH SAFETY that needs to be satiated.
b) are a hipster who wants to signal about being a big boy "systems programmer" while partaking in Mozilla's hip social justice community
▶ No.855221
>>854983
Ada isn't a LARP, just because it's too hard for brainlets doesn't mean it doesn't exist and cannot be useful in the hands of a competent programmer.
▶ No.855223
>>855211
>muh syntax
>muh compile times
>muh borrow checker
Anti Rust shill spotted.
▶ No.855253>>855255 >>855290
>>855059
>Graphs
>Having parent-child relationships
Lmao. Point at him and laugh.
▶ No.855255>>855290
>>855253
Something tells me Steve is the product of a parent-child relationship..
▶ No.855290>>855394 >>855522
>>855253
Ok. Seems like you skipped the algorithms and data structures course in uni.
>>855255
Not an argument.
▶ No.855294
There's two way to make massive shitposting in /tech/
Start a Rust thread.
Start a license debate.
▶ No.855339>>855354 >>855445
Here's 2 of the many gripes I have that haven't been mentioned yet.
1. The borrow checker can get annoying from a USERs perspective. If I want to just make a small tweak to a program so that it works better for me, I sometimes run into the borrow checker. This means that I might have to restructure more code to just make the borrow checker happy. If I know that a change is safe, I don't need the compiler to complain that it isn't. I'd prefer if the patches I made were just a couple lines.
2. For some reason the Rust community seems to license almost everything under the MIT license instead of the GPL. It seems like they do not want their software to remain free by allowing other developers to take away the freedom aspect of the projects.
▶ No.855354
>>855339
>It seems like they do not want their software to remain free
It's because rust is financed and shilled 100% by mozilla, a for profit company. It's in their best interest to get other companies locked into their shitty rust eco-system that they run and manage.
▶ No.855356
>>854901 (OP)
>What is wrong with it?
It threatens their oo-rah masculinity
▶ No.855373
Because it's natural and organic and gets slapped around every thread, like a benis.
▶ No.855394>>855429
>>855290
You know which subset of graphs introduces directionality? :^)
▶ No.855429
>>855394
directed graphs, duh
▶ No.855439
I'm firing up my meme machine and readying a queue of dank swastikas...
▶ No.855445>>855480 >>855482 >>855598
>>855339
1. The borrow checker runs at compile time, so the USER doesn't have to care about it even if they're reverse engineering the binary. You're just a shitty dev that needs to git gud.
2. No, they want to make cargo usable to professional developers without some one line dependency of a dependency of a dependency suddenly GPLing millions of dollars and thousands of hours of investment. Rust's dynamic linking is complicated at the moment so even LGPL is difficult to comply with. I checked the dependencies of a game engine once and it had this very scenario: some snowflake had decided that their <300 line wrapper for a bunch of DX11 texture compression functions was worth contradicting the entire community, essentially GPLing every game made with it.
▶ No.855480>>855484
>>855445
>so the USER doesn't have to care about it
But what if the user wants to make a modification to the program?
>suddenly GPLing millions of dollars and thousands of hours of investment
That's a good thing. Though it's a little misleading using the word suddenly since it only takes place when you want to distribute the binary.
There is nothing wrong with having to release your source code along with the binary. What if the users want to make small changes to it?
>essentially GPLing every game made with it
Those games could either remove the GPL software, or just do the right thing and become licensed under the GPL. With games it is actually not that bad becoming GPL since when you sell a game you are selling a lot of assets along with it.
▶ No.855482
>>855445
>GPLing every game made with it
>implying they wouldn't just ignore it and sell the game. nobody has the source anyway.
▶ No.855484>>855487 >>855489 >>855493 >>855618
>>855480
>>855480
>Those games could either remove the GPL software, or just do the right thing and become licensed under the GPL. With games it is actually not that bad becoming GPL since when you sell a game you are selling a lot of assets along with it.
why do you think programmers should give their labor away without remuneration but artists must be remunerated for their labor?
▶ No.855487
>>855484
art doesn't run botnet on your computers.
it's not about the money.
▶ No.855489
>>855484
>programmers should give their labor away
The programmers made something and then their company sold it.
For example, a craftsman uses his labor to make a piece of art and then he gives that art away in exchange for money. The programmers also make something with their labor and then they would give it away in exchange for money.
>but artists must...
Just like with code, I would prefer if they would give away the project files instead of just the final copy, but it's up to the company.
You could also imagine the opposite. What if all art assets were free, but the game binary wasn't. It's not like people would be able to enjoy your product by just having the models and not having anything to make them interact with each other.
▶ No.855493
>>855484
Programmers have no value. Pajeet can do it for less.
▶ No.855522
>>855290
Fuck niggers get AIDS, Steve.:^)
▶ No.855568>>855576
>>854910
Some Anon put it this way:
>a programming language is as good as its community
>Rust's CoC assumes that you believe in 'gender'
>i'm a christian and i don't believe in 'gender'
>therefore i can't use Rust
▶ No.855576
>>855568
Rust is a tool like any other, use it for good. It's a good language. Don't however, contribute in any way to the project or core team faggots with AIDS.
▶ No.855584
They're just a bunch of larpers.
Theres litterally nothing wrong with Rust.
▶ No.855610>>855612
>>855003
>typenum
disgusting tbh
>you have to use a trait object.
what about 'impl Trait' or whatever that's called?
▶ No.855612
>>855610
>disgusting tbh
yeah
>what about 'impl Trait' or whatever that's called?
impl Trait is just another way to specify generic bounds in function signatures.
You can't have a Vector of structs that implement a trait because the structs could have different sizes. So what you have to do is use a trait object. That is a pointer to the struct and a pointer to the vtable.
https://doc.rust-lang.org/std/raw/struct.TraitObject.html
▶ No.855618
>>855484
Programmers produce reusable modules and use others' work in their work, and in turn receive developer support and feedback from users of the program. An artist produces unique works that aren't improved or used by other artists and thus stands nothing to gain by giving work away in the same manner.
▶ No.855623>>855625 >>855687
>>855206
Yeah, I used the wrong words. It's not a C replacement; too big and high level.
▶ No.855627>>855630
A language that is supposed to replace C++ should not be more complicated to learn/write than C++.
>inb4 git gud
Just git gud at C++ then?
▶ No.855628>>855630 >>855647
>>854926
He meant those bugs are proof that even the things you think are absolutely safe and cannot possibly be unsafe can one day be found to contain one fatal flaw that makes the whole thing a mess.
So, he's right. Rust is way to young to go replacing anything. Formal proofs need to be produced first. Rust has to prove itself in practice, not only in theory.
▶ No.855630>>855633 >>855642
>>855627
>Just git gud at C++ then?
C++ is memory unsafe though
>>855628
>Rust has to prove itself in practice
I'm using Firefox Quantum right now.
Also I have replaced grep with ripgrep and ls with exa.
▶ No.855633>>855635
>>855630
He meant those bugs are proof that even the things you think are absolutely safe and cannot possibly be unsafe can one day be found to contain one fatal flaw that makes the whole thing a mess.
So, he's right. Rust is way to young to go replacing anything. Formal proofs need to be produced first. Rust has to prove itself in practice, not only in theory.
▶ No.855635>>855641 >>855688
>>855633
Why are you reposting your post with reddit spacing???
▶ No.855641>>855644 >>855664
>>855635
What are paragraphs?
▶ No.855642>>855644
>>855630
So is Rust and they still haven't bothered patching it. Face it the memory aspect is just for marketing which makes it a bad choice for production.
How many non-american, non-SF companies use Rust right now?
▶ No.855644>>855648 >>855662 >>856067
>>855641
see pic
>>855642
Rust is not memory unsafe. Stop spreading FUD.
>the memory aspect is just for marketing
It is not though. Memory unsafety is a huge problem in big projects. Not that you would know that of course. I'm sure your FizzBuzz implementation is 100% memory safe. But try writing something more complex before you talk shit.
>How many non-american, non-SF companies use Rust right now?
There are a few in Germany.
▶ No.855647>>855662
>>855628
Firefox Quantum is pretty damn fast and secure.
▶ No.855648>>855649
>>855644
Separating long lines consisting of multiple sentences by a single line break doesn't make sense imho.
▶ No.855649
>>855648
>sorosfox
use furryfox
▶ No.855662>>855665
>>855644
>There are a few in Germany.
Show us.
>>855647
>Firefox Quantum is pretty damn fast and secure.
Firefox quantum leaks even more memory than old firefox.
▶ No.855664
>>855641
>one sentence
>paragraph
▶ No.855667>>855668
>>855665
>all of them are 3man startups that will be gone within weeks
So there aren't any big players using rust? Sad.
▶ No.855668>>855679 >>855705
>>855667
>moving the goalposts
Shut up retarded anti Rust shill. First you excluded USA and now you exclude everything that isn't a big player.
The list at rustjobs.rs isn't exhaustive. There are a lot more companies that are using Rust in Germany. They just didn't out on that list.
Source: Employed Rust developer in Germany
▶ No.855679>>855681
>>855668
Anzeige ist raus Bernd
▶ No.855681>>855683
>>855679
Viel Erfolg! Ich bin hinter 7 proxies.
▶ No.855683
>>855681
>axel stoll
Anon, Ich...
▶ No.855685
>>854901 (OP)
Nothing. But this is 8chan, where honest discussion on the technical merits of technology is not allowed. Muh feels or fuck off. this is the 8chan credo.
▶ No.855687>>855775
>>855623
How so? It has no runtime, just like C (unlike C++), and real-world rust programs are faster than their equivalent C programs (see ripgrep, leaf or colemchyma for instance). "Big" doesn't really mean anything and it lets you do operations from as low-level as you need to high-level constructs which are faster and significantly easier to write. If anything it's what C should have been.
▶ No.855688>>855692
>>855635
He meant those bugs are proof that even the things you think are absolutely safe and cannot possibly be unsafe can one day be found to contain one fatal flaw that makes the whole thing a mess.
So, he's right. Rust is way to young to go replacing anything. Formal proofs need to be produced first. Rust has to prove itself in practice, not only in theory.
>Why are you reposting your post with reddit spacing???
Because judging by your response, you didn't read it or intentionally ignored the point. And because copying and pasting it inserted an extra line break there.
▶ No.855692>>855694 >>855696
>>855688
>he keeps reposting it
Are you mad? Rust has already proven itself in practice and nobody said that Rust would eliminate all seurity issues.
▶ No.855694>>855703
>>855692
By "in practice" I mean formal proofs. If there are any, I'll be very interested to read them. Please throw me a link.
▶ No.855696>>855699 >>855703
>>855692
The only relevant discussion I've seen always devolves into "it's not necessary" and "sure, check out my blog where I explain it to you", but nothing academic.
For example: https://github.com/rust-lang/rust/issues/9883
I'll be very interested because I think Rust has potential, but as I said in my thrice-posted post, it's way too young and relatively unproven (your examples are not enough yet).
▶ No.855699>>855701 >>855756
>>855696
Please stop being clinically retarded thank you.
▶ No.855700>>855702 >>855703
>and real-world rust programs are faster than their equivalent C programs
▶ No.855701>>855703
>>855699
nod an argumend :--DDDDDD
▶ No.855702
>>855700
Not an argument. Actual examples were provided. How about you debate them? Oh wait you can't because they're undeniable.
▶ No.855703>>855756
>>855694
>By "in practice" I mean formal proofs.
Formals proofs are "in theory" though.
>>855696
>The only relevant discussion I've seen always devolves into "it's not necessary"
Protip: Nobody cares about formal proofs. Companies don't pay you to jerk yourself off to some theory shit. They want you to get shit done.
But here, look at this: https://www.ralfj.de/blog/2017/07/08/rustbelt.html
>>855700
>>855701
error: (no arguments given)
▶ No.855705>>855708
>>855668
How big is your company?
What kind of product does it develop?
In what capacity does it use rust?
▶ No.855708>>855724
>>855705
>he wants me to dox myself on a white supremacy website
▶ No.855724>>855727
>>855708
No, I want you to verify your bogus claims.
▶ No.855727>>855732 >>855737
>>855724
How about you verify your bogus claims first?
▶ No.855732
>>855727
How would answering those questions dox you? Stupid much?
▶ No.855737>>855751
>>855727
High quality discussion.
▶ No.855751
▶ No.855756
>>855699
Why would you say that to me?
>>855703
Nice. Thanks for digging it up.
▶ No.855775>>855779 >>855782 >>855784
>>855687
>it has no runtime, like C
They both have a runtime that is the standard library (unless you statically link it) that is a lot bigger in Rust, of course.
>real-world rust programs are faster than their equivalent C programs (see ripgrep, leaf or colemchyma for instance).
Never said Rust couldn't be as fast as C.
>"Big" doesn't really mean anything
Yes it does. It mean compiler can stay simple and not become stupid behemoths. Find me something as simple as tcc/pcc for Rust. In fact, there's only one compiler for Rust, LLVM.
Another thing is that C is probably a lot simpler when you want to do a lot of unsafe memory stuff. Stuff like pointer aliasing, for example. Don't get me wrong, Rust does seems promising (especially that nice ML inspired syntax) but it needs maturation and will probably never completely replace C.
▶ No.855779>>855781
>>855775
>In fact, there's only one compiler for Rust
Wrong: https://github.com/thepowersgang/mrustc
Also, LLVM is just the backend. There is currently another backend in the works: https://github.com/stoklund/cretonne
▶ No.855781>>855804
>>855779
I see, it's still fat as fuck, though. And stop LARPing as this faggot, you'll have more serious discussions.
▶ No.855782
>>855775
>(especially that nice ML inspired syntax)
ML has a mostly clean syntax. Rust has more of a Perl/C++-inspired syntax that tries to use every character on the keyboard just because they're there.
▶ No.855784
>>855775
In unsafe blocks, rust has the exact same operations as C, so that point is moot at best.
Neither have a runtime.
▶ No.855804
>>855781
>you'll have more serious discussions
>serious discussion about rust on /tech/
LOL. I didn't always LARP as Steve Klabnik and the "discussion" was as shit then as it is now.
Also you are the retard complaining about muh bloat. There is no reason to keep something minimal at all cost only to appease your autism.
▶ No.855817>>855829
How big does your project need to be before it's worth it learning Rust over C++?
▶ No.855829>>855831
>>855817
If your project is big, you probably shouldn't use rust. Unless your time is worth little and you enjoy inordinately long compilation times, that is.
Using rust is never really worth it.
▶ No.855831>>855834 >>855835
>>855829
>muh compile times
Incremental compilation and multiple codegen units are in the beta right now which means it will be in the next stable release.
Rust's incremental compilation model is vastly superior to C++'s btw.
▶ No.855834>>855836
>>855831
HOw is it superior?
▶ No.855835>>855836
>>855831
>Incremental compilation
Here's that meme again. The only support for it I've seen are cherry-picked toy benchmarks based on recompilation after trivial changes. C++ modules will make rust compilation times look even worse when they're added in C++20 btw.
▶ No.855836>>855845
>>855834
Educate yourself:
https://github.com/nikomatsakis/rustc-on-demand-incremental-design-doc/blob/master/0000-rustc-on-demand-and-incremental.md
https://blog.rust-lang.org/2016/09/08/incremental.html
>>855835
>Here's that meme again
It hardly is a meme when it is working right now.
>The only support for it I've seen are cherry-picked toy benchmarks based on recompilation after trivial changes.
Bullshit.
>C++ modules will make rust compilation times look even worse when they're added in C++20 btw.
>when they're added in C++20
>C++20
ok
▶ No.855845>>855854
>>855836
>It hardly is a meme when it is working right now.
It's a meme because rust fanatics are way overstating whatever benefits it provides.
>Bullshit.
no u
>>C++20
>ok
The best part is that C++'s compile times (for normal code that doesn't retardedly abuse templates) are already better than rust's. And they're just going to get even better.
▶ No.855852>>855853 >>855859 >>855867
If you're new to programming should you learn c++ or rust?
▶ No.855853
>>855852
Rust. Since it rejects programs that have memory errors, you get into the habit of writing memory-safe programs regardless of which language you'll use after.
▶ No.855854>>855859
>>855845
The best part is that Rust's compile times (for normal code that doesn't retardedly abuse generics) are already better than C++'s. And they're just going to get even better.
Anyways, kill yourself anti Rust shill.
▶ No.855859>>855869 >>855875
>>855852
C++. Not only does rust's borrow checker impose a worthless cognitive load on a beginner, but it also prevents learning through mistakes about the underlying machine, meaning you will never be as good a systems programmer as someone who started with C++. C++ can also provide a more sane and gradual learning curve for certain concepts also used in rust, like move semantics.
>>855854
>Rust's compile times (for normal code that doesn't retardedly abuse generics) are already better than C++
Wrong. As long as overhead from the borrow checker exists, C++ will dominate in that regard. In other words, the only way for rust to catch up is to abandon its reason for existing.
▶ No.855863>>855864
Random thoughts about the evolution of this thread :
1. You're all just a bunch of non-rustaceans
2. The worst elements from the Ruby community, which was already a cesspool, moved to Rust
3. You will never make the ladies wet like Steve does
4. Steve is an insufferable personality yet he still has more success than all of you
5. You will never write the reference book for a language unlike he/them
6. A good sign you CS curriculum is weak : your operating system class is not in Rust
▶ No.855864
▶ No.855867
>>855852
neither nor
you should pay attention to your data structures and algorithms class if you are in a strong CS curriculum otherwise this will be a Java enterprise class and then move straight to an academic functional language so you will become unemployable for your own good
▶ No.855869>>855870 >>855873
>>855859
>waaah leaking memory and overrunning buffers is perfectly normal
>waaah how dare you not create insecure software bigot virgin sexist!
>learning to write safe and performant software is BADONG! only swiss-cheese software is diverse!
t. NSA
▶ No.855870>>855875
>>855869
>everything in rust is totally secure and has no flaws
No.
▶ No.855873>>855877 >>855879 >>855932
>>855869
>rust faggots accusing others of sjw behavior
That's a new one.
Also, you can use smart pointers, static code analysis and some basic discipline to write safe code in C++.
▶ No.855875>>855886
>>855870
>I make strawman then refute it
I win.
Have you considered making a C++ instead of shitting up this one? Kill yourself anti Rust shill.
>>855859
>muh borrow checker
>muh learn how computers actually work
So why not asm then? C++ is also way to high level. Kill yourself anti Rust shill.
▶ No.855876>>855880 >>855888
>>854910
>I only see you guys discuss the SJW boogeyman but never discusses the technical aspects of the language
The reason I won't use it is because it won't use the OS's native toolkit, whether that is GTK, QT, or Win32. Even fucking Java with SWT can do that. Consistency is important to me, and a application that sticks out like a sore dick has no place on my machine.
▶ No.855877>>855886 >>855894
>>855873
Modern C++ is not memory safe though.
▶ No.855879>>855882
>>855873
C++ fag here, modern C++ is a trainwreck. Any spec past C++11 is cancer.
▶ No.855880
>>855876
>rust bindings for gtk, qt, and win32 don't exist
Prove it
▶ No.855882>>855883
>>855879
>no argument
Like pottering.
▶ No.855883
>>855882
What's the point of arguing? Everyone here will just have an autistic shit fit when you point out anything, there's no point anymore.
▶ No.855886>>855893 >>855899
>>855875
>So why not asm then?
For one, asm is not portable. Although, I do think writing asm is a good exercise.
>>855877
It doesn't need to reach your retarded standards of perfection to be safe enough, though.
▶ No.855888
▶ No.855893>>855897
>>855886
>not having iterator invalidation is a retarded standard of perfection
C++ is a shit language that gets even shittier with every new version. You literally can't defend this fucking trainwreck.
Now either leave this thread or kill yourself, anti Rust shill.
▶ No.855894>>855897
>>855877
Then why does the new firefox leak memory out the ass?
▶ No.855897>>855911 >>855915 >>855932
>>855893
<haha! C++ doesn't have [arbitrary safety feature X]! Unsafe! Unsafe!
You still need to prove that this absence causes real, significant problems that are common in real modern code (as in, not just imagined by you due to your safety paranoia).
>>855894
Because ultimately, no amount of safety can stop a bad programmer from producing horrible shitcode. Also, as rust tries to shield programmers from their mistakes, it's not surprising that rust coders would become unable to think critically about their code.
▶ No.855899>>855908
>>855886
There are portable assemblers as well as asm-like languages such as Z# or whatever that was called. You literally have no excuse. Not that I expect better from sophist prime the master of all illogic.
▶ No.855908>>855911
>>855899
>portable assemblers
Defeats the point of writing asm in the first place.
>asm-like languages
Defeats the point of writing in higher-level languages.
Maybe you misunderstand; (zero-overhead) abstractions are fine as long as they don't try to make the underlying machine completely inaccessible, as rust tries to do.
>sophist prime the master of all illogic
wew lad
▶ No.855911>>855917
>>855897
>You still need to prove that this absence causes real, significant problems that are common in real modern code (as in, not just imagined by you due to your safety paranoia).
Literally any C/C++ codebase
>muh bad programmers
Kill yourself anti Rust shill
>>855908
>as rust tries to do.
Wrong. Any proof to back up your claim?
▶ No.855915>>855920
>>855897
Ever heard of heartbleed? Goto fail? Ariane5/cluster? The two mars rovers? Maybe you should use google sometimes, or stop living under a rock.
▶ No.855917
>>855911
>Literally any C/C++ codebase
So you say.
>Wrong. Any proof to back up your claim?
How about the fact that every problem rust hides under the carpet has to do with the reality of the underlying machine? e.g. those spooky scary segfaults
Of course, you can use unsafe blocks, but at that point you may just as well use C/C++.
▶ No.855920>>855926 >>855927
>>855915
>heartbleed
>Goto fail
>Ariane5/cluster
>modern C++ code
No, not very modern.
▶ No.855921>>855930 >>856081
>>854901 (OP)
https://marc.info/?l=openbsd-misc&m=151233345723889&w=2
> As a response to this, Theo asked rhetorically "Where's ls, where's cat,
> where's grep, and where's sort?", implying that noone so far bothered to
> write implementations of even the basic unix utilities in such a
> language.
I wasn't implying. I was stating a fact. There has been no attempt
to move the smallest parts of the ecosystem, to provide replacements
for base POSIX utilities.
As a general trend the only things being written in these new
languages are new web-facing applications, quite often proprietory or
customized to narrow roles. Not Unix parts.
Right now, there are zero usage cases in the source tree to require
those compiler tools. We won't put a horse into the source tree when
society lacks cart builders.
> This brings me to the question, what if someone actually bothered?
So rather than bothering to begin, you wrote an email.
Awesome.
Yes, now I am implying something: you won't bother to rewrite the
utilities.
And I understand, why would anyone bother? It took about 10 years for
gnu grep to be replaced sufficiently well in our tree. This stuff
doesn't happen overnight.
However there is a rampant fiction that if you supply a new safer
method everyone will use it. For gods sake, the simplest of concepts
like the stack protector took nearly 10 years for adoption, let people
should switch languages? DELUSION.
> Under what conditions would you consider replacing one of the
> current C implementations with an implementation written in another,
> "safer" language?
In OpenBSD there is a strict requirement that base builds base.
So we cannot replace any base utility, unless the toolchain to build
it is in the base. Adding such a toolchain would take make build time
from 40 minutes to hours. I don't see how that would happen.
> Note that with Cgrep and haskell-ls, there do in fact exist
> implementations/analogues of two of the mentioned utilities in a
> memory safe language (Haskell).
Are they POSIX compliant? No. They are completely different programs
that have borrowed the names.
By the way, this is how long it takes to compile our grep:
0m00.62s real 0m00.63s user 0m00.53s system
Does Cgrep compile in less than 10 minutes?
Such ecosystems come with incredible costs. For instance, rust cannot
even compile itself on i386 at present time because it exhausts the
address space.
Consider me a skeptic -- I think these compiler ecosystems face a grim
bloaty future.
▶ No.855926>>855932
>>855920
>examples are c
>muh c++ XDDDD
pathetic
▶ No.855927>>855932
>>855920
>moving the goalposts
>while pretending modern C++ has magical features it doesn't have
So you're just shitposting then.
▶ No.855930
>>855921
You could at least have the decency not to post the most basal of lies that can be discredited even by 5 years old children with an internet connection.
▶ No.855931>>855934 >>856848
>rust cannot even compile itself on i386 at present time because it exhausts the address space.
Post your smug faces to react to this
▶ No.855932
>>855926
The conversation was about modern C++, so why the fuck did you post C-specific examples in the first place?
>>855927
>>moving the goalposts
Let me check those goalposts:
>>855897
>modern code
>>855873
>write safe code in C++
Looks like the goalposts have stayed put.
>magical features
No magic needed, just
>smart pointers, static code analysis and some basic discipline
▶ No.856067>>856071 >>856093
>>855644
The reddit spacing meme doesn't make sense to me. Why would you press space only once? When the fuck would you ever want a line of text to be on the next line, rather than having a space between them? That's not how paragraphs work. If anything, it would be reddit spacing if they're pressing enter 3 times, not 2 times.
▶ No.856071
>>856067
Because an army of plebbit faggots injecting dozens of spaces into their blog posts makes threads long af to scroll through.
▶ No.856081
>>855921
> As a response to this, Theo asked rhetorically "Where's ls, where's cat,
> where's grep, and where's sort?", implying that noone so far bothered to
> write implementations of even the basic unix utilities in such a
> language.
Well, I fritter away some more idle minutes running another
ten or so iterations of running my shell script, adding and
removing switches, carefully checking that no commands are
aliased, that my search path is correct, that I'm actually
running grep on the correct files and that I am really
invoking grep without the "-h Do not display filenames"
switch. I check the non-setting of "-h" many times, since
having it set would produce exactly the sort of lossage I
was experiencing.
Finally, about to tear my hair out, I happen to type "c-L"
in the Emacs buffer in which the grep options are displayed.
This recentres the window such that three additional lines
appear at the top of the buffer's window. I read
----------------------------------------------------------------------
want the filename to appear, use /dev/null as a second file
in the list.
----------------------------------------------------------------------
ARRGGGGGGGGGGGHHHHHHHH.
I scroll back and read the whole screen:
----------------------------------------------------------------------
When any of the grep utilities is applied to more than one
input file, the name of the file is displayed preceding each
line which matches the pattern. The filename is not
displayed when processing a single file, so if you actually
want the filename to appear, use /dev/null as a second file
in the list.
OPTIONS
-b Precede each line by the block number on which it was
found. This is sometimes useful in locating disk block
numbers by context.
-c Display a count of matching lines rather than
displaying the lines which match.
-h Do not display filenames.
----------------------------------------------------------------------
The iron spike of enlightenment finally punches through into
my cerebellum "... ... ... so... so... so... you
mean... there's ANOTHER reason why Emacs always appends
/dev/null to its m-x grep command-line! ... Well f__k me
harder again and again! ... errgghhhh... FEELINGS are
cascading over me!!!"
Incidentally (or not -- YOU be the judge!) this is EXACTLY
the kind of bullshite which makes the "ls" command lose so
badly (and which, incidentally, contributes to every unix
FTP server flagrantly violating the FTP spec): the default
filename argument for "ls" (the current directory) is
totally different from specifying "ls * .*" (which one might
think would be the same thing) because bloody cretinous "ls"
descends into subdirectories which are specified on the
command-line, even those without a trailing "/" (even if
unix had some command-line convention to discriminate
between "the directory" and "the files of the directory",
which it doesn't) and even those which are a result of a
wild-card expansion (even if unix commands knew anything
about wild-cards, which they don't.)
(I won't even start to rant on the matter of needing ".*" in
addition to "*" to get all of the files in a directory. I
won't. I won't. I won't.)
Anyway, I now feel so much better for knowing why Emacs does
what it does.
I'm now a grep wizard! I can probably get a job as a
high-powered unix system administrating consultant, the sort
who just recently hosed three day's of my mail.
▶ No.856090
>>854914
>C++
Nice meme, but I don't think C++ can even be compared to C at this point anymore.
▶ No.856093>>856097
>>856067
>That's not how paragraphs work
The lines are too short to be called paragraphs. Look, they don't even wrap to a separate line.
▶ No.856097>>856100
>>856093
Looks longer in the reply box.
▶ No.856110>>856121
>>856100
>stretching it to retarded lengths
It feels wrong to have it any size other than default.
▶ No.856115
>>854914
security through obscurity
▶ No.856121
>>856110
then just be conscious on what your post will look like after you post it.
▶ No.856125>>856126
▶ No.856126>>856128 >>856645
>>854914
the catch is that it's still not there yet, and the development team is too impotent to fix some unsoundness bugs from 2012 (it's been almost 6 years!): >>856125
▶ No.856128
>>856126
oops I mean 2013 of course
▶ No.856163>>856190
▶ No.856190>>856197
>>856163
>bump
it's not /b dumbass
▶ No.856197>>856396
▶ No.856245>>856249
>2017+1
>still complaining about muh reddit spacing
KILL
YOURSELVES
FAGGOTS
▶ No.856249
▶ No.856396
>>856197
sage reapplied rustkike
▶ No.856645>>856646
>>856126
Imagine if the core queers weren't wasting time on crap like buttfucking and microaggressions.
▶ No.856646>>856653
>>856645
Imagine if the /tech/ LARPers weren't wasting time on crap like browsers and language wars.
▶ No.856677>>856678
>>855004
why is everything deleted?
▶ No.856678>>856679
▶ No.856679>>856761 >>856783
>>856678
>Ashley has already received a bunch of harassment from the Node community on this, and let's not repeat that here.
>To address the common concern that was brought up: The mod team does not consider hyperbolic comments she made years ago, in an informal venue, in frustration, to be a problem. (And some of us have discussed this with her directly as well).
LOOOOL
▶ No.856761>>856770
>>856679
whos this ashley person? a tranny?
▶ No.856770>>856772 >>856775
▶ No.856772>>856835 >>856960
>>856770
With a nice group of white knights
▶ No.856775>>856783 >>856960
>>856770
>be rust dev
>tell everyone how your COC is the most important thing of your project
>hire a woman who violated the COC at her last job multiple times
>???
>its okay because shes a woman in tech
EXPLAIN THIS, RUSTFAG
▶ No.856783>>856784
>>856775
read this >>856679
if you still disagree you fucking woman hating racist mail the rust moderation team
▶ No.856784>>856789 >>856960
>>856783
So she never got reprimanded but you're no longer allowed to yell at her?
The issue has never been addressed but it's over now?
▶ No.856789>>856793 >>856803
>>856784
>The mod team does not consider hyperbolic comments she made years ago, in an informal venue, in frustration, to be a problem. (And some of us have discussed this with her directly as well).
She wasn't serious about it so there is no need to reprimand her.
You are not allowed to yell at anyone in spaces where the CoC applies to.
The issue has been addressed.
▶ No.856793
>>856789
I hate women.
j/k i wasn't serious about it :^)
▶ No.856803
>>856789
>She wasn't serious about it so there is no need to reprimand her.
If the roles were reversed and a man did what she did, he would've been thrown out of the industry so fast his head would spin.
>The issue has been addressed.
The fags who drank the Kool-Aid aren't the ones you need to convince, it's everyone else who sees shit like this and thinks twice about using your language that needs convincing, and repeating the same line of bullshit over and over again isn't going to do the trick.
▶ No.856835>>856836
>>856772
repeat after me:
I shall never post screenshots in JPEG
▶ No.856836>>856850
>>856835
is it readable? yes
fuck off autismo
▶ No.856848
>>855931
>i686 master race
▶ No.856850
>>856836
>autismo
>8ch
>/tech
where the fuck do you think you are, fucking normie?
▶ No.856855>>857127
>>856854
disregard trip, i suck cocks
mods pls delet
▶ No.856856>>856871
>>856854
>60 character line length limit
>hurr how could i have known....
leave it to the turkroach to be even more retarded than the klabnik imposter
▶ No.856871>>857149
>>856856
>everyone should conform to MEEE MEEE MEEEEEEEE
>>>/auschwitz/
▶ No.856960>>857127
>>856772
Beta cucks in search of a mother. Not like they want to fuck her look at her face
>>856775
This. Double standard douchebags.
>>856784
That's where vigilante justice comes in. See >>856052
▶ No.857127>>857151
>>856960
>Not like they want to fuck her look at her face
to be fair, looks fuckable. not 10/10 of course, maybe 6/10
>>856855
you can delete your own posts, dinghole
▶ No.857149>>857662
>>856871
>MEEE MEEE MEEEEEEEE
says the fag who doesn't consider how his mental diarrhea looks with a sane line length
▶ No.857151>>857176
>>857127
>to be fair, looks fuckable. not 10/10 of course, maybe 6/10
No. Don't base your rating on its profile picture. Look its talks up on jewtube. 3/10 max.
▶ No.857176
>>857151
This. Seamonster for sure.
▶ No.857560>>857562 >>857593 >>857661
Rust uses the method len to get the number of characters right? No, faggots in Rust made it the number of bytes. So rather than using size and making sense, they used len in a confusing way. They admit it was a mistake but won't fix it because Rust has to remain backwards compatible forever.
RUST IS ALREADY A DEAD LANGUAGE
▶ No.857562
>>857560
C counts the number of bytes too.
▶ No.857593
>>857560
it's not wrong to give the length of the string in bytes, it's just not what your Pajeet Java brain expects because you're mentally inferious to the Rust programming Ubermen
▶ No.857653
>>854901 (OP)
>t. complete newfag
see you in 2020. bye.
▶ No.857661
>>857560
String in Rust's std are stored in UTF-8. That means that getting the number of codepoints in the string takes O(n) time. Getting the number of bytes is O(1). In the whole std len() is always O(1). So it would be confusing if it wouldn't be the case for strings.
If you want the number of codepoints do this: my_string.chars().count()
>They admit it was a mistake
source?
▶ No.857662>>857673
>>857149
I'm another anon, and you're still a faggot. If it looks like a fucking paragraph on my screen it is a paragraph.
>16:9
>sane line length
Anon, I...
▶ No.857673
>>857662
You are retarded. I did not mention aspect ratios.
▶ No.858468
Hey there cuckchan /g/ refugees! Please discuss Rust. Thanks! <3<3<3
▶ No.858493>>858508
Rust and Ruby start both with the same 2 letters.
Just saying.
▶ No.858508>>860818
>>858493
You can't write Trust without Rust.
Just saying.
Kill yourself, reddit spacer.
▶ No.860673
▶ No.860818
>>858508
2 good names for fork langs if the SJW queers ever force it, Trust and Just.