Yeah but this is different. Of course there is a system call in the execution of println but the features that the video presents are mostly about backwards compatiblity. But because rust compiler handles all of that by itself its the equalivent of an IL expansion when compared to other languages
If you go further and disable the main function, you need to manually specify the entry point of your rust code. If you disable c runtime, you even need to use assembly to define the entry point for your program. It's cool.
That's mostly how all programming languages work. But the crate and dependency handling is bliss compared to the hell that statically linked libraries are in C.
Last year I spent up to 3 abortive days trying to find and link boost.locale and icu library in c++ to enable unicode support in the software I was(am) working on. I got so depressed that I started to consider switching to rust or some other compiled language that supported unicode, but slowly my depression turned into anger which motivated me to design my own utf8 character type and I loved how std::basic_string seamlessly incorporated the character type without me having to write a custom string class for it(templates are the best). The experience further iterated my annoyance with the lack of tooling(clear documentation involved) in C++ as a whole.
A big part of this complexity comes from the fact that "simple" Hello World program is in fact ridiculously complex from low-level perspective as it involves strings. And Rust is one of a few languages that don't try to hide that complexity under convoluted behaviours, but hands out the control to the user with String, &str... or with synctatic sugar of println!()
NOT to start dumb language beef, because I like Rust and I use SO many tools from its ecosystem (WezTerm, Nushell, Helix, Starship, Deno, Salvo, Tauri), but this is the reason why I personally gravitate more towards C and Zig. Like the Zig homepage says, I'd rather spend my time debugging my code than my programming language knowledge. I still find this interesting though, so maybe I don't mind debugging my language knowledge so much after all, but still.
It's the same I started learning Rust a while ago, and it was just too much complexity for not a whole lot of benefits for my taste, It's the same feeling as C++, you never know what the assembly will look like, it's hard to read, hard to refactor, hard to jump in and contribute, I feel like you need two years of daily Rust, to become productive in it, and to me that just doesn't seem like it's worth my time. Zig on the other hand is amazing I learned it in like a week, and I have been productive in it since then. I don't understand why anybody would choose to use Rust honestly, outside of very specific situations, like string processing, or memory critical code. But if memory safety ain't one of your main needs than I think any other alternative except C++ would be better. I'd have to say that Rewriting something in Rust, meaning some solved problems is really really easy, but exploring with Rust is just too much pain.
@@TheMachina42 really? I've looked at zig and I've found it so much more convoluted than rust. It didn't take me longer than a month to understand the way rust works and make a small application. I now actually can't fathom any reason why a modern language doesn't have a borrow checker.
@@RenderingUser I mean there is a lot to learn and yes sometime you have to struggle a bit, but Zig is really easy otherwise, especially if you have a strong C background. It's the most readable language that I've used so far, in fact I've learned the language mostly by reading the code in the STD. I've been using Zig for about a year now, and I've been converting people at work since then, and most of my friends that have tried it now can't get enough of it ahah. It's really cool we have been working on games and stuff with it and it's shockingly good and a really nice upgrade compared to C. Like some of my friends code on Windows, I code on Linux, and one of us is on MacOS, and the fact that most of the API are cross-platform makes it really easy to work with people, the build system is really well made in that regard, and the great interops with C, means that we can usually use all of our libraries by simply importing them in Zig. On top of that the STD is full of tools, like you have tons of data structure backed in, tons of tools from http servers, to compression/decompression, to thread pools, etc it's a blast to use, you don't have to waste a lot of time and you can move quickly with it. And because the language forces explicitness, nobody can take shortcuts, and so jumping in to help a friend takes a few minutes at most. Rust is great don't get me wrong, and it's really cool to use for simple things, or for rewriting something (this is the use case that I prefer actually because it's really great for that purpose), But when you don't know exactly how to solve a problem Rust constantly gets in your way, and if you have to refactor something, despite the amazing compiler errors I find it way to tedious especially once you have lifetime + traits, plus some async operations, it becomes really bad real quick, and because the language allows for so much freedom in how to do stuff, and we don't really have strong guidelines me and my friends, its hard to help each others on our personal project.
I was probably a bit slower than most learning Rust. But now it's really paying off. I have complete confidence to refactor code knowing the language will most of the time protect me. The complexity trade off is total worth it in the long run.
I would love to see more from behind the curtains, specifically about memory management. Like how is Box implemented, which hidden functions are called to actually create the memory on the heap, does it end up being an extern C call to malloc?
Simple, try to building something, maybe a ORM or simple RestFull API or a rapper API or CI mini app. That was how I leard rust, I had previously stuff build in C# and then rebuild it in rust.
vscode and neovim that uses rust analyzer can invoke rust analyzer built in command to rebuild macro and expand macro , which i think is much preferred choice than using cargo-expand since cargo-expand would literally expand all macros on your codebase also note that you can control what to expand using the rust analayzer config , you can ignore some macro if you dont want it to get expanded e.g. using leptos. Having been able to use macro is both a blessing and a curse. Its a blessing since you dont need to write all the code. But Its a curse since it makes compilation times longer.
I use a keyboard shortcut in vscode to expand the macro at the cursor position. It's very handy when writing complex macros and it's interesting to see how other macros expand
@@MasumurRahman-d3x it's not a default shortcut. You have to go to the keyboard shortcut settings and search for something like "expand macro". I don't remember exactly how the command is called
Rust is the hardest language that I tried to learn . Experienced in c++ , I’m struggling . The syntax is very weird … writers trynna sell that Rust is easier , what a shame
I'm experiencing the same problem. Rust is insane. The syntax is weird, and the compiler is way too pedantic. Even trying to allocate a block of memory seems ludicrously complex, and everything I've tried runs way slower than C++. I'm converting my C++ prime sieve benchmark to rust. Needs a large working buffer. So far, I'm not impressed.
For sake of fairness one must notice that this is quite similar for C and C++, and most compiled languages, AFAIG. There are some differences. Like macros impl. C++ way is std::format, std::print. Which are functions. C and C++ will also include library items (depending on version, vendor) and do optimizations under the hood. As most compiled languages. I agree that Rust has better approach with unified cargo/build system and buildin linter. C/C++ have different implementations of those and those are quite diverse.
But didin't he just release this video a while ago, coz I watched it like 6 hours ago, but then I see, he has just released it, (the video was called 'Rust hides complexity from us')
That title sounds more in line with the content of the video. Yes you could explicitly write all that stuff in rust, but rust hides it so you don't need to write stuff like that. That is not what makes rust hard, on the contrary, this lowers the barrier of entry, which is a good thing.
@@HonsHon it does seem fun (and doesnt have segcaylt unlike c which i do like) but i just dont enjoy coding in rust for some reason, idk myself. Also, logic errors (for me) are a way bigger problem than segfaults, use after free, doube free and all that kind of stuff
That is A LOT of Abstraction. Great to see these low-level languages abstract away all the complexities to make the code easier to understand and write for developers.
Even though we seem to have an overabundance of new low-level languages (e.g. Nim, Odin, Rust, Zig, Jai, Beef, and more)... I think we need one more. Something like Zig except with optional rust-like safety. It seems obvious to me that the price we pay for Rust's safety is too high. Maybe 5% of code needs to be rust-level safe, but Rust forces you to think harder 100% of the time. People who have understood the borrow-checker and lifetimes for a couple of years, still struggle with problems that are not problems at all in other low-level languages.
@@RenderingUser But would you agree that you must suffer through lifetimes trouble 100% of the time you write rust, but you need its safety only a small % of the time?
These constraints force you to think in a different way than most programming languages. A good analogy to me is that learning Rust as a C developer is like learning C as a Python developer. I do like Rust a lot and I've been exclusively using Rust for every low level project I've done in the last couple years. That said, I agree that the complexity that the Rust safety model brings to the table is sometimes excessive, if you're not familiar with it. The path to mastering Rust and its unique programming paradigm is hard and long, but I think it's worth it if you like low level stuff or work on critical software. Maybe in a couple more years I'll have become a Rust expert to the point that writing Rust code is as efficient as writing C, but with improved safety.
Why we need #[macro_use] ? Why just not explicitly add path to standart macros? Why hide it from programmers? Isn't it just confusing for new people in rust? Path to some other library must be added explicitly but std - not. Wtf
As said, ` #[macro_use]` is no longer needed for this case and thus the macros are imported as other language items (i.e. via `use foo::bar::baz`). Most std macros live in `core::` module. As for > Path to some other library must be added explicitly but std This is not true. Prelude does *not* import whole `std`. It is just the small set of items which are explictly listed in `core::prelude` and `std::prelude`. Even more, many libraries usually add their own preludes which are one-liner importable via `use foo:prelude::*;`.
"This food is not *half* bad, it is very bad." EDIT: Somehow, RUclips comments don't follow the Markdown standard, and italics aren't supported. I learned this today.
This example is not even remotely the source of complexity in rust. Now go take a not owned, stack allocated slice, coming from the network, that has to remain on the stack and try to return it 3 levels up from an other thread where its passed again to something that should own it while also NEVER touching the heap and also being thread safe. Have fun.
Get your *FREE 4-Day Rust training* :
letsgetrusty.com/bootcamp
This is true for every programming language. Writing to console eventually happens through the system calls.
Yeah but this is different. Of course there is a system call in the execution of println but the features that the video presents are mostly about backwards compatiblity. But because rust compiler handles all of that by itself its the equalivent of an IL expansion when compared to other languages
*People* : complain that C++ is too complex
*Rust* : "hold my beer"
I once used a variadic template in production. I don't think Rust considers supporting that.
People are different, ya know.
Well, C++ is way more complex actually.
How are macros complex? As long as you don't have to write or debug them they are just a fancy version of the C preprocessor
@@Turalcar, variadic template is a useful feature in C++, one can simply cover it by writing a macro in Rust where macros are really powerful
That villainous stare at the end killed me
He is gonna rust you so good
it made me pregnant (i'm a dude)
😏
truely devious
They're about to release the alpha for Cosmic, a DE written entirely in Rust.
Buy an ad.
What is "DE"?
@@joshuachan6317 desktop environment, if you dont use linux you wont understand
Desktop Environment@@joshuachan6317
@@joshuachan6317 Desktop Environment
If you go further and disable the main function, you need to manually specify the entry point of your rust code.
If you disable c runtime, you even need to use assembly to define the entry point for your program. It's cool.
That's mostly how all programming languages work. But the crate and dependency handling is bliss compared to the hell that statically linked libraries are in C.
Last year I spent up to 3 abortive days trying to find and link boost.locale and icu library in c++ to enable unicode support in the software I was(am) working on. I got so depressed that I started to consider switching to rust or some other compiled language that supported unicode, but slowly my depression turned into anger which motivated me to design my own utf8 character type and I loved how std::basic_string seamlessly incorporated the character type without me having to write a custom string class for it(templates are the best). The experience further iterated my annoyance with the lack of tooling(clear documentation involved) in C++ as a whole.
A big part of this complexity comes from the fact that "simple" Hello World program is in fact ridiculously complex from low-level perspective as it involves strings.
And Rust is one of a few languages that don't try to hide that complexity under convoluted behaviours, but hands out the control to the user with String, &str... or with synctatic sugar of println!()
What was that last smirk? 😅
At what point will dtolnay be classified as a strategic national asset?
Protect that man at all costs
Prey-lude or prelude? 🤔 Rustacian fight!
Hunters are a bit freaky today
NOT to start dumb language beef, because I like Rust and I use SO many tools from its ecosystem (WezTerm, Nushell, Helix, Starship, Deno, Salvo, Tauri), but this is the reason why I personally gravitate more towards C and Zig. Like the Zig homepage says, I'd rather spend my time debugging my code than my programming language knowledge. I still find this interesting though, so maybe I don't mind debugging my language knowledge so much after all, but still.
Personally, my favourite rust projects are nushell, fish shell, wezterm, mdbook and neovide
It's the same I started learning Rust a while ago, and it was just too much complexity for not a whole lot of benefits for my taste, It's the same feeling as C++, you never know what the assembly will look like, it's hard to read, hard to refactor, hard to jump in and contribute, I feel like you need two years of daily Rust, to become productive in it, and to me that just doesn't seem like it's worth my time. Zig on the other hand is amazing I learned it in like a week, and I have been productive in it since then. I don't understand why anybody would choose to use Rust honestly, outside of very specific situations, like string processing, or memory critical code. But if memory safety ain't one of your main needs than I think any other alternative except C++ would be better.
I'd have to say that Rewriting something in Rust, meaning some solved problems is really really easy, but exploring with Rust is just too much pain.
@@TheMachina42 really? I've looked at zig and I've found it so much more convoluted than rust. It didn't take me longer than a month to understand the way rust works and make a small application.
I now actually can't fathom any reason why a modern language doesn't have a borrow checker.
@@RenderingUser I mean there is a lot to learn and yes sometime you have to struggle a bit, but Zig is really easy otherwise, especially if you have a strong C background. It's the most readable language that I've used so far, in fact I've learned the language mostly by reading the code in the STD. I've been using Zig for about a year now, and I've been converting people at work since then, and most of my friends that have tried it now can't get enough of it ahah. It's really cool we have been working on games and stuff with it and it's shockingly good and a really nice upgrade compared to C. Like some of my friends code on Windows, I code on Linux, and one of us is on MacOS, and the fact that most of the API are cross-platform makes it really easy to work with people, the build system is really well made in that regard, and the great interops with C, means that we can usually use all of our libraries by simply importing them in Zig. On top of that the STD is full of tools, like you have tons of data structure backed in, tons of tools from http servers, to compression/decompression, to thread pools, etc it's a blast to use, you don't have to waste a lot of time and you can move quickly with it. And because the language forces explicitness, nobody can take shortcuts, and so jumping in to help a friend takes a few minutes at most.
Rust is great don't get me wrong, and it's really cool to use for simple things, or for rewriting something (this is the use case that I prefer actually because it's really great for that purpose), But when you don't know exactly how to solve a problem Rust constantly gets in your way, and if you have to refactor something, despite the amazing compiler errors I find it way to tedious especially once you have lifetime + traits, plus some async operations, it becomes really bad real quick, and because the language allows for so much freedom in how to do stuff, and we don't really have strong guidelines me and my friends, its hard to help each others on our personal project.
I was probably a bit slower than most learning Rust. But now it's really paying off. I have complete confidence to refactor code knowing the language will most of the time protect me. The complexity trade off is total worth it in the long run.
I would love to see more from behind the curtains, specifically about memory management. Like how is Box implemented, which hidden functions are called to actually create the memory on the heap, does it end up being an extern C call to malloc?
yes it will be ended up calling malloc or virtualalloc on windows.
these are just wrappers around memory allocations i think
why did you use the word harder instead of complex in the title?
Yeah, I read about the macro exclamation in the rust documentation.
Your villain underslept mug makes it even harder to code Rust.
do a vid on stacked borrows
what about the format_args! macro? shouldn't it be expanded as well?
it's a compiler builtin macro, it doesn't expand into rust code directly
I want to learn rust and i didn’t understand a thing 💀 what should be my next step?
Simple, try to building something, maybe a ORM or simple RestFull API or a rapper API or CI mini app.
That was how I leard rust, I had previously stuff build in C# and then rebuild it in rust.
man what was that smirk in the end? 😓😂😂
vscode and neovim that uses rust analyzer can invoke rust analyzer built in command to rebuild macro and expand macro ,
which i think is much preferred choice than using cargo-expand since cargo-expand would literally expand all macros on your codebase
also note that you can control what to expand using the rust analayzer config , you can ignore some macro if you dont want it to get expanded
e.g. using leptos.
Having been able to use macro is both a blessing and a curse. Its a blessing since you dont need to write all the code. But Its a curse since it makes compilation times longer.
Yes, except if you want to expand derive macros then it's easier to use cargo expand.
I use a keyboard shortcut in vscode to expand the macro at the cursor position. It's very handy when writing complex macros and it's interesting to see how other macros expand
@@nicholas_obertWhat shortcut is that?
@@nicholas_obert Tell us
@@MasumurRahman-d3x it's not a default shortcut. You have to go to the keyboard shortcut settings and search for something like "expand macro". I don't remember exactly how the command is called
Rust is the hardest language that I tried to learn . Experienced in c++ , I’m struggling . The syntax is very weird … writers trynna sell that Rust is easier , what a shame
I'm experiencing the same problem. Rust is insane. The syntax is weird, and the compiler is way too pedantic. Even trying to allocate a block of memory seems ludicrously complex, and everything I've tried runs way slower than C++. I'm converting my C++ prime sieve benchmark to rust. Needs a large working buffer. So far, I'm not impressed.
This is true for literally every language…
For sake of fairness one must notice that this is quite similar for C and C++, and most compiled languages, AFAIG.
There are some differences. Like macros impl.
C++ way is std::format, std::print. Which are functions.
C and C++ will also include library items (depending on version, vendor) and do optimizations under the hood. As most compiled languages.
I agree that Rust has better approach with unified cargo/build system and buildin linter.
C/C++ have different implementations of those and those are quite diverse.
It's not Rust that is complex, it's ours lack of knowledge about programming in a whole.
Well rust works harder than you think is maybe a better assessment but fun video to watch anyway.
But didin't he just release this video a while ago, coz I watched it like 6 hours ago, but then I see, he has just released it, (the video was called 'Rust hides complexity from us')
That title sounds more in line with the content of the video.
Yes you could explicitly write all that stuff in rust, but rust hides it so you don't need to write stuff like that. That is not what makes rust hard, on the contrary, this lowers the barrier of entry, which is a good thing.
Rust abstracts away a lot of complexity from the developer.
Дякую, Богдане! It's nice that im right now coding my rust program while watching video))
YT algo gave me fellow ukrainian comrade to finally learn rust, what a coincidence indeed ☕
Rust seems cool, i tried it, but it wasnt fun. Idk why, i could be too dumb for Rust, vor i just dont enjoy it.
I tried this language twice, I gave up twice. Rust is not for me.
It's actually a nice language. I personally always try to use game engines or frameworks when beginning a language. Bevy was a sweet place to start.
@@HonsHon it does seem fun (and doesnt have segcaylt unlike c which i do like) but i just dont enjoy coding in rust for some reason, idk myself. Also, logic errors (for me) are a way bigger problem than segfaults, use after free, doube free and all that kind of stuff
after c++ nothing is that hard honestly
Love Rust, but I can't get anything done in it.
I'm just a garbage-collected kinda coder 🤷🏻♂
You definitely mix difficulty and hardness.
For important system level tasks I can see Rust replacing C or C++, but beyond that I think it's just too complex.
Of course. Its complexity is too high for other devs. No one else will use it other than systems programming people.
That is A LOT of Abstraction. Great to see these low-level languages abstract away all the complexities to make the code easier to understand and write for developers.
Wow, is life a simulation? I used cargo expand for the first time yesterday.
Even though we seem to have an overabundance of new low-level languages (e.g. Nim, Odin, Rust, Zig, Jai, Beef, and more)... I think we need one more. Something like Zig except with optional rust-like safety. It seems obvious to me that the price we pay for Rust's safety is too high. Maybe 5% of code needs to be rust-level safe, but Rust forces you to think harder 100% of the time. People who have understood the borrow-checker and lifetimes for a couple of years, still struggle with problems that are not problems at all in other low-level languages.
borrow checker is easy. the only issue that remains hard is lifetimes
@@RenderingUser But would you agree that you must suffer through lifetimes trouble 100% of the time you write rust, but you need its safety only a small % of the time?
@@freeideasYes
@@freeideas no. because life times are something ive hardly ever had to touch. lifetimes arent a problem till you encounter a very specific use case
These constraints force you to think in a different way than most programming languages. A good analogy to me is that learning Rust as a C developer is like learning C as a Python developer.
I do like Rust a lot and I've been exclusively using Rust for every low level project I've done in the last couple years.
That said, I agree that the complexity that the Rust safety model brings to the table is sometimes excessive, if you're not familiar with it. The path to mastering Rust and its unique programming paradigm is hard and long, but I think it's worth it if you like low level stuff or work on critical software. Maybe in a couple more years I'll have become a Rust expert to the point that writing Rust code is as efficient as writing C, but with improved safety.
Me when every language does the same thing:
Ok... Good luck with this thing! 😂😂😂
4:39
That villainous stare
I gave up. I moved to zig.
That same complexity appears in Zig too. EDIT: If you want most of the complexity to be apparent, write in assembly.
Bah, I wanted to see format_args! in all its gory glory :(
meanwhile, in python world, anything goes. everything is runtime. won-der-ful. splendid.
idc care how hard it is. Get rid of the cheaters. Just imagine how many people would play or still be playing if there was no cheating.
All programming languages including Python is complex.
println!("Great video!");
is there any new news on project polonius?
New look ❤
I have to say, the hype for Rust is actually worth it! An extremely beautiful language!
This is anything but beautiful.
@@jabuci aesthetically/visually yeah
@@jabuci totally agreed! it's way more than just "beautiful"
Have you seen some real world Rust code? It's by far the most ugly language ever created. Even uglier than C++ and JS.
@@RustIsWinning the syntax. And the more advanced features have uglier syntax.
Rust is not that difficult even with pro-macro and async code.
Mojo will replace stupid Rust
Today is not April 1st
@@RustIsWinning Only Femboys use Rust.
@@RustIsWinning Yes. Mojo is superior. Syntax of python with memory safety and fast as well. Imagine using rust syntax lol.
unstable Rust pleeeeeeeeeeeaaaaaase UwU
Perhaps the worst name for a programming language!
I think the name fits perfectly. Make me think of a bare bone, rock solid thing.
👏👏👏
Why we need #[macro_use] ? Why just not explicitly add path to standart macros? Why hide it from programmers? Isn't it just confusing for new people in rust? Path to some other library must be added explicitly but std - not. Wtf
As said, ` #[macro_use]` is no longer needed for this case and thus the macros are imported as other language items (i.e. via `use foo::bar::baz`). Most std macros live in `core::` module.
As for
> Path to some other library must be added explicitly but std
This is not true. Prelude does *not* import whole `std`. It is just the small set of items which are explictly listed in `core::prelude` and `std::prelude`. Even more, many libraries usually add their own preludes which are one-liner importable via `use foo:prelude::*;`.
" Rust is not as hard as you think,
But its really harder than you think "
"This food is not *half* bad, it is very bad."
EDIT: Somehow, RUclips comments don't follow the Markdown standard, and italics aren't supported. I learned this today.
Just use Zig with C lib bindings
Rust is a joke!
@@RustIsWinninglaugh more. you're joker
@@RustIsWinning okay
I have been meaning to see what println! expands to, but never got around to doing it. Now I don’t have to😊
Again 10/0 :)
Rust is a stupid language.
Today is not April 1st
This example is not even remotely the source of complexity in rust. Now go take a not owned, stack allocated slice, coming from the network, that has to remain on the stack and try to return it 3 levels up from an other thread where its passed again to something that should own it while also NEVER touching the heap and also being thread safe. Have fun.