Then for now we will just write it in wasm and use a webapp infrastructure. Rust has always a way ; )

We do have Rust in our kernels now too.

Can't wait. Really wanted to check out Rust's mobile feasibility, but couldn't find anything particularly easy to get the feet wet.

Plus we can write Python dynamic libraries in Rust using PyO3

yeah, I'm really waiting for it because it will cover all my project needs with it (windows, android, linux, ios, macintosh, oculus quest (I hope)).

Here's another, if you've not heard of it: Rust is named so because it's close to the metal!

Thank you! Keep checking the ERRATA comment to make sure it's actually accurate!

Completely agree. Started watching just a couple of weeks ago and now I click as fast as I can when I see a new video

Same, this channel is always amazing

@@NoBoilerplate The fact that you mention this also makes you worth the praise. Thank you for the content.

oui

Rude!

@@NoBoilerplate indeed, but so is academically misleading many people

@@tuskiomisham oh I'm so sorry, I meant that them misleading people is rude, not you!

Public static void main string args amirite

@@pixelsam123 say it again, public static void main string args also you forgot the class

"When there were no more compiler errors, I was done." this is my experience every time I write Rust too! Isn't it relaxing!

Can you please explain what do you mean by “added a new thing”. It’s so hard to understand what you are working on.

Oh! The same for me! I rewrote an old project that never leaves my mind, and now it works at a decent speed and memory usage, while doing what I want it to do. It was strange at first, seeing errors and warns I didn't even know the meaning, but with time (just 2 days), once there were no more errors, it was beautiful (actually, as it's image processing, and I have a bad taste, it was ugly, but conceptually working)!

You're too kind! I honed my production skills on a hopepunk, scifi podcast, and I'd love to know what you think! ukposts.info/have/v-deo/qGOTeHtwoqmrrpc.html

i mean, he does a fiction podcast, so audiobooks kinda. it's also really good

@@NoBoilerplate I always wondered why you opted for calling it a podcast.

@@raymanovich3254 what, Lost Terminal? Isn't it a podcast?

@@NoBoilerplate It is - but the meaning of _podcast_ has been lost over time - I certainly found it surprising that a podcast meant _any_ digitally distributed programme, and did not specifically refer to the format of several hosts having a recorded conversation... P.s. Lost Terminal is amazing! It's the first podcast I've listened to in a long time (read: ever) and I love it.

Plenty of friends on the noboilerplate.org discord :-)

Just program a friend in Rust.

Rust is my best friend

@@somedooby honestly it feels like that when working with the compiler - amazing!

You're too kind! I'm always improving.

@@NoBoilerplate This one is right. You seem to just not be able to not be amazing. Your videos are a real source of inspiration for a lot of us.

No, his type system doesn't allow unamazing videos :]

@@nicolashumbert8344 Thank you so much, I'm so grateful!

@@NoBoilerplate As others have said, the quality of your videos is high, and I feel like that's also part of why you love Rust so much, because you too care about correctness. And with such, you keep your videos correct, which in the context of YT vids would be considered videos that achieve their goals well and nothing else, and since you're teaching us about Rust, you're fast, concise, and to the point with no meaningless detours. This video quality is amazing, and I'm very thankful to have stumbled onto this channel. Thanks for your amazing work!

Very good take, it's certainly an are that could be optimised more isn't it? Running a Rust CI pipeline is very different to other languages for this particular reason!

wait kovic? the_kovic, the one that made the doom eternal ost remaster? You a rustacean too? life is crazy! cheers m8

17k on windows, is the record I've seen!

I'm not sure what you mean by "In exchange for making code fast, you generally have to sacrifice some space to hold the compiled binary." Whilst it is true that sometimes one can optimise a compilation for speed and get a bigger binary as a result or vice-versa, I would say that in general the differences are not very big. More common is things like Java, Javascript, Python where one gets extra memory usage, thanks to the way they maintain variables and use garbage collection and at the same time slow performance, for much the same reasons. That's before we have added on the memory consumed by their run-rime systems/interpreters. Anyway, yes, Rust can produce binaries that are as small and performant as C or C++ can, there are many embedded projects running on micro-controllers to test to that. By the way, what do yo mean "forgoing the entire C runtime, "? C pretty much does not have a run time beyond what is needed to initialise the stack and such before jumping to main(), but even that is not running once your program is started.

@@Heater-v1.0.0 That comment was largely in reference to replacing a shell invocation that took a few dozen bytes with a 2kiB binary (which was optimized for size). And yes, C _does_ have a runtime and Rust by default links to it, and the dynamic linking alone actually increased the size of the binary more than reimplementing the necessary parts myself.

@@angeldude101 Well certainly it nice to be able to write one line of shell to get some quite complex task done. The comparison with a 2K compiled binary is of little relevance usually. I mean, that line of shell script can be dependent on millions of lines of code, in the shell interpreter, in the commands it is invoking, in the libraries they depend on, in the operating system the whole thing runs on. Perhaps if you wanted to do that same task on a memory constrained system, like a micro-controller, the 2K compiled binary would be the way to go. No, C does not have a run-time. Sure your C code may depend on library functions defined in the standard library. Or it may depend on other libraries. Or it mat depend on syscalls to the operating system. It mat even achieve all that via dynamic linked libraries. Non of that is a language run-time. That is just library dependencies. After all consider the kernel of your operating system, often written in C, there is no language run-time underneath that, it is running on the bare metal. In fact that kernel provides run time facilities that all your applications need. Yeah, I know there is often something called "crt" something or other, as in "C run time" that is typically very small and only initialises the stack, processor registers, static variable, etc before jumping to your main(). It can be as small as a handful of instructions. It's also not running when your C code is. Whilst it is true that Rust links to the standard functions provided by lib C on Linux, Windows, Mac etc, that is not actually necessary to run Rust programs. Many people are using Rust on bare metal systems that have none of that.

All that is required is for people to understand the power that we have today with rust. I'm making progress on that goal 😊

Rust is very new to me, and I wonder: Do you use unwrap()s if you are certein that a variable is Some or Ok?

Thank you! I did that once, have you seen this ukposts.info/have/v-deo/mqJke3-AiJuWx40.html My focus for the moment is shining a light on all the incredible features of Rust. Once you're excited, The Book is all you need to learn, it's written brilliantly! doc.rust-lang.org/stable/book/

@@NoBoilerplate This is low value and high effort, but the Rust Book with your radio voice would probably come out like a fun bedtime story.

@@zakstephens9297 It's ridiculous to call the rust lang book "low value", meanwhile learning any language is going to be high effort if you want to be fluent in it. The rust lang book is probably the single highest quality resource I've come across learning ANY language, with an imbedded compiler and multiple examples and explanations for every single rust concept.

@@TheShadowmanInc Nah, I mean getting old mate to read it out is low value. The Rust Book is fantastic, I have a copy on my desk right now.

@@NoBoilerplate The Book is my bible for the past month.. What an amazing doc is that!

THIS IS EXACTLY IT Rust can panic like other languages, but you can SEE when it's going to. Fantastic!

That's the plan!

This is something you find in Haskell too, rich types are amazing!

Nice! I'll watch, thank you

Some projects use pact for this when the language is JavaScript. It is used to shard type definition, test cases and mock code between systems. Ones systems mock code are the expected values for the test cases of the other system. This shows that a rich type system together with sharing the type definition goes a long way to securing compatibility. Perhaps there's something like pact for rust, which would also share the tests.

You can see the full talk here: "Building Observability for 99% Developers" by Jean Yang (Strange Loop 2022) ukposts.info/have/v-deo/jXpyaIZ-gqSqk58.html

@@LowestofheDead Nice, thanks for the link!

Thank you so much! If you want something relaxing to listen to in my voice, I recently started season 10 of my hopepunk scifi podcast, Lost Terminal ukposts.info/have/v-deo/qGOTeHtwoqmrrpc.html

Right! The whole community cares about correctness, this is SUCH a huge force!

Sound like Stockholm syndrome to me. Getting beat up and coming back for more.

You and me both my friend! Yeah, I hit that problem with Yew too, their documentation could be better :-( But once I got it working, I LOVED hot-reloading in-browser. That was an unexpected treat!

I too had this experience, with all the tutorials being so simple it gives you the idea that all will be simple from now on. But then when you try making your own thing that is not a tutorial, the compiler beats you up! It is frustrating - "I just wanna use the thing I just created! Why can't I even REFER to it, you silly compiler?!" But I find, now after a while, that stops happening. I kind-of just started placing things in memory more consciously, more deliberately, and when I mutate things i tend to do it in a more structured way than before. And slowly the compiler stopped being an annoying brat. Now I even prefer doing "quick and small" tools in Rust, over Python.

Write the macro!

hehe

The compiler demands a sacrifice

A true friend!

It's a tough start, you're doing well so far! I recommend: - fasterthanli.me/articles/a-half-hour-to-learn-rust - My rust series (10 other videos) - The Book doc.rust-lang.org/stable/book/ Good luck! Ask for help on my discord if you need it, loads of nice people there! links on noboilerplate.org!

@@NoBoilerplate Thank you very much for the recommendations. I'll stick with it. I know I'll be turning to nice people like you when in need of help!!

Fantastic! Do check out my other videos for incredible features to get excited about. You'll need that to get over the initial learning curve! 😁

Yep, always feels such a long wait for the next one..

I feel the same! So nice to chat to everyone :-)

Currently it's fortnightly, but if the Patreon takes off...!

You're very kind! I try to make it as good as I can.

Rust is close to the metal XD

Very impressive! But, so is Haskell, and as you say, Elm. I'm excited by Haskell not just because of it's technical qualities, but because it's *popular* and I can hire a team and get working with it TODAY. When Roc passes Common Lisp (dead center) I will start to pay attention. redmonk.com/sogrady/2022/03/28/language-rankings-1-22/

Thank you so much!

Thank you so much! If you want to avoid YT, I post about the new videos on twitter, patreon and discord!

Google back Go, of course, and have made a carbon copy of Rust, called Carbon. I'm deeply suspicious of their motives there! -.-

​@@NoBoilerplate 😆😆

Thank you!

I'm so pleased! This is why I started this series!

Hey, thanks!

My pleasure!

Oh sure, everything is possible, but I'll take my chances with an extremely well-reviewed piece of open source software ;-)

That's it! And, unlike C++, we get this with a pleasant to use high-level language too!

I promise to only use my powers for awesome

Thank you!

"mainly the use of unstable features in kernel rust." I'm not sure that's quite right there. Unsafe isn't any worse than C, it just means you can defeference a raw pointer, plus 4 other pointer-related superpowers. (see the book for them). ...C can do all these unsafe operations with no oversight already, and we already write the linux kernel in that XD

@@NoBoilerplate Im not talking about unsafe, i mean feature like 'global_asm' or 'allocator_api' which are currently unstable that means the build could break in any verison which is a huge nogo. There are talks of having a dedicated kernel rust version, but that would lead to stagnation, like with C, where they had C89 for the longest time as the kernel C version, they only updated it because of a speculation bug, which couldnt be fixed in the version they had, so they went straight to C11 Wich is also a decade old but its atleast more modern than what they had.

@@wChris_ oh! sorry I read 'unstable' as 'unsafe'. My bad! Unstable features get stabilised pretty quickly, even in the short time I've been following things. The Editions system perhaps could help here?

I too take what I've learned from Rust into my day job to improve the Ruby we write!

My pleasure!

You can do it!

Nice! Did you see my setup video for it? (my 'lightsaber' video)

Rest is good for our mental health isn't it!

Agreed, and rust's unsafe system makes this process as easy as it can be!

If you made just one of these, I'd buy it :-D

Go's a great language too, you'll have a good time! Absolutely no harm in learning both, as developers, that's what we do! The book (also in epub) is free, don't forget doc.rust-lang.org/stable/book/ (dead tree formats don't have working links ;-) )

@@NoBoilerplate I agree 100% :) thanks for the link!

@@fabiobregasi5290 HAVING SAID THAT here's two features that you can't get in Go ;-) ukposts.info/have/v-deo/iKV-jI2aZ66jrGQ.html

Now compare that with Python...

@@CristiNeagu Same for scopes. Probably shorter. It's just this line: print "Hello World"

And the less we talk about the GIL the better!

I don't think your concerns actually manifest in practice. Once you know Ruby on Rails, you can rapidly prototype, once you know React you can rapidly prototype, and once you know Rust, you can rapidly prototype. A newbie in any of these would be slower at first. And even on top of that: Compiler-driven development has the potential to be FASTER than iterating in traditional tools because so much more is checked for you by the compiler. I've got a draft video on this topic coming soon!

This is intentional. I've noticed a lack of clear, well-explained introductory videos to Rust topics. There's loads of people making really great technical tutorials, but not stuff to get EXCITED about. I crashed out of writing Rust TWICE in 2020, and I only came back because I had a mentor to help me. Most people don't have this luxury. Rust has a BRUTAL learning curve, compared to other popular languages (though not as bad as Haskell et al), and so you need to know ALL of the great features that you simply can't get elsewhere, in order to push yourself through the initial learning period. Have you tried Rust? Thanks for your comment!

@@NoBoilerplate I actually started learning because of you. Moreover, I watch your videos sometimes when I lose my motivation. It really helps! :3

@@SeresHotes25 I'm so pleased, thank you 🙂

​@@SeresHotes25 And imma start because of this guy

you should have your own show! :-D

My rust series won't go on forever. I will eventually run out of features to hype up! :-) And then, I might try a different colour logo. It's entirely possible I'll need to figure out the art of a YT thumbnail later on, and you might find big changes! I'd welcome any and all suggestions.

I think the biggest category where Rust wouldn't be the right choice is applications where having a big runtime is an asset, not a feature. The one that comes to mind first is Data Science. Playing around with datasets in a repl is a huge part of doing data science, and it's not the types that matter but the values, so a rich compiler won't be as much help as building a larger app. Julia is a language i'm excited about for this sort of work!

@@NoBoilerplate Oh absolutely, especially doing Uni work, it’s nice to just script things and play around with data. I’m using Python for that :) But Julia or R are also present in some fields. There’s really a lot of languages to choose from haha

I too am looking forward to the discussion on this topic. I'm not a kernel developer, so I'm not the right person to talk about it I'm afraid!

rust doesn't inherently handle panics better, but it does require programmers to clearly mark everywhere where a panic can occur using the `panic!()` macro, the `.unwrap()` method, or something similar. In theory, if a programmer can replace all `panic!()`s and such with code that compensates for the issue, you code can become panic-proof. You can even use a macro called `no-panic` to make sure a method is incapable of panicking or it will fail to compile. In practice, I suspect panics will still happen sometimes, but they may be so rare as to only effect driver developers with non-rust languages and the like.

@@lucky-segfault4219 Indeed, I did a video on this very topic! ukposts.info/have/v-deo/q5KHrKdupYSlyKM.html

I haven't looked at the latest iteration in detail, but as far as I'm aware the kernel doesn't panic. That's not a thing it wants to ever do. In light of this one of the things that were required to put rust into the kernel was to provide better support for non-panicking data structures/functions. For example Box::try_new tries to allocate a new Box, but if it runs out of memory and the allocator can't do that, then it gives an Err instead. So Rust's normal enum and rich type system actually makes the same patterns even better. In C you would perform the allocation and simply receive a null pointer in the cases where it runs out of memory, and it's up to the developer to check each pointer returned by malloc. In Rust that's as easy as ?

In fact Asahi Lina (whose live streams are on youtube) has just written a GPU driver for the M1 mac in Rust, which is where I saw these patterns

Love it, good comparison topic erlang-rust. Thank you!

Absolutely - all these other incredible features of Rust in the video make me excited for it! Speed is fine, but I wrote python for 15 years, so I know that it's not essential XD

Compile times are a huge focus for the core team. And maybe you're a little out of date? I remember such compile times when I first started using Rust in 2020, but every version they get faster and faster! I just tried the Rocket hello world demo, and it uses ~100 crates. On an M1 mac this takes 10s to compile cold, and 0.1s to recompile. Do try the same and let me know how you get on!

​@@NoBoilerplate I don't know about Rocket now, I used it around the same year you mentioned. Yew however comes at this size, presumably for all the wasm deps. Following the Yew tutorial, it took me ~30 minutes before I could open my editor, downloading and install trunk, wasm, bindgen, yew and what not. Those 30 minutes were 80-100% CPU usage on all cores, and drained a fifth of my battery. This has been my experience with all Rust frameworks 2019-2021 (ish). But happy to hear! I know there's been some fuzz around linkers and debug builds coming down. That is awesome news.

@@Honken Yeah, do try out Rocket again, you'll be pleasantly surprised! Yew did take a lot to set up didn't it? Trunk was especially weird too when I set it up, downloading some binary blobs that I wasn't keen on . HOWEVER I don't actually mind those setup costs - they're one-time. They should be faster, you're right, and they're getting better, but at least they're one time. Once I got yew installed for the last video, and started playing around with it, the experience was SO FAST, even hot-loading code into the browser when sourcecode changed and compiled. WOW! Please don't let the long compile times put you off, and if they still do, just try again in 2 months, they're getting better every release 🙂

@@NoBoilerplate Thank you for always being so positive and encouraging in your comments. I'll take you up on that, and subscribe :)

@@Honken My pleasure! I'm trying to help people out with the videos, it'd be weird if I didn't also do that in the comments 🙂 There's 10 other videos in the series right now, have you seen them? Here's the playlist ukposts.info/have/v-deo/iWNynLB_qG6gyKc.html

My pleasure, thank you for your nice words. The huge library of tooling documentation and SDKs is coming, and coming fast, and it's already there for many fields

You're too kind! I also think so!

The podcast? Not sure if I am looking at the right thing

@@serioustr This is Lost Terminal, written by a geek for geeks 🙂 ukposts.info/have/v-deo/qGOTeHtwoqmrrpc.html

No denying the learning curve, but that's why I'm here to get you (and me!) excited enough to push through to that point you mentioned, where you're fluent in it. It's a hard road initially, though. I crashed out twice in 2020. Glad I pushed through! The benefit of lifetimes (to us, not to the compiler) I can't yet explain clearly enough, though I'm nearly there. I'm writing the video, stay tuned! The tldr is that if your type system has lifetimes, you can model not just what your data is, but WHEN. (what sequences of your data are valid). Come ask on my discord, links on noboilerplate.org, and those smarter than me may give a better answer!

@@NoBoilerplate Thx

Wonderful! Honestly this language sells itself! Have you seen my video on how to learn Rust? ukposts.info/have/v-deo/apiJgpptr2-ku6c.html

Have a look at the middle of my 'lightsaber' video - I use obsidian.md!

@@NoBoilerplate Rust and obsidian! Tis a beautiful way to live

Very true, of course. It's much easier to find these errors, when you don't have to wade through the marsh of uncertainty that other languages have, however!

Adam, you're doing it right, cloning strings and objects is absolutely fine when you are getting started. Rust is 80x faster than Python, you'll get fine performance XD Come ask questions on the noboilerplate.org discord - there's a channel #newbie-advice just for this!

"most apps should be written in a higher level language until you can no longer do so" Telling a newbie this is very mean and closed-minded. Please learn more.

​@Christopher Grant Chris, look at the context of your statements: You're commenting in a thread where a newbie is excited about Rust and has written a simple web app and is starting to ask intermediate questions about cloneing. You're too late with all this advice! Adam is excited about Rust and has already breezed past the problems that that paper's authors seem to think are too difficult. They're not, ownership is easy. Python's a fine langauge to learn to code in, so is javascript or ruby. For me, Python was my boat. It's got me to the other side of the river, but I'm not taking it with me as I climb the mountain.

Both! Go is a fine language that if rust didn't exist, I'd be writing. These are not the last two languages you'll be learning in your career either, so start today 😊 Try rocket.rs and yew.rs, and go through Rustlings and the Book. Hit up my discord and ask for help in there. Good luck!

1. You're right, though Rust's C support is excellent (doc.rust-lang.org/nomicon/ffi.html) calling C++ functions requires a C wrapper. This is how C++ libraries are wrapped (such as GTK crates.io/crates/gtk) So it's not impossible, certainly easier than with Python, it's not as direct as with C. Check crates.io, you may find that someone has done the work for you for the library you want to use! 2. Syntax is syntax. Some people prefer type on the left, some on the right. Many people have it even harder, and are coming from dynamic languages and ask me why it needs to be there at all! This is a matter of style, and one you may have to get used to if you want to try new languages, as it appears to be the prevailing style. My take is that the NAME of the variable is something I look at much more often than the type. Because the Rust compiler does type inference based on both sides of the = sign, in most cases, only the function signature needs to be typed. I am sure that you will have no problem learning Rust, coming from a C++ background you're already familiar with many of the low-level features I had to learn (My background was Python). This article was revolutionary for me fasterthanli.me/articles/a-half-hour-to-learn-rust.md So much so that I got permission from the author to make a video version ukposts.info/have/v-deo/mqJke3-AiJuWx40.html (though the article is better) I have written about 10 other Rust videos showing the remarkable features of this language. The playlist is here ukposts.info/have/v-deo/iWNynLB_qG6gyKc.html I'd give them a watch, and I hope you will see that small differences in syntax will seem like a small price to pay :-)

Oh! I just found cxx.rs - which seems to do what you want! There's also bindgen, but I don't know much about that. Come and chat to me and the community on my discord if you like, the people over in #programming would be delighted to talk C++ / Rust integration discord.gg/mCY2bBmDKZ

You've been listening to Lost Terminal haven't you XD ukposts.info/have/v-deo/qGOTeHtwoqmrrpc.html

This is EXACTLY why I made this video! I have a few others that are also very boss-compatible too, check them out!

@@NoBoilerplate Nice :D, good job!!!

​​​@@NoBoilerplate it would be nice if you made playlist called something like "For boss" where in right order all reletad videos would be to convince him :D

@@edems131 DONE ukposts.info/have/v-deo/bJSnmmyihG1h0oE.html

@@NoBoilerplate :D awesome

Thank you so much!

Excellent!

My goal is to get as many people excited about rust as possible, and while they're learning, to stay excited 😊

Fantastic! Do watch my other videos on Rust, there's astonishingly good features there that you'll NEED to know about! Start here fasterthanli.me/articles/a-half-hour-to-learn-rust Then hit The Rust Book, and Rustlings. Good luck!

Just don't buy into the "70x more efficient" part from right at the beginning. It's perhaps 70x faster to run, but what are Python scripts generally for? The language not meant for heavy lifting, so those comparisons are unfair, so to speak, unless you do come across a Python script that ends up crunching numbers at max speed for minutes (or higher) on end. But yes, do learn Rust! It's a great language. Just don't forget about scope and scale.

"python scripts" is not what we call the second most popular language in the world. Despite what you or I think about Python's applicability, people are using it for EVERYTHING! Also 70x slower than C speed, is Python's pure cpu single-threaded benchmark. It utterly crumbles in multithreaded benchmarks due to the GIL. Yes speed doesn't really matter. But when it's HUNDREDS of times slower, it starts to matter. As I said in the video, unit tests are 100% cpu with no waiting for IO, so it's especially noticeable there.

Thank you so much! Perhaps you'd like my delivery of Lost Terminal too? ukposts.info/have/v-deo/qGOTeHtwoqmrrpc.html

@@NoBoilerplate No, python scripts are what you create with Python. And if you want more performance with similar ease, Nim is a fine alternative. If you want actual performance you go for a more suitable language. I don't think we'd disagree on this. I write Python for things where bash doesn't cut it, but still in the same domain as bash scripts. Beyond that, other languages are far more suitable.

@@herrpez I am aware of nim, I am a maintainer of inim, the most popular repl ukposts.info/have/v-deo/iZGQbaysq2qF24U.html Please understand most people don't use python in the way you do. It's not the second most popular language in the world because people write scripts "where bash doesn't cut it".

Thank you!

I didn't set out to do so. Perhaps I make assumptions that the audience has watched the previous videos in my rust series? There's far more to Rust than static typing: ukposts.info/slow/PLZaoyhMXgBzoM9bfb5pyUOT3zjnaDdSEP

@@NoBoilerplate Well, the thing about prevoius videos is that it's entirely reliant on the UKposts algorithm. It recommended this video to me without telling me there were others. From what I can tell after spending 10 minutes with an installed compiler, it's a convoluted language combinging the arcane syntax of C++ with an extensive pythonesque library. I mean, that's not necessarily a bad thing, but I have to wonder if it's a gatekeeping language intended to scare away new developers with its unnecessarily complicated syntax.

@@YDV669 I should make it clear that these are part of a Rust series! Good point, thank you. Oh it's TOUGH isn't it! I also hated the syntax when I started learning in 2020, I gave up twice, but luckily had a mentor that put me back on the right track! Here's the way to think about it: C or Python or other popular languages don't have all this syntax because they don't support the FEATURES that rust has that they don't. Three clear examples of this are the Result type, often seen in return values, lifetime annotations (which state that reference x must live at least as long as reference y), and references themselves. A recent video where I showed an example of why this extra syntax is needed was Rust on Rails ukposts.info/have/v-deo/q5KHrKdupYSlyKM.html I'd love to know your thoughts after watching this.

@@NoBoilerplate Book follows. :) So I watched your video, and I still don't really agree that such syntax complexity is necessary, despite all the things Rust seems to do for you at the compiler level. let mut x = 1 let y = 1 Why force the use of two keywords for almost every single variable? Mutable function variables would normally be the default, with immutables the exception, wouldn't they?. mut x = 1 let y = 1 Or to more clearly identify the immutables, let x = 1 imm y = 1 The constant abuse of the exclamation mark(!). The apparently forced use of the question mark(?) to unwrap the actual result from a return payload. "Your code will never crash." That's like the worst thing to tell companies. Maybe it won't crash, but is it correct? It's bad enough remembering having a manager with the unshakable belief that code is production-ready the moment it cleanly compiles and after a few sanity-check runs(yes, even batch update cycles). This kind of thought corrodes development budgets. I have no problem with the language enforcing safety at compilation time, but does it need to be so needlessly and thoughtlessly convoluted? It sounds great at the "I designed a language to impresse my girlfriend" stage, but when you're debugging a program at 3am(or even compilation errors) after already being awake for 20 hours, the ivory tower intellectualism embedded in the core of this language isn't going to win you any friends due to issues with arcane syntax potentially obscuring critical logic errors with badly placed question marks or somesuch. I say all this as someone who grew up on a language that literally did not believe in division by zero being any sort of error, where string comparisons were all essentially right-trimmed(empty string is equivallent to ' '*x where x is any integer from 0 to MAXINT). None of this is intended in any way as a criticism of you personally. Your videos are well-written and narrated, and I appreciate learning about Rust.

@@YDV669 Thank you for a very coherent comment! I'm DELIGHTED to help you here, you're on the right track, but have misunderstood a few things, I think. If that's due to my video, my apologies. You wrote me a book, I'll write one for you: 1. Mutability. Mutable variables are indeed the default for most languages. Rust chose to make immutability default because it's *better*. Immutability is the default in functional languages, you'll see this in Haskell and similar. Rust is a functional language. Look at any modern javascript tutorial, you'll find more `const` declarations than `let`. For instance, here's the first React tutorial reactjs.org/tutorial/tutorial.html the first code blocks that have variable declarations in use const. There are more `const`s on that page than `let`s My understanding is that in JS, the advice is is "use const by default, if you need mutability, use let". And why is this? One reason is Immutable variables are much easier to reason about and debug, we can't accidentally shadow them and mutate them, causing surprises. 2. "Constant abuse of exclamation mark." The compiler enforces that macros must end with a question mark, and nothing else may. If you see a !, you are looking at a macro, simple as that. Macros are STAGGERINGLY powerful, they can: 1. Rewrite syntax at compile time, and 2. Execute arbitrary code at compile time (even disk and network access) You'll never have come across this power before, except if you've use lisp. Other languages have things they call macros (or templates or comptime etc) but they are very rarely able to do both the above superpowers. Macros have a bang ! at the end because it's important we know where they are so we aren't surprised. 3. "Forced use of question mark to unwrap" Functional error passing is very different to exception handling and I understand why you are confused. It's not forced, nor does it unwrap the errors. My video on Rust's error handling is here, and I'm very proud of it, do take a look ukposts.info/have/v-deo/q5KHrKdupYSlyKM.html 4. (related) "Your code will never crash" I think after you watch the above video about error handling, you'll understand why I say this more. Rust CARES about not crashing at runtime (it is this feature that made it perfect for Linux kernel development, something that is THIS WEEK official), and has the complex syntax and compiler to find nearly every case where it could. (edge cases that require more care to handle are OOM errors and unchecked maths, but they both have simple solutions for if you need them, say in an embedded environment) 5. "arcane syntax potentially obscuring critical logic errors" I understand the syntax is unfamiliar, I really do. I hated it for the longest time, I kept crashing out of learning Rust. But I came back for the world-leading features that you simply can't get anywhere else. If you want a hard, realtime language that doesn't use a GC, and you ALSO don't want manual memory management, you're going to NEED the borrow checker. There's simply no other language available! The good news here is that the syntax is there for a reason. Other languages don't have borrows, so we need two symbols for a read-only borrow, and a mutable borrow [& and &mut]. OK, and now the compiler needs to know how long the programmer wants these borrows to live for, when can they be cleaned up? let's use ['a 'b 'c], name the lifetimes with simple names, you can use 'longer 'names, but most of the time there's only one or two lifetimes in a function, if any, so 'a and 'b are fine. Types are annotated with HashMap angle brackets as normal. The way I learned Rust's syntax was by reading the BRILLIANT Amos's blog post: fasterthanli.me/articles/a-half-hour-to-learn-rust I was so impressed by this post I made my own video version (after asking permission) ukposts.info/have/v-deo/mqJke3-AiJuWx40.html Depending on if you are a reading person, or a watching person, you could try either of these to grok the syntax fast? (I'm, ironically, a reading person!) I wish Rust had simpler syntax too. Just as I wish for proper self-driving cars. For now, I'll have to drive a normal car, and program using a bit more syntax! Both get me where I want to go. It's worth noting that the rust core team add more and more places where lifetimes don't need to be explicitly stated - the goal isn't to have zero lifetimes, but to have as few as possible, while being unambiguous. Thanks for reading all this and chatting with me, I think this video of mine, doing a deep-dive into unsafe and macros explains these two features pretty well - and you simply can't get them anywhere else, AND THEY'RE SO GOOD I didn't know I wanted these features when I was writing Python! ukposts.info/have/v-deo/iKV-jI2aZ66jrGQ.html Thanks friend!

I built critical national infrastructure in it while working at the Government Digital Service, here in the UK, in 2020, that was my first taste. The experience was really profound for me: the whole first day nothing was compiling, and I thought the language was insane, but at 4pm we got it compiling and then no further changes were required and it's currently sitting in production, receiving dependabot security updates, code passing tests in CI and building with no changes. I genuinely think it could run for ever, this language is so focussed on uncompromising rock-solid backwards and forward compatibility. This commenter said it better than I ever could: ukposts.info/have/v-deo/knZ1pZ5qqqKCx4k.html

Love it. Before I discovered Rust, I was a professional clojure developer for 2 years, I even made a video about it! ukposts.info/have/v-deo/o49lpoKwqIeWonU.html Rust has taken so many of the features i love from Clojure: - Expression-based language - Real lisp macros - fluent interfaces everywhere - Instant feedback (albeit from the compiler instead of repl) I searched for years for a way to make typing work with clojure. Typed clojure just never clicked for me, it was so much overhead, no-one really uses it, and it wasn't very powerful, clearly an after-thought. Finding Rust (which is Lisp in C's clothing with Haskell's type system) has been revolutionary!

Homophones are fun!

Oooh! that's a good one. I heard recently that 'rust is close to the metal'

It's a progress bar for people who watch in full screen. Reveal.js has it as a feature, and I quite like it!

I don't understand your question, this sounds like Apples and oranges. Do explain more?

Most languages are fast enough. Even Python's 80x slower than C doesn't hold it back from being the #2 language in the world! I don't know of ARM benchmarks, but according to the paper referenced in this video, Dart is 6.67x slower than C, just behind Javascript. For comparison, Rust is 1.04x slower than C, and C++ was 1.56 slower. So your dart app uses probably a similar amount of power to a javascript app, but the CPU-bound parts use 6x more than Rust. This is only pure cpu tasks, most app time is waiting for IO, which is why most languages seem fast enough - they're not executing most of the time!

@@NoBoilerplate Flutter projects are compiled to native arm machine code for mobile devices. It also leverages GPU acceleration a lot for the GUI layer The near JS performance is likely when it's transpiled from dart to JS for use as a JS alternative like typescript. We're actually doing a lot of heavy lifting in the Flutter client.

By the way your videos are great!

@@magfal Oh cool! I didn't know that. I hear only good things about Flutter.

@@magfal Oh thank you so much! I'm learning every day 🙂

Thank you so much! How is your learning going?

It's going very well, thanks! I don't have much free time, but when I do I solve programming puzzles with rust. It has been a breath of fresh air after years of enterprise Java. Thanks for taking the time to reply. Good luck with your channel, you are awesome.

Thank you! Did you check out my other 10 videos in the Rust series? I'm trying to cover in a high-level all the cool features of rust!

The way I like to put it is Rust has V-shaped difficulty curve. It's hard to learn, easy to get proficient and hard to fully master. With C++ it's an ever-steepening hill all the way up.

Ooh, that's very interesting. I think of it like this: In most languages Easy things are Easy, and hard things are possible. In Rust, Easy things are possible, hard things are Easy.

I should hope so! I'm certainly making hype videos

Developers are paid to think, managers are paid to worry.

Thank you!

You've got a very similar background to me! I'd recommend: - fasterthanli.me/articles/a-half-hour-to-learn-rust (or my video made on this article) - github.com/rust-lang/rustlings and the book. Come ask in #newbie-advice on my discord server, there's a thousand lovely people who can help! (me too!)

Come chat to the community on the discord, links in the description!

Oh good spot. My guess is Compiled, Interpreted, and ... something else. Check my markdown sourcecode for the link to the paper!

​@@NoBoilerplate Thanks! I couldn't find a free version of the paper to check the reference so I did the next sensible thing-pasted each language and a trailing v into Google search and they ended up having virtual machines in common. Java should have been a dead giveaway😄

@@kelvinpraises Genius!

It's defined in the first line of the source code. (it's FiraCode Nerd Font)