I Hate Rust | Prime Reacts 

Let's go

blazingly fast

But you don't think shipping an app with "bounds checking" is good, right? Also I'm currently learning Rust...dispite me probably never getting to use it at work... but I'm also probably twice your age...I don't think I will ever get to switch jobs in my age. I'm an IDE guy and Rust Rover is realy nice. Also claiming a linked list can't be written sounds like challange to me, or is there scientific proof it actually can't be written?

We're up all night to get Rusty

@@TremereTTthere are implementations of linked lists in standard library, it’s just really hard to write it yourself, especially with no unsafe

This is what is really behind the rust momentum

And take out your holiday related flora.

Happy to see i was not the only one who thought of 24 when that came out :)

@@getcass Wasn't 24 the most successful TV show of all time? I'm sure we four are not the only ones :D

​@@gownerjones Mate it's an obsession, can see those 2 numbers without thinking about CTU :)

And Jack went to Jail

Brainfuck is simpler than both of them ¯\_(ツ)_/¯

it's fairly true😭 The simplicity of it really makes it easy to learn and also less intimidating to start and those to experiment. But yeah it can be thought as hard, you can easily as a beginner trigger a SIGBUS or SIGSEGV or misstype and create a use after free etc. You can even do it by being hasty.

C is simple yet complex, it's like women

@@trenwar yet she's always doing what you're telling her to do, this is because you don't know her native language

preach!

agreed

And people who DO program in C++, can we complain about Rust? Because it solves problems that do not exist.

But I want to complain about both C++ && Rust

@@ciCCapROSTi which one does?

is that not just basic Hindley Milner algorithm w stuff?

@@SamualN IIRC Rust doesn't use Hindley Milner for some reason, but a similar (although simplified) algo. Generally languages using HM can infer more than Rust.

Rust doesn’t infer function return types. Gets rather annoying typing “Result” repeatedly instead of something like “auto”.

Yeah :')

Rust tends to hide skill issues if programmer doesn't know what is happening with the objects and needs assistance with it...

Idk bro I feel like I have a lot of skill issues but I feel much more capable with rust than c/cpp

@@user-uf4lf2bp8t My point exactly...

Incroyable.

Rust's worst enemy are the annoying Rust evangelicals

@@maythesciencebewithyou That is so true. It's like a relligion...

Rust is poetry

@@famoustoxo5644 Another reason not to like Rust than...

@@famoustoxo5644 rust is literally unreadable Kinda like poetry I guess

I feel like if the Go team heard this tagline they would completely embrace it though. The entire point of go is that it's simple. Saying it's for 5 year olds is a compliment because that's what it's trying to be.

Its for 5 year olds or people with no brain cells xD No Wonder why so many people want to learn Go, they simply dont have enough brain capacity to learn something like Rust

@@Luxalpa exactly, if a 5 year old din learn how to write some Go I think Rob Pike would cry his eyes off

The same reason people don't write everything in C. Garbage-collected languages have much better flexibility and dynamic languages have even more flexibility. People rewrite in lower-level languages when they need the performance.

And the lifetimes is a Rust specific problem, refactoring dynamically types languages is a pain, having the compiler kindly point out everywhere your change broke something is fantastic. Although with lifetimes I'm slowling getting the hang of it, I'm learing to lean in on the ellision, and most of all I try to avoid creating structs that hold references, if I can I'd rather get the reference as an argument to a function, helps to avoid having lifetime parameters poluting your entire code base.

ya and also rust LSP is by far best and the fact that you don't need search documentation to understand codebase is the best part of it now i am using typescript and when compared to rust , typescript is soo stupid

That's just Python being shit. An actually good dynamically typed language (of which there are ~3) lets you interactively see if a data type is correct or not.

@@gagagero I only know python, so I'm curious. Let's say you changed a type or a function's API, and forgot to change one of the places where it's used. How would one of the "good dynamically typed languages" help me find that error before it blows up in production?

@@isodoubIet Depending on what exactly you're doing. In simple enough cases, it can be caught by a compiler or static analyser but in more complex cases, the ability to interactively run and redefine functions during runtime helps a ton. And having the ability that if you do fuck up, you can recover without losing state is incredible.

C++ literally doesn't even have seamless interoperability with itself, at least not without non-standard extensions. That said, Rust is absolutely better for acknowledging ABIs outside extern C actually exist unlike ISO. Zig is only as seamless as bare C++ itself, extern C and opaque pointers all the way baby.

​@@MetroidChildI don't think Zig is seamless compatible with C++, Zig has no OOP, so there must be some kind of wrapping

@@ITSecNEO C++ requires you to extern C all permutations of functions you wish to use manually, unless you can guarantee that you and everyone else who are working on the same project are using the exact same version of the same compiler for the entire duration of maintenance, in practice you can only use OOP within a file and not when interfacing with other stuff.

too bad it doesn't have interfaces, I really miss that sometimes.

Why is Rust even used for Web Dev xD Rust shines for low level things and not for Web dev. I don't get it why people always tend to turn the language in a general purpose language

gcc also supports this for c, but unfortunately it's not part of the c standard. You can also do the equivalent of errdefer in c++ if you check if an exception has been throw in the destructor. But exceptions are a mess in c++ so nobody does that.

Yes but C++ is trash, thats the reason no one will ever compare some language with C++

Yes I agree however the bad thing is that it’s hidden to the consumer, where as in Zig/Go is explicit what code will run at the end of the scope.

Who

@@notuxnobux exceptions are just fine in C++.

Can also determine if you're in a consteval state of the function now too.

it's not even close. constexpr and consteval require a lot of template and compiler magic built-ins like std::bit_cast to be actually productive, and you still have a lot of limitations, something like zig is just miles ahead of C++'s poor design. constexpr is nearly meaningless, you can add constexpr to nearly every function, it's a joke keyword because the compiler should be (and generally is) smart enough to pre-compute compile time known values.

​@@marcsfeh Constexpr/consteval function does not need to be templates. What limitations are you talking about? You can add constexpr to nearly every function (and it will work) because almost everything is possible in constexpr (except multi-threading of course), even the entire header is now usable (C++23) and the proposed Simd extension will be constexpr friendly so you don't need to write different code for compile time vs runtime. The compiler is not always able to pre-compute known values but with C++ you can force it to do so. The compiler magic built-ins that you mentioned are only handfuls like std::construct_at, std::bit_cast and you would already be using them for runtime code, so I don't see where the problem is.

@@marcsfeh No offense but I don't think you understand constexpr or what it's for. It's not an optimization switch.

@@isodoubIet no.

what's the difference in practice between AST based macros and zig comptime with comptime if/switch statements? it will generate different AST depending on the arguments you pass the comptime function

@@notuxnobux I don't think you can create new items in Zig, like you can in Rust. Adding functions to impl blocks, declaring new variables, implementing whole traits etc. And that's not even touching proc-macros.

I thought Zig’s comptime was type-aware. Is that not true?

@@airman122469 afaik it's type-aware. However nim's can be both typed and untyped

@@NewStart-mi3uu No, zig just lets you generate const values during the compile/build step. It's super handy and versatile, but it doesn't allow you to write in totally new styles - everything written in zig will look like zig. I see this as a win, since it agrees with normally what IDEs are willing to tolerate for syntax highlighting, auto-complete and code navigation (JSX being a super rare exception). Doesn't mean you can't have seperate files with different DLS in there that you parse at build-time. I really love in-lined DSLs though for sure - Rust somewhat scratches that itch, if only IDEs could support it better.

You've made my evening 😂😂

Especially if you used python with type hints, that would at least show of the complications of generics.

The best comparison was that video that Prime reacted to recently, where a Rust-loving functional bro took a perfectly readable (by anyone) snippet of C code with like 2 ifs & 1 for loop, and went step by step mangling it into crazy functional C++17/20, and then Rust; with the Rust & C++20 being almost identical syntax with the exception of 1-2 library function names., and to him it was "beautiful" and "elegant" b/c no loops/ifs, and simply b/c "it took less lines"; yet it was effectively completely illegible and difficult to understand without a lot of effort (& it had a non-obvious bug). In addition to all the comments saying "wtf that's way worse & unreadable", my fave part was that he profiled the compiled code, and basically every time he made a change, it made it way harder for the compiler to optimize it, and it depending on which optimize settings he chose, it was either far less efficient OR far slower. LOL This video should've compared it to Go syntax, or maybe Zig; or C / classic C++ (C++98) since those are the most widely known & languages it is trying to replace.

@@MadVillain__ I guess they are referring to "From C to C++ to Rust to Haskell". Though they are obviously misremembering bits. For one, there was no profiling of the generated code done. There were simply some comparison between the amounts of generated assembly instructions. The "basic" C/C++ versions had the least amounts of instructions generated for -O2 builds, but had the most instructions generated for the -O3 builds. The "functional" C++ on the other hand had the most instructions generated for -O2 builds and beat out the "basic" C/C++ versions for -O3 builds, only beaten out by Rust, which generated the least amount of instruction in -O3 builds. The Rust version also wasn't really bad to understand. Like sure, if it's the first time you encounter something like a filter or a sum it might be a bit scary, but: (bottom..=top).filter(|e| e % 2 == 0).sum() is a perfectly elegant way to sum up all the even numbers in a range. Also the bug was in the original C version and was pointed out in the video.

​@@lamelama22How can Zig replace Rust, if Zig has nulls, use-after-frees and then one could easily get a segfault?

​@@lamelama22 void* everything, amirite?

Indeed. In fact, the reason Rust is verbose is because they specifically chose to be verbose in those cases. All types could theoretically be inferred, but that gives major problems at API boundaries. A static language with mostly or exclusively inferred types is basically incompatible with the idea of a library ecosystem.

​@@Luxalpacouldn't you just require types on the public components of crates and infer it everywhere else if that was the argument?

Skip D

D is great. It is enjoyable to write, but the standard library docs can be tricky to follow. I honestly wish it was used more, if only for better userguides. Also look out for OpenD in the coming months, a fork some of the core maintainers have moved to due to some issues with D's leadership

Zig also goes without saying. Trying to replicate "simple" things may seem overly verbose in Zig, but it is very enjoyable to use. I'm learning it through making small CLI games. I want to move on to incorporating SDL next for 2D games, and maybe browser-based with Zig to WASM (per Tigerbeetle's demo). I've also seen good things come from using Nim+SDL

Treating it like C or Go? Those are two very different languages. Rust isn't meant to be as low-level as C. You can't do low-level memory management without using unsafe blocks, and there are certain things that you can do in C that are undefined behaviour in Rust. For example: char buf[5]; // this would be UB in Rust. you need to initialize the memory, which makes it slower.

That's what I love most about the language. Instead of trying to make your program fit the language, you get to choose which paradigms and language constructs fit your program the most. For example, if you're writing Go, you will be forced to use reference counting, but in Rust you get to choose whether you want to have reference counting, borrow checking or unsafe raw pointers. And this is true for a lot of features in Rust. Like for example static vs dynamic dispatch. That's also what I used to like about C++ a lot. When people say "use the right tool for the job," this is what they should be referring to instead of picking the right programming language. Your application typically consists of many different pieces, and most programming languages are the right tool for some bits of the program but the wrong tool for other parts of the program. With Rust we actually get the full toolbox and can freely choose which parts of our programs use high level code and which use low level code.

There is beauty in simplicity. Rust fails in that regard.

zig tooling is good in terms of the toolchain aspect. but asides from that the tooling just really bad, zls is slow and barely works and the debugging experience is basically the same in zig and odin.

@@marcs9451 to be fair, when rust was as old as zig is now it wasn't in 1.0 either (despite being corporate backed with multiple employees) and rust tooling was actually worse. Zls works pretty ok in my experience if you install it from git, vscode version was outdated the last time I checked. It also works better if you enable the experimental comptime interpreter.

Why is everyone here talking about Odin. It literaly is yet another C replacement which no one needs. Zig is way better for this purpose...

@@ITSecNEO have you tried coding in odin? it'll really change your mind. like, i was the same as you but coding in it made me like it more than zig.

@@kenneth_romero No, because of the ability of zig to replace gcc and C build Tools directly. What are your reasons for Odin? I want to understand why so much people like it

Python: 1) not typing anything and unknowingly coding functions that have like 4 return types 2) stub file out of date and also separate from half typed library 3) Inheritance making it so I have to drill layers down into their hierarchy and do find in page over and over to figure out who the hell actually defines the function 4) Can’t really put definition links in doc comments so that hover overlay will provide more links to definition (I think you can get tools to do it but no one does, whereas its out of the box in Rust) 5) (1) again: type `Never | None` and `Unknown | None`

Also I have found the joy of compiled languages, I want to know I screwed up something simple long before that execution path happens to get used.

The point where I've found that python code is harder to understand because of dynamic typing rather than easier is when the code gets longer than about a page.

​@isodoubIet hahah 😂😂 that's too funny

Dynamic types in python and stringly untyped stuff in shell scripts is fine for 100-1000 lines that are written once and updated fairly rarely, and especially if they're always updated by the person who wrote the thing: that way, you might remember what types you had in your head. But for Real Applications (™) of non-trivial size, anything that can be automatically proven about your program (such as the types lining up) is incredibly helpful, even if you have to spend a bit of extra typing time to leverage the prover. Well, actually-I think that's true for a sufficiently expressive type system. Parameterized types are a bare minimum. Nice support for linearity and session types is a bonus, but rarely a deal breaker. (I like higher-kinded types for higher-level abstractions, but that's more of an expressiveness thing than a verification thing.)

You mean Rust++ 43 ;)

why would one not be able to maintain old legacy code?

@@NewStart-mi3uuyes, It's legit amazing. I love it, and I am on a mission to slowly start tempting my coworkers and really anyone who will listen how absolutely fantastic it actually is, and how much more fun it is writing almost anything in it. there are a few cases where you don't want it, mostly EXTREME performance code, or ultra low latency stuff, like realtime audio, or embedded systems, where you just can't have a garbage collected language. but for normal code, there isn't much out there that has such a developer friendly way of writing than the ML languages do. Highly recommend fsharp or ocaml. you will not regret it. look up Scott Wlashin's great videos like "functional programming for C# developers" or "domain Modeling Made Functional". it's just so empowering. great stuff.

And C++ even since it was "C with classes". Imagine thinking that strong typing and scoped resources management is somehow revolutionary.

@@franciscomalmeidaWhat's crazy to me is that Javascript has become the point of reference for everything else

It's a terrible example, it manages to show off exactly zero unique features but with unreadable abstract syntax. The Rust compiler is great exactly because it goes beyond this basic type checking.

You didn't know? Rust enthusiast believe there's only three languages: Rust, JS and C. Example: - Hey, why you chose Rust? - I don't wanna write unsafe C code ridden with memory bugs, duh. - Why not try languages other than C? - But Javascript doesn't have static types. It's like they only learn programming from social media and if language is not popular there - it doesn't exist.

@@janAkaliKilo lmao, so true

boom

Can't spell distrust either.

Can't spell frustration without rust either

@@trappedcat3615 true. Anything except Ada2012 is pretty sus for any serious work.

Imagine we had surgeons that were like "I only cut along the y axis, I never cut horizontally. Y-Cut Boyz 4 lyfe"

😂

🎉😂​@@askholia

There is no steep learning curve, every good programmer should easily be able to understand the concepts of Rust. If not, thats the programmers fault and not Rusts. The concepts are very easy, specially if you read the Book

@@ITSecNEO Exactly. There are some areas that are a bit more difficult to wrap your head around in Rust compared to other languages (most of which relate to async in some manner) but even so, Rust doesn't do anything in a profoundly different manner than any other language. It's not any more difficult than something like C++ or Java, and in many respects even easier to get started in because of a significantly easier build system

@@aarholodian Absolutely true! I would say programmers can go really far with Rust without ever touching some of the more advanced stuff. The advanced stuff is obviously harder to understand, but the core language is pretty easy. And nowadays the compiler can infer a lot of Lifetimes by itself and also provides really really good help in case of compiler errors

​@@ITSecNEOThat is untrue, the only language I can think of with a steeper learning curve than Rust is Haskell. For a procedural language, that is not great. Rust is a complex language just like C++, and a lot of engineering going on in an attempt to make it safe (in a safety critical system, panics are as bad as UB). In my opinion there is way too much going on in Rust to make it appealing to a programmer used to modern garbage collector-based languages. That makes it very hard for me to suggest using it in a enterprise context where Rust developers will be much harder to find or train. So Rust doesn't quite cut it for me but I like the premise of it and I think there is much more work to be done in this line of thinking.

@@HyperMario64 Again, if its hard for you to learn Rust its your problem and not a issue of Rust. Rust is as easy to learn as C++ and other languages. The compiler offers the best help out of all languages. So, I stick to my previous words and say that you are a bad programmer if you cant understand Rusts concepts fast, its not magic. We will see Rust everywhere in the future

loving java? have you tried other modern languages besides it?

@@ninocraft1 Have you tried getting your information from something *other* than memes?

​@@ninocraft1 I've taken a deep dive into Scala and Python and "looked" at Go and Rust. Go would've done the job but I liked Rust much more even though it would've been slow going at first. Python is a dynamic language like TCL and PHP. I wanted static strong types. I loved Scala but that was a too radical a choice for my team. These are guys who've been stuck on TCL and C for decades. (We're old)

@@gagageroI have used some Java. Really, it's an incredibly dated language. Replacing C with Java feels like going back from 30 years ago to 20 years ago. You're still working with an incredibly outdated code base.

Cr1nge comment. Rust ist better. Get over it.

Are you using unwrap everywhere?

Your rust program panics while your C program actually crashes. Slight difference. Anyway, you can avoid panics in Rust using some macro, but it's probably better to use the right functions, for example using `get(0)` or `first()` instead of `[0]` if you aren't sure whether that array actually contains that element.

It almost feels ideological. Like I understand why people argue over ideology. It’s a lot messier and you’re fighting over various interests and have to get them all to move in one direction. But programming languages??? It’s so weird to fight over those the same way we do politics. When you look at the targeted use case, a lot of programming languages make sense. Though they do tend to deviate away from those original use cases over time

I do suggest trying at least one of each type of programming paradigm, but I don't think exploring languages will make a good programmer. Good programmers know how the hardware works. Armed with that knowledge, it's easy to choose the right tool for the job with minimal exploration.

🤯🤯

for example you can review rust code from a junior programmer much much easier than reviewing zig

It’s completely reasonable to require much bigger VMs for running builds, if you are in the business of selling hosting services to sucker developers I can see why AWS and co might be loudly promoting this nonsense

@@steveoc64 yes, that is indeed a sly, underhanded incentive. Let's face it, most VMs are Linux and a lot of tools, packages etc need compilation. Seems that Rust core devs skill issue is a hosting providers's business model

Anything feels natural if you make yourself do it long enough.

@@ThePrimeTimeagenSame as with learning a second language: eventually you become fluent with enough (lots of) practice, eventually it feels natural. Kind of hinting at the "thinking fast and slow" paradigm, it migrates from our slow thinking engine, and starts to run on our "fast", second-nature thinking engine.

Most people that complain about security problems don't actually understand security in my experience, granted I'm not great with it either, but there are people I know personally who do know security because they work in high risk engineering environments, (like aeronautics and defense) they still use C and C++, most of them preferred C++, and I've been told a few times they'll never switch to something like Rust. Its quite likely the Rust developers don't actually understand security either and haven't actually worked in a field where security is vital. When the US government starts imposing something technical, its usually because it completely misunderstood the problem and developed the worst fix possible to said problem. They do it repeatedly in defense contracting and I know of people who've directly suffered and died of such things in the military.

I don't use it for the memory safety, I use it for the great DX. I keep seeing this argument you made, but its from people who think Rust is only about memory safety and that's the only reason it exists.

It's astonishing how few people know that you can mitigate almost all realistic security issues related to memory safety with just a few compiler flags

We need to stop using the term “safe” in general. Rust is not a safe language. A nuclear reactor written in Rust can still meltdown. A plane written in Rust can still crash. Sure it’s memory safe, but that is just one relatively small area of safety.

@@jonnyso1 Exactly! My personal favorite feature of Rust are macros. "Memory safety" is not one of the main benefits, it's lower on the list than iterators, Cargo, traits, ...

Rust refactoring is one of the WORST experiences. Build something more complicated than a cli calculator, and you will understand. Rust is terrible for larger projects, and teams.

@@chrisdaman4179 ? Why are you assuming I built a cli calculator

@@chrisdaman4179 ? Why are you assuming I build a cli calculator and not something complicated

@@chrisdaman4179 ? Why are you assuming I built a cli calculator

@@chrisdaman4179 ? Why are you assuming I only built a cli calculator

C# and Java??? 😅 Giant errors, lots of unnecessary information

The plastic fans are already loving it, lmao

I won't dispute the fact that the language is very young, but honestly it's very usable at the moment.

I agree. I'm not even a professional programmer. In fact, Rust is the first compiled language I seriously tried. Was intimidating at first, but after 1.5 years of using it, I can now easily read and understand the source code for most of the libraries I encounter.

Most don't like the fanboy base of ppl that haven't semi-mastered any other languages. Kinda like JS fan base. The syntax is wonky AF though. And readability is mid to low. I prefer to write declarative and functional alongside OOP for organizing my code.

I agree. I learned it passively in like 2 years and I know for sure now that it was just a skill issue that I hated it in the beginning.

Yes, because the syntax is designed to focus on functionality over optics.

As a PHP developer I can agree Rust wasn't much hard for me 😂

Nah, unlike Rust PHP is eternal

Guess what, C++ is ignored because its dog water xD You need to search really Long to find people who like C++, or better, Bloat++

C++ has expected (theoretically, C++23 hasn't quite landed yet) but most of the stdlib is setup to report errors through exceptions. I suppose you could write your own version if you're really adamant about ADT-style error handling, but most won't be able/willing to do that. I think the error there is people just don't understand how _good_ exceptions are. They come from languages like Javascript or Python that have exceptions but no RAII, when exceptions were designed to be used _with_ RAII. About the only legitimate argument against exceptions is they perform poorly on the fail case, but that's a QoI more than anything.

And IIRC the main argument for this is that the proposed C++ subset will replace "kernel C" features that are basically a re-implementation of C++ features.

@@sledgex9 I use to think that C++ in the 90s was not "mature" enough for the kernel but now being experienced in C++, I would say that "classes" and "templates" alone (which were present in C++98) would be a huge leap for handling complexity in kernel code. They should have done the switch a long time ago when the kernel wasn't as huge as it is today.

C++20 is better standardized, but I think a lot of kernel devs don't like it because the language inherently incentivizes overly complex constructs. Also issues like name mangling, virtual, and less control over memory layout is annoying to deal with in a kernel.

@@marcs9451 it's an improvement overall, but not for everything. Co-routines have disappointing performance overhead, making them a no-go for embedded. C++20 has quite a few fixes such as const& lifetime extension in loops that help a lot, though. That saddest is that only now modules are barely becoming usable. Curse whoever thought generalized header modules was a good idea, because that will actually stall adoption in the future.

@@marcs9451 and worth reminding, you can still use your own allocators if necessary, there is a more fine grained control over memory layout, and of course, nobody actually has to use virtual functions.

How would you do that in other languages? You can implement Write/Read traits on a mock, or use `tempfile` crate to create a temporary file.

You shouldn't be using mocks at all, it's an anti,-pattern, just write an integration test.

@@tinrab Probably through a macro.

@@tinrab from my limited experience, I've found that python-style mocks are the nicest to use, but of course they only work because the language is interpreted and there's not much sense comparing python and Rust. In C++, it's much simpler to wrap a class with a standard pImpl because both traits and structs "concepts" are handled in the same "tool", the class. And with gmock you can define mocks for code you don't own. Also, when the apis are expecting the real class and not an "interface", there are simple enough patterns to deal with both, think 10-20 lines straight-forward setup, not 500 lines. For C-style functions, you would have to design your real code with a class/interface that wraps the function calls so that you can use mocks, not ideal but the setup is usually limited as well. Java has mockito that I used once, it's a bit like in python if I remember correctly and the language can be compiled to native runtime with quite decent perfs today. @jonathan2847 yes I understand that I can write bad tests with bad assumptions on the mock's behavior, but it has other advantages. I prefer a simple mock setup that is completely independent from other tests in unit tests, to a large set of integration tests. It's a personal choice. For example, I accept that the api I call may change or that I may not understand it properly, but I can test that I handle the error I expect from it in the way I intend to, even if my expectation is wrong. What I don't want is for my bugged code that should fail with integration_test1 to pass with integration_test2 because my data manipulation is messed up and they now both point to being tested with integration_test2. And you can imagine that now integration_test1 leaves bad stuff behind on the filesystem that messes up integration_test3 which should have passed but is now failing. That kind of setup is too flaky for me. Mocks are not perfect but I think they have a place in our toolset and sometimes they are the right choice. And running additional integration tests after that is still relevant, yes.

Let me add that I would like to see a language that forces library developers to provide accurate mocks. They would allow testing every edge case and force you to test all those you could be impacted with. It could be enforced by the compiler and work a bit like Rust's "match" statement maybe ? Would that fix all the problems with using mocks ?

What's that

“What’s that” in response to ABI is the greatest representation of the rust community I’ve ever seen. Couldn’t have scripted it if I tried

@@LeFlamel aplication binary interface

@@combatcorgiofficialExcept the person in question is likely not a Rust developer...

I think raylib is cool project, but it is somewhat niche IMHO. I feel it is a layer of abstraction that most don't need, or perhaps more accurately only a brief stepping stone from a higher-to-lower level abstraction (the same goes for SDL). If you become skilled enough to use raylib competently, then there is no need to keep using it, and it is far more effective and flexible to simply use GLFW, OpenAL, OpenGL, etc. directly without the additional layer of abstraction over it. It sits in a weird "in-between" place of "not flexible or low level enough for serious development" and "not abstract enough for newcomers".

@@ForeverZer0 i think the reason i like it is that it emphasizes programming creativity. you can just do things and allows for people who are just getting used to a language do more with it. since it's just a library they can add on to it, rather than a full game development suite or having to focus on shaders and such. it's a good constraint to practice the language more, since the language itself is your backend and the raylib library is just a simple front end. though, been a while since i did opengl, but i do remember SDL being a bit cumbersome. raylib is like the old days of just being able to put a pixel on screen, and i think that's valuable for people to have.

Rust is better. Get over it.