Rust is growing stronger by the day

>it's easy to make a better C
Then why hasn't anyone done it yet?

Haha you sure got him bro XD XD
*highfives*

it has been, several times. but that doesn't guarantee adoption

white male programming = get job done

Attached: WHITE MALE POWA.jpg (1156x1848, 308K)

C will be destroyed eventually, at least in the sense that very little new code will be written in C compared to today. However, it will be at the hands of Zig or V or one of those other languages that are actually C replacements rather than C++ replacements.

It is memory safe if you take an amnestic beforehand,

Rust can't replace C. C is dead simple and blazing fucking fast, compiles within seconds. The only other language that can achieve that is Zig.

>dead simple
untrue
>blazing fast
untrue
>compiles within seconds
that's slow

C is not simple

people.eecs.berkeley.edu/~necula/cil/cil016.html

maybe you're a fucking pro and you can guess all of these, but as someone who doesn't know C I don't understand why half of these are the way they are

What the fuck are you on? Last time I tried compiling a C project it took 45 minutes

Fresh from yesterday's thread. Rust is unusable.

Attached: rust.png (900x2648, 296K)

Also

way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

Zig is the most promising right now and I love the name, but there are others: V, Muon, D -betterC and others I can't remember right now. Maybe some day Mr. Blow will release Jai.

Thank you for making a screenshot that is now insanely wide.

Eh?

Rust will be remembered as an important language that helped popularize linear types. But there are already new languages that have learned from Rust, github.com/carp-lang/Carp.

>a literal lisp

A lively linear Lisp.
home.pipeline.com/~hbaker1/LinearLisp.html

anyday now....

It's still a lisp.

kek, try comparing the compile times of a 100kLOC Rust project to a 100kLOC C project.

And?

>inb4 brainlet

I don't like it.

What do you dislike about it? I doubt you've read the paper.

Well, the paper is not about lisp in general. I did not read. I dislike the syntax of lisp. Those parens all over the place. Why are you even asking, surely you should know by now that the majority of programmer population dislikes that shit.

I'm just curious if there is anything thinking behind it or only a gut reaction to the parens. I am not a big fan, personally, but I don't see why people react to them like they're allergic.

of course you can't write that style of code in Rust

why would you try to fit a square peg in a round hole? Rust programming is a different style, you don't make a World struct and try to do everything with it. That's closer to OOP programming.

you wouldn't really have world.get().x

You can't just write Java/C++ in Rust and expect it to work

FWIW I wrote a Go (Baduk) AI in Rust and only had to Arc the board cache so it can be shared between threads

I didn't have any issues after I understood how Arc works

s/anything thinking/any thinking/

A gut reaction to code that looks like unreadable mess.

Please explain it to all the brainlets that pollute C and C++ threads spamming their rust bullshit asking people to convert.

Weak. Spend three days with it, and your perception will change.

Maybe. But I do not want to spend three days with it.

>Last time I tried compiling a C project it took 45 minutes
The Linux kernel, one of the largest C programs you'll encounter, compiles significantly quicker than that on normal desktop hardware.

That doesn't make it fast. There is no reason for million loc projects should not compile in few milliseconds. Computers are fast enough to enable that.

wew lads, that's my daily dose of cringe.

Is there an idiomatic ECS implementation in Rust?

compare incremental builds and touch a header file

once you touch a header file in C, the changes can ripple through the entire codebase, which means you may need to recompile EVERYTHING

when you touch a file in Rust, the compiler only has to recompile things that can potentially be affected

Sure, the final --release build may be slower by like 50%, but you usually make a lot of incremental and debug builds just to check whether your shit is working correctly at all

>and touch a header file
I had so many issues with this because build tool was implemented by idiot who did not use dynamic dependencies generated by compiler.
Also: C linkage is not type-safe. One more point for name mangling.

>of course you can't write that style of code in Rust
I know you still have your penis attached, but your passive aggressive HRT induced psychosis is showing.
>you don't make a World struct and try to do everything with it. That's closer to OOP programming.
Which maps perfectly to game programming.
Kindly fuck yourself.

Attached: D5W9ypzXkAAFLKv.jpg (850x1188, 189K)

>by like 50%
No, it's WAY fucking longer than that. 1 to 2 magnitudes more than that.
Because don't forget: you're not simply compiling your program, but all of your dependencies and all of their dependencies too.

The header file "rebuild propagation" is hardly an issue because C builds so quickly to begin with. Maybe with fuckhueg programs, it's more of an issue, but for most real world programs, we're talking less than 2 seconds.

there's a shitload of them

arewegameyet.com/categories/ecs/

>non-lexical lifetimes block your path
>cyclic data structures blocks your path

>Weak. Spend three days with it, and your perception will change.
Spend three days in the sewer and your perception will change.

Speaking from experience, not really.

youtube.com/watch?v=-9c095aXc-s
youtube.com/watch?v=iD08Vpkie8Q

>C linkage is not type-safe
Unless your build system is brain-dead retarded, this is never an issue. Most good build systems make this sort of shit impossible.

>tfw Rustfags have to defend sewers to justify using their language

Attached: 009.png (763x719, 534K)

woah nice, now let's wait for linus to rewrite his linux in rust

most but posix make and not-so-old versions of eclipse
also assumes programmer doesn't ignore implicit declarations warnings

actually that's the benefit of Rust, you can cache the builds of the dependencies, so every time you recompile the program, even in --release you only compile the crate you changed

Wine takes 45 minutes to build and NOTHING is cached, it's literal fucking autism

oh what's that? your program didn't work in Wine? MAKE ANOTHER CHANGE AND WAIT 45 MORE MINUTES

whereas a recompile (not fresh build) in Rust takes a minute since the dependencies are already built, you only need to build the project

of course a Wine project in Rust would be broken up into several crates for this exact reason: it makes sense to break up your project into some independent parts so you can recompile them separately when working on the codebase