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

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

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.

I feel like Rust is becoming a religion.

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

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

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 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.

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.

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.

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

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.

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!

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.

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.

"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...

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”

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

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

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.

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

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!

“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.

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

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.

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

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

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

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

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!!

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

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.

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.

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

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

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

I was not prepared for the tomfoolery of the drop function

"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

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

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

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

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!

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?

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

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

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!

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.

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.

love this

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

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

But can rust macro compile rust?

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

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.

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

Brb Gonna go oxidise the rest of my life.

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

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

1:18 Ah yes, Jagger's Law.

2:22 meaning of _self hosted_ compiler 2:28 i dont think zig is self hosted yet?

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

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.

How you handle exceptional cases, I mean how you can handle events that can happen at any time unexpectedly, like KeyboardInterrupts, SIGKILL and SIGTERM? A usecase for handling these is when you are writing a software like a text editor that needs to save user data before exiting.

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 UKposts shenanigans.

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!

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.

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

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

I think math is built on philosophy

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: ukposts.info/have/v-deo/q2WEZnubbIpexZc.html

fucking excellent video brother

do you have a series on Scala? just wondering since everything that people like about Rust (other than the manual memory management or borrowing) is in Scala :shrug:

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

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

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

Great video. As someone who loves functional languages, but is forced to use C++ at my day job, I really enjoyed the way this is presented. The rest of what follows is a nitpick: I feel that your point about Optional and Reault are muddled somewhat by one of the few warts with Rust: the question mark operator being a compiler hack instead of an instance of a general purpose monad. I feel it wouldve been worth juxtaposing the Rust author's choice to define optional and result in the language itself, but question mark as a builtin hack.

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?

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

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

I really like how while certain things seemed weird and arbitrary at first, as I learned why they are that way, it all started to make a lot of sense and I ended up learning more about how those things technically work. An example of this is the distinction between String and &str. Also, I am curious why drop is not marked as const in the video. It seems like it could be. Is there any reason for it not to be?

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

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.

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.

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

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

man, I love your work

have you had time to play with typst?

I have not really liked using Rust so far with an admittedly small sample size, but I do really love the deep, detailed discussions that the Rust community tends to generate. The merging of high level functional programming and low level memory control has been enlightening to witness and learn about. I feel inspired to make my own language (well, another language -- I've already made a simple language for building embedded ACLs that compiles to bytecode and is extensible with up to an additional 194 operators) that merges some Lisp syntax with lexical scoping, more data structures than just a singly-linked list, consistent and no-nonsense naming convention, reference counted pointers for all variables, and no heap memory. The algebraic type system and idiomatic result handling are things that will probably make it into the first version.

Ohhhhh that's why they're called product and sum types!

I want to check your sponsor Quadratic , is there a link somewhere?

I'm sorry, but the whole point of Kotlin was to have non-null types, it literally started with that (at least when it crawled out of obscurity) "readsble Scala with convenient non-nullable types" is literally how I described it to friends att the time The downfall is ultumately that it has to interact with Java and it's nulls 😂

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