Diseased Open Source Software Community - it's about ethics in Code of Conducts

[Kola]

Also "you can't update an array", you can, it has to be mutable, however.

Having to make a conscious decision to make a piece of data mutable is extremely beneficial, it forces you to write good, stateless, predictable code, and it forces contributors to do so too (if you have them). Immutable data structures keep debugging and reasoning about your program simpler and more organized. That's why it's the default in Rust. And event in scripting languages like Typescript or python, there are already many libraries that help you design your data structures around immutability. React is based around this concept as well.

 

[Kiwi & Cow]

That sounds more like a praise than an insult.

Also "you can't update an array", you can, it has to be mutable, however. Which is a good thing, as it avoids undefined behavior and works all of the time. Go try modifying a global const array in C and try it on all platforms, it won't work.

Good C code is equivalent to normal Rust code, since both avoid UB and data races. The actual feature of Rust is that it prevents you from writing racy or undefined behavioral programs.

Don't talk about programming languages you haven't written a single line of code in. Rust is a great solution for systems programming.

It is very soothing to autistics.

His words, not mine, sperg.

 

[Coolio55]

Does rust have a mechanism to stop random functions from calling exit() at any time?
That sounds like the sort of thing that keeps const-ant whiners up at night.

 

[Perfect Paz]

That sounds more like a praise than an insult.

Being unable to do things without jumping through a bunch of gay hoops is cancer. Deliberately making your programming language harder to use is idiotic.

 

[named]

Don't talk about programming languages you haven't written a single line of code in. Rust is a great solution for systems programming.

I'll make a serious response to this even though my previous posts in this thread were part of what got it bumped to Infected.

Rust is great for solving very straightforward problems that would likely be very trivial in C. Rust, especially in its current state, is not great for systems programming. You can use it for that, but it doesn't really buy you a ton of advantage over C++ other than having a marginally better type system.

Rust's design was a response to Go, Java, and similar classes of languages that, fundamentally, assume that the user is stupid. Rob Pike was explicit about that when he was designing Google Go, and Rust retains the same assumption. Since it assumes that the user is stupid, it makes it incredibly annoying to do valid but difficult-to-verify operations. Rust's borrow checker suffers from a similar problem to FP languages - the language model sometimes requires convoluted solutions from a classic procedural language's point of view to accomplish simple tasks.

The borrow checker is only able to check simple hierarchies and cannot handle cyclical data structures without unsafe or workarounds such as quasi-pointers (indices into pre-allocated arrays, such as for a ring buffer). While quasi-pointers will stop you from outright crashing, they will not stop you from accessing incorrect data within a correctly allocated array. If you correctly calculate your index, then you would also have correctly calculated your pointer if you were using C; and Rust's Vec<T> is mostly reliant on runtime bounds checking. While this allows you to confine pointer wizardry to specially designated areas of the code, you can also accomplish that task in C by a policy to rejecting PRs which do that. The Rust compiler has some support for eliding bounds checks if it can guarantee that the index falls within a range, but it can only do that for very simple cases.

The borrow checker also immediately runs into other language features, such as async/Futures. Futures are extremely important for current Rust server programming models since they tend to be modeled as an epoll loop that dispatches a future. Essentially any data used by futures will either need to be accessed through an Arc<Mutex<T>> (which can impose a significant performance penalty for things which don't really need to be locked) or be 'static + Send + Sync.

As a side note, when I personally used Rust some time ago, certain types---which I felt weren't particularly complicated compared to what I used to do in C++---would cause the compiler to crash outright. I'd rather deal with Boost again. It might output inscrutable error messages on error, but at least the happy path reliably works.

Also "you can't update an array", you can, it has to be mutable, however. Which is a good thing, as it avoids undefined behavior and works all of the time. Go try modifying a global const array in C and try it on all platforms, it won't work.

As you're well-aware, you can only have a single live mutable reference to an array in Rust, and porting a C implementation directly to Rust will frequently cause compiler errors due to this. C++ will allow multiple mutable references to a global mutable array, and it's the programmer's responsibility to ensure that write accesses are managed properly in a multi-threaded environment.

 

[Kola]

Being unable to do things without jumping through a bunch of gay hoops is cancer. Deliberately making your programming language harder to use is idiotic.

No, making dumb things harder to do is actually a major concept in the development of programming languages and software in general. If you want to do them, you have to make sure they're 100% deliberate and you know what you're doing. An idiot admires complexity. A genius admires simplicity.

 

[Rusty Metal Skull Gun]

Does rust have a mechanism to stop random functions from calling exit() at any time?

It's considered idiomatic that any function can panic, which effectively always leads to exit(). This is one of many things about Rust which I dislike.

No, making dumb things harder to do is actually a major concept in the development of programming languages and software in general. If you want to do them, you have to make sure they're 100% deliberate and you know what you're doing.

Rust makes programs harder to write by its nature, but a lot of the time there's no benefit to this. The majority of the programs anybody writes (with the exception of maybe game developer) are going to be single-threaded, which makes a lot of the borrow-checker stuff pointless.

 

[named]

No, making dumb things harder to do is actually a major concept in the development of programming languages and software in general. If you want to do them, you have to make sure they're 100% deliberate and you know what you're doing. An idiot admires complexity. A genius admires simplicity.

I fundamentally agree with you that most problems are caused by programmers trying to be too clever in areas that don't require it. However, Rust takes a very extreme approach. "Difficult to (automatically) validate" is not the same thing as "dumb," and many of the tasks that Rust classifies as "difficult to validate," such as reasoning about internal references within a cyclical data structure, are fairly trivial to do and can be reliably done by a freshman CS student with no prior experience after a few weeks of class.

The Rust compiler developers don't try to solve this general class of problems because the Rust compiler isn't a generic theorem prover, which I completely agree with, but it also means that most of what you would use raw pointers for in modern C++ will still require unsafe blocks in Rust.

The majority of the programs anybody writes (with the exception of maybe game developer) are going to be single-threaded, which makes a lot of the borrow-checker stuff pointless.

Even in a single-threaded environment, Rust advocates will claim that the borrow-checker prevents null pointer dereferences and use-after-free. I think this is not much of a problem in modern codebases since modern C++ tends to avoid raw pointers, though.

 

[Perfect Paz]

No, making dumb things harder to do is actually a major concept in the development of programming languages and software in general. If you want to do them, you have to make sure they're 100% deliberate and you know what you're doing. An idiot admires complexity. A genius admires simplicity.

I agree, idiots admire complexity. So, bearing that in mind:

Rust--pointlessly complex, nannies the programmer because he needs his hand held
C--simple, just werks, the programmer can do as he pleases, because it's presumed he's not retarded

 

[Kiwi & Cow]

No, making dumb things harder to do is actually a major concept in the development of programming languages and software in general. If you want to do them, you have to make sure they're 100% deliberate and you know what you're doing. An idiot admires complexity. A genius admires simplicity.

I'll just make this clear, the whole praise you're giving Rust is retarded and using that quote doesn't even work cuz this applies to what is being made and how it's made, not the tools or fundamentals. Nobody cares if you use a wrench or a crowbar to get something done. Nobody admires wrenches and crowbars.

Also I'd like to remind ya Null only uses Rust as a meme language to piss off troons. If Rust wasn't associated with troons and didn't have that novelty as a meme language he would've used PHP or Python which are by all means far better for this stuff anyways.

It is, which is why picking Rust will objectively cause the most anal pain and hilarity.

https://kiwifarms.st/threads/xenforo-has-revoked-our-license.106654/post-10604077

https://kiwifarms.st/threads/xenforo-has-revoked-our-license.106654/post-10604091

Null uses Rust the same way a professional gamedev uses RPGmaker. RPGmaker is horseshit and worse than Unity, but gamedevs use it because they're lazy, too illiterate to learn anything better albeit harder (sounds familiar?) or shitposters who give 0 fucks. Null falls into the last category BTW.

Stop hyping up this dogshit made by and for troons.

 

[Kola]

I agree, idiots admire complexity. So, bearing that in mind:

Rust--pointlessly complex, nannies the programmer because he needs his hand held
C--simple, just werks, the programmer can do as he pleases, because it's presumed he's not retarded

Then it's presumed wrong. On any project, there's going to be a number of people working on it (when you're working on it solo, that's going to be you on different days). And yeah you're going to be retarded sometimes, when you're tired, annoyed, distracted, have to work with tight deadlines, etc. There's a million opportunities for programmers to make errors even when you assume best intentions and top skills. You want the technology to be holding your hand and preventing you from making those errors. Junior programmers often think programming is like an intelligence test where you've got to make it as clever as possible and scoff at the thought of writing simple code and the compiler guiding you through it. That's what that quote means.

 

[Perfect Paz]

Then it's presumed wrong. On any project, there's going to be a number of people working on it (when you're working on it solo, that's going to be you on different days). And yeah you're going to be retarded sometimes, when you're tired, annoyed, distracted, have to work with tight deadlines, etc. There's a million opportunities for programmers to make errors even when you assume best intentions and top skills. You want the technology to be holding your hand and preventing you from making those errors. Junior programmers often think programming is like an intelligence test where you've got to make it as clever as possible and scoff at the thought of writing simple code and the compiler guiding you through it. That's what that quote means.

Cope, all of this is by having non-retards writing your software in the first place, and in a worst case scenario, the code review process.

 

[Kola]

Cope, all of this is by having non-retards writing your software in the first place, and in a worst case scenario, the code review process.

With experience comes humility and then you realize that you can use technology to assist you instead of turning software development into a dick measuring contest.

 

[Perfect Paz]

With experience comes humility and then you realize that you can use technology to assist you instead of turning software development into a dick measuring contest.

Except Rust doesn't assist me, it gets in my way. Also I've been writing software for a living for more than a decade so fuck off with this condescending autism

 

[Kiwi & Cow]

With experience comes humility and then you realize that you can use technology to assist you instead of turning software development into a dick measuring contest.

The point of programming language (and why c is still popular, in spite of how old it is) is that you can dictate exactly how your software behaves. You can't do that with Rust because it's so far removed from the base computer code. So most serious devs will probably have to rely on another language like Null did when he had to rely on c and lua.

You're defending the indefensible I'm telling you.

 

[Kola]

Except Rust doesn't assist me, it gets in my way. Also I've been writing software for a living for more than a decade so fuck off with this condescending autism

And you're still this insecure about your ability?

 

[UERISIMILITUDO]

C'mon baby, let's get to plagued status.

Don't talk about programming languages you haven't written a single line of code in.

I've written trivial Brainfuck programs. Don't criticize Brainfuck without the same level of experience.

Rust is a great solution for systems programming.

No, it's a meme.

Being unable to do things without jumping through a bunch of gay hoops is cancer.

I want to use another example from Ada: Ada has nominal strong typing, a particularly strong form of strong typing, meaning that even identical types with different names can't be treated identically; this enforces modularity. The programmer is forbidden from reaching into the internal representation of a private type and treating it like another type, even if he knows it's the same type underneath. This maintains the package boundary the interface sets up, now doesn't it? In fact, Ada allows the programmer to define types that have many restrictions, such as no assignment, no equality comparisons, and even no ability to declare a value of the type without providing more information where required. All of this is very useful for defining mechanisms beyond the language specification.

In C and UNIX land, the systems programmer can define types that are actually safe from certain manipulations, namely file descriptors, but everyone else struggles to approximate that. Isn't that inconvenient and restrictive for no good reason?

Deliberately making your programming language harder to use is idiotic.

Power tools have legally mandated safety mechanisms. I almost lost a limb once, but the safety mechanism shut down the machine before it mutilated me. Programming languages are no different.

While this allows you to confine pointer wizardry to specially designated areas of the code, you can also accomplish that task in C by a policy to rejecting PRs which do that.

Come now, the C language not only makes certain things extremely difficult, but it requires them everywhere. Ada yet again does it right by having access types, but making them very easy to avoid. The programmer can't even get by-reference parameter passing in the C language without using a pointer.

The Rust compiler has some support for eliding bounds checks if it can guarantee that the index falls within a range, but it can only do that for very simple cases.

Trying to remove necessary checks is a mental illness.

Nobody cares if you use a wrench or a crowbar to get something done.

In fact, people do care when the wrong tool is used for a job, as it implies incompetence and ignorance, and it can lead to lesser work very easily. Try painting with a toothbrush next time.

You want the technology to be holding your hand and preventing you from making those errors.

With experience comes humility and then you realize that you can use technology to assist you instead of turning software development into a dick measuring contest.

These people will never understand that, because their egos rely on this worthless knowledge. Why, if programming were easier, and if more people could do it, they couldn't lord it over normal people like wizards anymore. Their voice is clear: Humanity got it right in the 1970s, not before, and not after; everything should stay like that, forever.

The point of programming language (and why c is still popular, in spite of how old it is) is that you can dictate exactly how your software behaves.

No, there are plenty of constructs that are impossible to express in the C language. C language programmers just like to pretend that they're controlling the computer directly, when they're no better than any other language running under a huge operating system.

Woah, I'm directly manipulating (virtual) memory (except the stack which doesn't count) and directly controlling the hardware (by making calls to the operating system that has tens of millions of lines of code)! I'm the master of the universe!

 

[Hồ Chí Minh]

Ya'll need to check your autism and go back to laughing at trannies doing stupid tranny shit.

 

[Kiwi & Cow]

Ya'll need to check your autism and go back to laughing at trannies doing stupid tranny shit.

Would be good if the Rust dickriders here didn't derail the thread everytime someone said something negative about it because y'know it's going to be mentioned often in relations to troons with how overrated it is amongst them.

I literally give no fucks if you like Rust, go be a preachy prick about it elsewhere.

 

[RGBCube]

give no fucks if you like Rust, go be a preachy prick about it elsewhere.

And you proved that by sperging about it for I don't know how many posts. Lmao

Anyway, the conclusion I derive from this thread is that most people are retarded and should have a superior that makes their decisions for them because they're incapable of seperating the politics from technical capabilities.

Saying that Rust is bad while saying C++ is good is not possible if you're not blatantly unaware of what people actually working with huge C and C++ codebases have been trying to achieve with new standards.

I urge these C++ lovers to mess with C++ templates, contracts and recursive template definitions and then try out Rust's trait system. It is like a breath of fresh air.

Also - C and C++ are also plagued by these undesirables, it's not exclusive to Rust. Lots of what you guys would call "based" people work with Rust and prefer it over C/++.