What Makes Rust Different? 

ERRATA - "axiom" was not the right word, apologies! "Theorem" is what I think I should have said. My metaphor got somewhat out of hand...! - 7:47, on the second line of the first example. sadly rust doesn't allow expression inlining, only identifiers can be inlined. - 12:08 "Early ad-free and tracking videos" I promise there's no tracking, woops! It should say "tracking-free" - 10:25 variants*

You lost me at "computers exist", completely outrageous claim

Hi Tris, I'm Friends

Sorry, as a mathematician I have to disagree that the axioms/rules are not invented. Mathematics is a game of determining the consequences of axioms. You choose the axioms and the consequences follow. The axioms we choose feel "natural", but that is purely a choice. Edit: I think your point still follows. But the point about axioms being "determined" isn't right. I love this part of mathematics 😊

the drop function is now my favourite function

The drop function is insane, I always thought there was just some magic sprinkled around in rustc (tho that is arguably magic) but for some things to be that simple, it's insane

I feel like Rust is becoming a religion.

I just started rewriting some of our lab's research code in rust and I had *no idea* the drop function is that simple, that was a wow moment for this rust beginner.

Who knew a No Boilerplate video could finally motivate me to work on that project?

"Computers exists" I see, hot takes straight from the start

Mathematicians do invent axioms and there are a lot of axiomatic systems that you can choose from (ZFC, NBG etc), and they're neither self evident (most famously there have been many disputes about the axiom of choice) nor perfect, as Gödel demonstrated

I know someone else already said it - but math's axioms are _incredibly_ a choice, to the point where there are branches of math dedicated to exploring the consequences of different choices for what would be the exact same "type" of math (for example, there are multiple kinds of arithmetic) and in any branch of math, you'll find that some statements cannot be proven nor disproven - the axioms simply don't have the ability to say anything about it. whether they're true or not is _your_ choice, and they create two branches of math (one where we choose it to be true and one where we don't). we just pick the useful one

The laws of the universe are simply not discovered but rather inferred because, humans have limits and thereby our understanding has limits. So math is not "The Language" of the universe but one that we've inferred for understanding reality.

Yep, now I'm absolutely positive that Rust will drive me insane.

As I suspected, lots of comments are disagreeing on the "math is discovered" part lol. My opinion on this is that we invent math axioms and then discover the properties that emerge from them. There have been several axiomatic systems in the past, they had their flaws and it took a really long time before we got set theory. And even then it wasn't clear cut perfect.

Hi NB, I’m a big fan of your videos! I love Rust, in fact I’m adopting it for most if not all the backend parts of an application I’m working on. However, I think the difficulty curve of Rust is extremely understated, which is why we’ve seen Go adopted in more code bases than Rust. I recall a video you did easily addressing this curve, but a simple reality is that when you’re a startup with limited runway, or a department with limited budget, you have to consider the speed at which a technology can be adopted. I’ve heard news the Rust team is working on greatly simplifying the language, which would make it perfect for me. But I understand why others choose Go.

The first time I saw the term "evangelist" in a tech context I got a bit confused. With your videos about Rust now I get it. Tanks for the amazing job! You're truly spreading the word, man.

Math being discovered as opposed to invented is debatable at best. Although it matters not to endeavours in math

"You don't have to invent an error handling system" - Kinda wish they did. The builtin error handling can be clunky when dealing a whole chain of different errors, this error, that error - anyhow I'm rambling...

“What Rust Discovered”, in the same sense as “How Britain Discovered Australia”; things which have been so well known by some for decades, but they’re “discoveries” when they finally land in Rust.

Technically wrong about mathematics being something purely discovered. There are provable paradoxes at the center of mathematics due to the axioms used in its construction, specifically in set theory as the foundation of all mathematics. Russell's Paradox is the most well known.

0:06 Math is just applied logic... which is just applied philosophy

Rust is a language I love the idea of, but the more I actually tried to use it for more complex things, the more I disliked using it. It starts with the horrendously slow compiler. Then the way the compiler flags correct function code as having errors due to problems elsewhere in code. However the biggest issue I found to be that it often forces complete rewrites when an idea is taken into a direction, and you find out quite late that Rust just does not like the approach. This can be seen as a feature (perhaps the approach was wrong to begin with?). However I found perfectly fine directions often not working in Rust due to how lifetimes and static bindings work, forcing a more "less Rusty" approach that kind of defeats the purpose. I also found C interop hard in practice, due to how Rust works with borrowing, but perhaps that is a skill issue on my part. The macros are great compared to C/C++ and the like, but I think they are still not great, with two kinds of macros, with one being pretty hard to write or worse, comprehend. Zig comptime shows the way here I think. In practice, for my purposes, these things make Rust best at smaller tools that have a clear scope and are predictable in how you want to implement them, and where low latency, low memory usage and great performance are paramount.

I like what you’re going for, but tbh this video feels more based on platitudes than usual. I still appreciate the content, thank you for all of your hard work!

The trademark shenanigans that happened made me stop learning Rust by just sticking to C and C#, but your videos make me hungry for more Rust each and every time. I really vibe with the language and I kind of want to jump into the deep end with it. Great video as always!

Great video, just a small correction. 6:45 I wouldn't compare null in kotlin to those other languages. Nullable variables in kotlin work exactly like in rust, you must either handle the null case or explicitly unwrap it with the !! operator. The compiler prevents you from accidentally making a null pointer exception. Even though they call it null and have some syntactic sugar to handle it it is comparable to an Option in rust or a Maybe in haskell.

"Math is the floor of the abstraction" The floor is philosophy, on which mathematics is built. "Math is based on fundamental self-evident axioms" These axioms are not self-evident nor fundamental, they are able to be freely chosen and the question of which axioms to choose is a question for the philosophy of mathematics "The rules of our universe are pre-set, and mathematicians discover them" Isn't that what physicists do? "These rules exist in perfect form out there" this is the philosophical position of mathematical platonism

Yeah but I had a hellish time trying to convert basic Pandas ML into Rust due to the crates being designed so poorly and opaquely. An N-dimensional array is pretty rough to implement, and even more rough to understand if you didn't write it.

Beautifully captured the magic of strong type systems. This is exactly how I felt when I first learned about functional programming in the MOOC “How to Design Programs”

7:34 Rust doesnt have exceptions because it CANT. Borrow checker under the hood is a control flow analysis. Exceptions make control flow analysis exponentially more difficult to the point where its impractical to have it in a compiler. If you have borrow checker then you dont have exceptions. If you have exceptions then you dont have borrow checker. Rust was forced to use other methods for error handling

1:09 computers DO exist, but they've only existed since last Thursday just like everything else.

using rust for a few months made me a much better developer in all other languages due to the enum mentality

Axioms are literally made up and not discovered. Sometimes you "discover" an axiom, but what you're actually doing is discovering that one of the actual axioms you were using would instead follow from making a different axiom. That different axiom is what you then use, and your former axiom becomes a theorem. But the axioms in and of themselves are pure inventions, pure conventions. Mathematicians just chose the ones that lead to the most interesting and useful theorems by consequence. Theorems, now those are discovered!

The "computers exist" thing got me rolling on the floor KKKKKK Couldn't agree more

Great video, thank you. Elements of fp are are good for every language domain I guess, starting from vacuum Haskell going all through js and java, finally reaching the deeper levels of coding

I think math is built on philosophy

thank you so much for mentioning the "rust by example"

Let's be honest - None and null are pretty much the same semantics

Impressive video! Mind Blown. Gained a new subscriber. I have been learning rust for a few months now, love the language and i am intregued by it.

The idea that mathematics is discovered and not invented is disputed. The mathematicians are actually split in two fields about it.

Rust's design makes me immeasurably happy. It's so consistent and clear, and everything surrounding it sticks to that level of clarity. I have severe ADHD and my working memory is kinda hopeless, so I rely heavily on tools such as language servers to get things done (since I can't remember my way around most code, it's great to let my editor do the remembering for me), and the way Rust is designed means that its tooling for things like language servers is the best I've ever used. Things like that mean that it's not just a well-designed language, but also a very accessible language, and I appreciate it a lot.

This is probably the most important resource I've fund for experienced programmers to understand the Why of Rust, instead of just how to achieve familiar tasks in a new language. Very well done, and profound in its' simplicity.

that part when you talk about math being discovered rather than invented... like yeah, its just your opinion, man. philosophers argue on that for centuries, but you seem highly convinced without a good reason. dont do that. but great video, as always.

"mathematicians discover, not invent" oh dear... we really want to get into math fundamentalism? lol

The more I explore about Rust, the more my mind gets blown. It's like a convergence of C++ and LISP after taking away the disadvantages of both. It will be the language of the future for sure and the most critical projects (especially system software) will use it. Learning it now will pay huge dividends in the coming years. Shoutout to @NoBoilerplate for such fascinating videos.

This channel is so awesome!!

I was not prepared for the tomfoolery of the drop function

Python does not have null. it has an Optional type that can either be None or the Value. It just does not force you to do error checking

Honestly, bro, the way you are giving the information, not just monotonous but like with , with the power, idk how to describe it, with the pauses, dramatic effect idk... It made me even listen through the whole sponsor part

great video! i had a teacher who once told me: some languages are invented, some are discovered, stick to the discovered ones. and it was surreal seeing that some concept being talked about here. there is something very powerful to that family of discovered languages, but i think every language has some degree of inventions in them (syntax for instance, which can be very arbitraty) i'd also like to make a very small correction to the video, at 7:47, on the second line of the first example. sadly rust doesn't allow expression inlining, only identifiers can be inlined. as a learning exercise once i made a crate with copies of std macros that use string formatting, but that allowed for expression inlining, but i never released it. i think this is definitely something that could be improved in the language, but it is also very minor

hey Tris, you've been making great videos about how great Rust(tm) is. it would be great if you also made a video of things which you don't like about it

"If something can be done in javascript it will eventually be done in javascript" **Rust has entered the chat**

“features simply emerge”. Everyone who’s tried rust felt that

4:30 Also have a look at Scopes. It's both higher level and lower level than Rust, basically a Lisp with LLVM level core language, higher than Lisp level Metaprogramming and python like indentation based syntax, but simpler and more generic, and Rust lifetimes, but without the need of references.

rusts type system was amazing to me because it was the clearest implementation of linear logic into a type system i have seen so far

This combination of low- and high-level features isn't unheard of. You always mention C, but C++ would fit the bill, wouldn't it?

love this

Back to my login page in PHP and changing color in CSS.

Brb Gonna go oxidise the rest of my life.

I could never quite put my finger on why I like rust so much and everything felt so logical in it, but this explains that perfectly. Everything really feels like a natural continuation of the base axioms which makes my brain feel good

I look forward to your videos every time they drop. Thank you for making these tris

great video Tris, very inspiring. Sometimes is hard to know how to put all this knowledge into practise though as sometimes the documentation on some crates can be spares

Man you sound like 3kliksphillip but on a technical subject, i like that :D

I feel like this fits neatly into what emergence is about. I really like the concept of emergence.

Yes! I'm on the right path with Rust, even as a newcomer to programming. I'm eager to uncover all that it has to offer, and the future looks bright. Every concept is a new discovery, and I can't wait to see where this journey takes me!

Are you secretly teaching us C++? Was that the plan all along with Rust? I like that you emphasize that Rust is a Universal, general purpose language. When they describe it as a systems programming language, that scares away most from higher level languages, and I don't think they need to be scared of it. I do think we need concise training on the core for new developers.

I actually came back, because that product in the advertisement haunted me. I have to empower my data scientists with this. Thank you.

In the end we will see if Rust stays/becomes more popular or not. There was a time when everyone thought that whole Java is going to be rewritten in Scala... guess what it didn't happen. I look sceptical at Rust, on the other hand I look very optimistic when looking at Go for example. In fact the most popular languages are not those which have complex structure, but those which have simple structure, like Java (8), C, Python... The learning factor of a language cannot be underestimated. Right now there is a hype for Rust, we'll see if it stays that way or will it fall off eventually.

wow, drop....it makes total sense, but I assumed it did more explicitely

How does rust avoid then inserting a drop at the end of the drop function?

IIRC Infallible can also be used when you need to return a Result (for whatever reason) but there is not possible error in the function. You can return -> Result EDIT: I found the video. SUPER RECOMMENDED: ru-vid.com/video/%D0%B2%D0%B8%D0%B4%D0%B5%D0%BE-s5S2Ed5T-dc.html

I'm not sure I agree with the notion that Rust is a universal language. Certainly, it is _capable_ of much more than most languages, and in fact, almost any programming task, but that doesn't make it the best choice for many things. From my experience with C, kernels, and Rust, I would much rather write a kernel in Zig than in Rust, at least for the core parts. Attempting to grapple with ownership in a system where things have no owner and where shared mutability is a necessity is a pain. Rust also makes it very hard to write lock-free code. The lack of a garbage collector means that even in code where the performance penalties of a garbage collector really don't matter in the slightest, you have to worry about lifetimes and ownership. This makes me still default to Python for quick and dirty tasks, because it saves me the effort of complicated type annotations and putting .clone() everywhere (honestly, I think Rust would benefit a lot from a clone operator of some kind).

"hey you know how languages are usually targetted for specific purposes?" "yeah" "you know how basically every language out there has null?" "yeah" "how about we just don't do that"

Today in my functional programming class we were discussing functional programming in Rust and other otherwise imperative languages, and we touched upon a certain point which seems to be one of the few instances in which your argument is invalidated, which is that the question mark operator is not implemented as some sort of general pattern - the Rust devs created an entire special syntax for working just with Result and Error, when actually we could extend this syntax to deal with any kind of monad at all, like Haskell would let you do. Instead of making ? something that could be overloaded or generalized, they just went "nope, let's just make this beautiful and glorious abstraction limited to exactly 2 circumstances." This is a wart and a half.

11:44 C can be used to write interactive web apps, even though it was made before the internet existed.

It's funny how the processor that sequentially executes machine instructions was an implementation lead deasign but by early 90s became an abstraction with pipeline, then an ever less fitting abstraction with out of order. And now we have Meltdown and friends where the abstraction turns out leaky. There is a lot of dark arts hiding the real processor from us. VLIW was supposed to be the solution to expose the processor innards directly, but every time turned out a lot less efficient. Again abstraction allows optimisation. Maybe we're due for another run of VLIW processor. This time with specialising tranpiler from something like webasm, which can perform these optimisations as they become discovered at runtime.

I learned Rust just a month ago, and I was in awe discovering all these extremely smart decisions. It feels like Rust for the most part doesn't really invent that many new things (nulls being bad is well known, nullability markers are emerging in many languages because of it, though they are often not more than a marker, trying to cover up past design decisions). The only exception to that I can really think of is the borrow checker. It still often gets in my way, but at least I get to insult it in my comments. Enums also are a bit hard to grasp at first, perhaps because when I hear "enum" my mind already has that concept in its head from other languages, a simple enumeration type without fields. So at first it was a bit weird to me they called Option an enume when it looked more like a nullability marker. When I discovered how it's actually implemented and how it's not an opaque compiler abstraction, and same for Result, I can't put the joy I felt into words. It's simply an arbitrary convention the standard library implements rather than an explicit language feature. And because of the way they implemented unit types (None essentially carries a unit type) and enums, the compiler will still compile it with null, so you don't get any performance penalty. Same if you have your own Option-like enum. Because there is nothing special about Option. The only thing I wish for Option is that TypeName? was an alias for Option. The trait system is also really cool, implementing similar ideas as OOP interfaces, but without extensibility, so you can still work with raw structs.

1:18 Ah yes, Jagger's Law.

I see people arguing with you about axioms being chosen. I’m a math grad student, and although axioms are chosen, the important part is that everything that comes after IS discovered!! And the library of reasonable axioms one might choose from is pretty small!

this is quality content , concise and informative

Your speech would be much clearer when you turn down the bass. (just a tip) Thank you for the video, great content

so the drop semantics are /dev/null, genius 😮

But can rust macro compile rust?

I actually understood 27.3% of that. There's no doubt this mathematical underpinning is what draws me to Rust. I have a hyper-analytic mind. So I do well with things that proceed logically. Functional programming uber alles. Thought I was already subscribed. Must be RU-vid shenanigans.

"there's so much more left foR US To discover" :D

is rust really self-host?, since its backend is still llvm which written in c and c++

The Garth Merhengi bit you've got going here is good.

i would suggest that math is based upon logic, which in turn is based upon philosophy.

Thank you for this video! I'm already sold on Rust, but this helps reinforce that choice.

Hi, I have a question! My coding background is a 100% python, I have no experience with low level programming languages. I'd like to ask you what would you recommend me doing in this case. Should I go ahead and learn Rust from scratch or should I get the basics from c++ and then go ahead and learn Rust?

Looks interesting. Unfortunately, Go is more in demand right now, which is why it is prudent to learn it at a higher priority.

I kinda prefer parentheses to curly braces, if you catch my drift.

11:35 Rust assumes that the computer that it is running on can do multiple tasks concurrently, which is not always the case. The Apple ][ can only do 1 task at a time.

man, I love your work

At 10:04, shouldn't the total amount of possible states be 8 * 8 * 1 instead of 8 + 8 + 1?

10:56 99% sure that the never type (!) is stable

rust is the language of the future.

fucking excellent video brother

One up for the "hidden in plain sight" reference to the Hitchikers guide tothe Galaxy 🙂

dude It's hard stop convincing me to learn rust