In Search of Code Purity
ฝัง
- เผยแพร่เมื่อ 20 พ.ค. 2024
- Alternate title: Rust's Hidden Purity System
I was taught formal methods at university but these ultra-safe development techniques are expensive, require using unusual external verification languages, and most damning for web and application developers, they slow down iteration.
After graduating and getting a webdev job, I despaired that the safety and guarantees of the formal systems that I had been introduced to weren't available to me as a web developer.
I was going to have to act if I wanted to live in a different world.
❤️ If you would like to support what I do, I have set up a Patreon here: / noboilerplate - Thank you!
📄 All my videos are built in compile-checked markdown, transcript source code available here github.com/0atman/noboilerplate this is also where you'll find links to everything mentioned.
🖊️ Corrections are in the pinned ERRATA comment.
🦀 Start your Rust journey here: • How to Learn Rust
👕 Bad shirts available here www.teepublic.com/user/no-boi...
🛰️ Lost Terminal is here: • Lost Terminal Episode ...
🌕 Modem Prometheus is here: • Modem Prometheus 1 - #...
📓 The Phosphene Catalogue is here: • The Phosphene Catalogu...
🎵 My published albums are on spotify, itunes, etc, but I have a lot more unpublished work over at / namtao
🙏🏻 CREDITS & PROMO
My name is Tris Oaten and I produce fast, technical videos.
Follow me here tech.lgbt/deck/@noboilerplate
Website for the show: noboilerplate.org
Come chat to me on my discord server: / discord
If you like sci-fi, I also produce a hopepunk podcast narrated by a little AI, videos written in Rust! www.lostterminal.com
If urban fantasy is more your thing, I also produce a podcast of wonderful modern folktales www.modemprometheus.com
👏🏻 Special thanks to my patreon sponsors:
- JC Andrever-Wright
- Miah Beach
- Taylor Dolezal
- Thomas Picard
- David Senk
And to all my patrons!
Alternate title options:
1. In Search of Code Purity
2. Rust's Secret Purity System
3. My Journey from Haskell to Go to Rust
4. const fn: Pure Functions in Rust
![ตั๋วเมีย (ຕົວະເມຍ) - SOMBATH.97 Ft. YOUD SALAVAN [ Official music video ]](http://i.ytimg.com/vi/GV6qHagpp50/mqdefault.jpg)
ERRATA
- Wikipedia's got a great overview of Formal Methods: en.wikipedia.org/wiki/Formal_methods
- 7:00 : typoe Cofigurable -> Configurable.
- 9:04 typo: faddone -> addone
The quote at the end says "purerer" instead of "purer"
5:41 should rstest be in the [dev-dependencies] section?
Coq has been renamed to rocq for obvious reasons. (If you're interested, thr new name is short for Rocquencourt, where the prover was first developed)
ah, probably
hehe yes, that's me being daft
"I am not sure if what you want is actually what will make you happy" is such a baller comment to leave on someone's technical question
You can't always get what you want
But if you try sometimes you just might find
You get what you need
Your average SO answer.
thats some gandalf level shit
Especially when giving no more information
"It's not C++, but better. It's haskell standing on lisps shoulders, hiding in C's coat to sneak into production"
Ok, that is next level :D I love it. I am not a programmer (just like reading about it as a hobby), but you may make me start learning it for real with your videos and rust.
Are you interested in making videos targeting beginners (using rust of course)? It would be an interesting idea/challenge to teach rust as first lang.
Thank you! I already did: th-cam.com/video/CJtvnepMVAU/w-d-xo.html
Do it!! Programming is tons of fun.
Programming is empowering, and very fun if you like hard, structured things like RimWorld or Dwarf Fortress or Factorio. It can also be painful to learn and do at times. (You're always building new brain muscles.) Best of luck!
Love how this channel has turned into a huge ad for Rust. I've been reading about Rust from an outside perspective for years but always thought it'd be annoying/painful to get into. Your videos slowly warmed me up to the idea that this is not the case.
Someone got me a physical copy of Crafting Interpreters for Christmas and I decided to pick up a new compiled language before I work through the book (the last compiled language I used was Java 8-9 around 10 years ago and I did not feel like going back to Java lol). Went through your entire Rust playlist during downtime between festivity-related business and started working through the rust book, one chapter a day. It's been a blast so far!
Wonderful! yes, I'm desperate to tell people about this incredible language because it's so *chill* to code in, I don't write... BUGS!
Speaking as a relative newbie, you'll want to have tight integration between rust and your IDE, so you can proactively respond to error messages, at least until you instinctively learn the rust idioms. VSCode does this okay with minimal setup.
The type system makes a very strong contract with your code, so I find myself twiddling function signatures a lot to change the contract to allow me to add the behavior I need.
This is more rewarding than debugging, but is a big time-sink in the beginning. Occasionally, I realize I'm not smart enough to express what I want in the type system, so I have to move on to a different strategy.
I recommend learning about type aliases early on, as they can help save typing when you're repeating a long type annotation and need to tweak it.
Also, Rust a lot easier to learn if you already know Haskell. Then, all you have to learn are lifetimes and borrows + syntactic differences.
You don't have to learn to build or understand macros upfront, although you'll probably use a few. Just treat them like the annotations and typeless functions from other languages at the start. That mental model is working okay so far.
Coming from an OO language, you'll find several new things: composition used in place of inheritance; new and powerful kinds of polymorphism; sum types (enums); enums used instead of null (Option/Result); traits instead of interfaces.
What a coincidence! I've started to read the Rust book as I plan to tackle the Crafting Interpreters book with Rust!
And why exactly do you love it?.. Are you that much in need of someone confirming your point of view that all the kilotons of Rust ads out there are not enough for you?
@@em_the_bee Are you getting angry about a comment I made months ago on a video? Wow!
Maybe read more than the first sentence of a comment before replying with passive aggressive questions, though. The second and third sentence of my comment answer your question and point out that what you're trying to complain about is not what's happening.
I don't think we _have to_ compromise.
Designing an ergonomic language that can still be formally verified is definitely a challenge, but I am confident that with managed effects, capabilities and dependent types we will one day create something you can fairly quickly iterate on at first and later on still add proofs, formally verified optimizations, etc.
Just a quick "ad" for three languages:
- Ownership and borrowing of linear resources are basically purity. You just need a capability system. For an excellent example of that, see Austral.
- If you want to see Haskell, but with neatly integrated formal methods, take a look at Idris.
- And purely functional languages can absolutely be ergonomic. Elm is the easiest language I've ever seen.
hmm, and yet nobody has managed yet. Rusts practicality is imo a big reason its actually gotten popular unlike many other languages which try new thinga
I applaud the effort, but over and over we have seen that if you make that language, no-one will use it enough to solve the problems in the world we're hoping to solve, and it'll be another Haskell, languishing with Matlab on this graph redmonk.com/sogrady/2023/05/16/language-rankings-1-23/
All the features you mentioned in your other comment can be built inside rust using the Macro system, and many of them are (go check lib.rs!) which is tremendously exciting!
@@NoBoilerplate I don't think it's a good argument to only look at the failures of today's languages. I too am hopeful for such a language to exist. After all, before Rust, it was either you manage pointers directly and have to compromise on safety (even in C++ where you have somewhat decent pointer management helpers), or you use a garbage collector and have to compromise on performance. Rust made it so you don't have that compromise anymore _by language design._ Language design is the kind of stuff that can solve these problems, so being hopeful about it isn't unrealistic.
Totally agreed, and I'm expecting the next best thing to be bootstrapped in Rust :-D
Such possitiveness, you are a stress relief!
A big fan of lost terminal as well btw:)
Thank you so much!
7:11 probably the best description of function purity (and encapsulation in general) and why it's good
thank you so much!
I feel like this video is a great way of explaining modularity of Rust as a language. Making Rust more specialized i.e. making Rust a more pure language via an easily controlled limitations by adding rules to compile e.g. minimalistic linting and some added packages is definitely is a great boon to language. Also, the phrase "Rust is a pure as possible, but no purer", really solidified the idea in the end. Your video gave me just one more reason to love Rust, and insight into programming languages in general. Thanks for the great videos as always!
Hi tris, a random viewer here with a take... This seems very similar to c++ consteval/constexpr, and zig comptime functions. In c++ consteval/constexpr is very strict scope like in rust although comparably less strict, it allows arithmetic on Floats etc. but rest are pretty similar. To me it just seems very similar in terms of purity, one of my tricks when writing a pure function in c++ is to just slap a constexpr at it and see if the code compiles...
I am a fan of formal methods and rust has so much to offer in that area. One of the most interesting things for me is how the compiler has so much information about the code that some very interesting optimisations become available. And while most of my more esoteric projects in rust eventually end in me bemoaning the absence of dependent types (const generics are not enought) the rest of the time I am quite glad that I do not have to depend on somebody doing very elaborate type shenaningans.
Thanks! Your vids are sweet and to the point. Excellent signal/noise ratio! :)
It's nice to see C++'s constexpr being brought to life in Rust as well, that's really cool as it has many of the same benefits in both languages. Being able to easily see a function has no side effects just from glancing for that `const` is really useful.
Man your video's are hella motivating. You're an inspiration, keep up the good work!
Thank you!
Hey mister no boilerplate I started following you some months ago your videos on time management and such really helped me out ❤ thank you
Formally proving code is almost mever done, not even in medical devices and at NASA. Sometimes very very small parts of the code base are formally proven. But it doesn't really solve much because compilers are to complicated to formally prove, CPU microcode is not formally proved, the hardware itself isn't. And even if all that where, if a cosmic ray hits the hardware in an unlucky way, all bets are off. In practice software is split into small units and those are tested to a required level.
I love the perspective you bring to programming. You are like the carpenter who is also a philosopher. You understand the practicality while putting it in the context of the meaning of life.
One commenter says that the channel is an ad for Rust. I disagree with this comment. I am confident that you will call out the things you do not like, and I don't believe you are paid.
This channel inspired me to cover Rust in my upcoming bachelor's thesis (somehow, I haven't figured out yet what practical topic I could cover as I have to be very specific with things). I really want to see it get adopted more.
Your conclusions are so unconvetional but the same so practical. Never stop to be amazing !
I have made the transition from Haskell to Rust too, for me the main reason was the lack of control over inner runtime "gears" that made really hard the performance tuning. I liked pretty much the monads and the type system though.
I'm glad your channel exists. I got back to learning Rust again after i dropped out for a while. Thank you for existing!
My pleasure, this kind of excitment is what I'm here for!
@@NoBoilerplate You're causing me to hate the language (C#) I use at my day job. Presumably, that's _also_ the excitement you are here for! :-p :-D
@@creativecraving C# is the cream at the top, appreaciate it, 99% things are much worse
loved haskell in school and am now two weeks into learning Rust, again your video has been perfectly timed. excellent!
wonderful!
I feel like Zig also incorporates concepts of pure functions through the compile time evaluation. Functions that run at comptime cannot have any runtime side effects. The compiler caches the call of the function, so calling a function with the same inputs at comptime will be guaranteed to produce the same result. It also doesn’t have many of the limitations of Rust const fn. You can have any loop you want (and even inline the loops too, if the bounds are compile time known). Additionally, you can assert and compileError or panic to stop the compiler. And since some comptime functions can also run at runtime, you can keep the purity of the function too (only it won’t be guaranteed unless you run the function at compile time first to verify).
I see zig comptime more comparable to c++ consteval/constexpr it's more of a compile time execution for a function (I absolutely love it, I use them as primary design for 2 of my major projects). But I doubt they are similar to rust const fn... For example floating point operations are allowed.
as someone who doesnt actively program (but really should) these deep dives into structures surrounding the languages puts them into perspective nicely.
Now i somewhat understand why people like rust, as opposed to, knowing that people like rust.
How did I not know about const functions? The way you presented this has given me so many ideas :) I really liked this video
Zan! Hope you're having a great time. Yeah, right!? What else is this fun language hiding from us!
I love the quotes in these videos. They capture the idea of Rust so well.
AFAICT, the subset of Rust that uses mutable borrows and mutable local variables, but is otherwise pure, can be mechanically converted into normal pure code (e.g. Haskell) by changing all the mutable borrows into passing-in values to functions which then return (alongside the proper return value) the updated value that gets re-incorporated into the datastructure whence it was mutably borrowed (and all the mutations of local variables must be turned into Static Single-Assignment, and loops into recursion, etc).
I noticed this in Advent of Code 2022, when one of my Rust solutions was similar to an online Haskell solution, but with mutable borrows instead of returning updated parts of datastructures from functions.
One of your best so far. Bit dense but invites deep thought.
You are a very inspirational person! Your work is awesome! Thanks!
Thank you so much! I'm hoping to help as many folks as I can (and I'm learning a lot in the process!)
Really useful knowledge. I have a mostly functional programming background and is working on learning embedded rust, so I highly value this kind of knowledge. I always wished that I could just write all my code in something like Idris, but have concluded that Rust is good enough for now.
..and love that night club image :p
Great video! I have spoken with my friends (one of whom is a Haskell enthusiast) about purity several times in the past, and kept coming back to const fns. It is kind of disappointing how limited they are, but I came to the same realization that due to the borrow checker, I really don't *need* a purity system. If a function takes in no mutable parameters, I can be reasonably sure it's not going to have any side effects *that matter to my code*.
You've got it exactly. Also, we don't need Rust to be Haskell, we've already got Haskell! We need something that brings MOST of Haskell's features to the masses, and that's Rust
@@NoBoilerplate imo if that was your message, then const fns is very far from something that I'd call best for showcasing this
0:40 Now I have that tune in my head.
Happy to see more Rust videos. I've watched every video, some multiple times. Re Nim, I've been publishing a series of videos exploring the language by writing an interpreter in it. For anyone interested in Nim, you might enjoy and I appreciate any feedback.
Really liked this video. very clear and well reasoned, and about a topic which hasnt gotte enough love!
Thank you so much Laund, and thank you for your help!
Agreed
4:21 Nim is my go to these days. So much fun to code microcontrollers in. Not sure how having memory management is a downside?
Sure it’s a bit obscure, and the stdlib needs work. I don’t use the stdlib for embedded anyway.
I've coded webapps in Haskell professionally (specifically reflex, an FRP framework).
It was a great experience. Without FRP it would have been painful though.
Thank you to introducing me to this clippy option. I love it
This video couldn't have come at a better time for me. In the middle of learning Rust for the 2nd/3rd time, starting to get it, and this cut at the reason I was looking at it. The "const fn" attributes you describe remind me of Python's Numba library, where there are similar restrictions in NoPython mode. That library is one of the reasons I went further into Rust, because Numba is so fast, but Rust was faster. Thanks!
I'd love to see you talk Nim more. I've started using it recently and it seems like the Leonarod Da Vinci of programming languages, defying conventional wisdom by doing so many things and doing them so well. Combining the features from other languages that are normally really the main reason people use them (pythons simple syntax, C's low level performance, C++'s versatility) It might become the "anti-rust" competitor language.
Its creator is what I'd call a religious fascist who has called for violence on various occasions and believes there is some queer dystopian conspiracy. This personality reflects in conflicts inside the project and management style and pretty much assures that the language is going to stay obscure. There are many great ideas in nim but the language is not perfect and will probably get eaten up by the next language that figures that developer experience and performance are both important. As well as marketing and community building. Maybe mojo.
@@pik910 What? I'm relatively new to Nim community and I have no idea who you're talking about.. Yes, Araq has some conservative views, but calling him fascist has absolutely no bearing with reality. "This personality reflects in conflicts inside the project and management style" - my impression is totally opposite, Araq can be grumpy and harsh in words, but he's also not the last to apologize and admit his mistakes and flaws.
P.S. regarding "queer dystopian conspiracy" - he's not far off if we're talking about modern social-political discuss in and around US, but that's totally off-topic =).
Unfortunately, neither Haskell nor Rust has a version of "purity" that allows you to guarantee that a subset of the code will not crash/panic at runtime. This was my biggest disappointment with Haskell.
these videos are what got me into rust and i love it
wonderful, thank you!
Your comments about Go got me so curious. You say: it's too practical and efficient, no beauty in it but not in terms of syntax, and yet it almost worked for you. I would love it if you could expand on what you mean with all of that?
before rust, i didn’t “get” iterators. now that i’ve used them in rust i get it.
one little thing that i like is that a for-loop between two numbers is written like:
for i in start..end { /* blah */ }
in a traditional for-loop, the end expression is, at least conceptually, evaluated with every iteration of the loop, but in this syntax, the range is constructed and _then_ iterated over, which makes me feel much less anxious if the end expression is something expensive, while also making the code actually cleaner.
i have similarly grown to appreciate other “functional” concepts as well.
I love the description you gave to Go, especially because it’s not a compliment.
I know it’s completely counter intuitive but I get a strong feeling of PHP when I work in Go, and I can’t put my finger on why.
I tgought this same exact question when searching for a Full Stack JS replacement. I am completely done with stupid preventable bugs with JS, so I am moving to greener pastures.
Front End -> ReScript
Back End -> Rust or Elixir
oh ho ho, you should try leptos.dev
Depending on what you do with elixir you don’t even need the front end you can use the liveview
@@randomthings1553 I know Elixir is great, however, Phoenix has limited React support.
Your videos are so inspiring and informative! I'm wondering what your opinion is on C#? I'm a game developer and I code everyday in it. I also know a little bit of Rust and from what I see, C# feels like an "easier" version of Rust. It's type-safe, has compile-time source-generation, the newer versions are including more and more functional patterns and paradigms, and it's still fairly performative (though not as much as Rust).
I adore Haskell so much and this video makes me so happy! I love it!
4:30 could you explain the "garbage collector" part for Nim? I'm not a Nim user, but don't all of the languages on the list except Rust use a garbage collector? Why is Nim's garbage collector emphasized here?
I also don't understand. Nim is also, probably, had one of the best GCs from that list: fast, deterministic, low-overhead, no 'StopTheWorld', memory safe, thread local.
But it's definitely not an issue now with ARC/ORC being default in 2.0.
I tried Rust and had some fun before giving up since I found it too slow to write with, but after seeing so many of your videos, I'm going to dive back in and try again 😅
it takes much longer than other languages to reach a proficiency where you're fast. but it saves a lot of time in other areas like debugging of complec problems.
It's only slow using your old coding techniques and habits. If you code, compile, test, look at an error and try to guess what's wrong, it'll certainly be slower!
But with rust you can code faster by using what I think of as "Compiler Driven Development", using clippy to give you incredible feedback, before you even run your code!
th-cam.com/video/CJtvnepMVAU/w-d-xo.html
Rust has so many well thought little design decisions that add up without you noticing that when I work on other languages I can't put my finger on it but it always feels like something is missing.
yes! Absolutely. In games there's a term called game feel, it's a bunch of little decisions that add up and elevate a game for the user. There's a similar thing I experience using rust.
Over my 5 years as a Haskell developer in industry I found Haskell no hassle, but a joy to use for just about any programming tasks. Web services, API clients, html and code generation, writing cli tools, servers, web sockets, parsers, interfacing with OpenGL all work quite straight forwardly and quite elegantly. There is a tough initial learning curve doing pure fp and monadic IO, which seems to deter many people. But once through it, it does no longer get in the way and I did not find there to be a compromise necessary. What Haskell really suffers from is that it only has a small community like Python in the early 2000s. There are fewer library and dev tooling choices and some struggle with maintenance. That said eventhough Haskell has much more effective safety than main stream languages, it is still quite limited in what is practical to prove. Maybe that's why what is there right now does IMHO not have the practical problems No Boilerplate seems to suspect.
From what I can tell the main reason rust is compared to C++ is some see it as a successor to it - a powerful, fast running language to write performant code for operating systems, and robots, and the fact that it has kinda similar syntax. It is very clear upon looking deeper that they are very different languages
I got into coding last year in April. I started with The Odin project and I loved it. I learned the MERN stack. I jump to ruby and ruby on Rails, which is pretty nice, but I discovered my dislike for implicitly typed languages. I looked at Python but I didn't get any tingles and then I learned Rust and again I discovered something new about myself, I discovered my dislike for weak typed languages. I absolutely adore Rust, but as I'm planning on building a PAAS on a timeline, I still have to go with something like Ruby on Rails or NextJS as a team of two newby devs. Feels bad man...
Best of luck to you!
ty@@avidrucker
4:48 "crushing march of efficiency" "too practical" some of the reason that I absolutely *love* Go.
except it sacrifices so much in the name of "practicality" that it loops back to being a hindrance
Why doesn't go.dev have syntax highlighting?
congratulations and condolences on loving the beaver
love the lil' _(it's rust)_ there
hehe, gotcha!
Hey Tris, thanks for another great video. It once again comes as I'm reasoning through something similar with some side project rust code. I have a struct of state that I use throughout a program, and I've been iteratively making the things that update it smaller and easier to reason about. I didn't realise that what I was doing was making my methods more functionally pure, but now I have a reason to lean in even further!
The only thing that I didn't quite get (maybe I just need to read around it some more) but I see what we can and can't do with `const fn`, but I didn't really understand why we would want to opt in to them, given that we are wilfully limiting ourselves to what const funds are able to do, versus "being good citizens" with limiting side effects in regular functions?
Awesome video, thank you!
Funny, I am using this video as a motivational source to learn rust, I read the documentation, do some rustlings exercices, get mad because I don't understand something, come back to this video for motivation, repeat. Thank you!
Love your videos! Keep it up!
thank you, I will!
I'm always unsure whether to consider &mut parameters to be "pure" or not. In one sense, they're obviously being mutated outside of the return value, but in another, the fact that it's explicitly marked means that you can basically just treat it as an explicit return value with more ergonomic syntax and more efficient performance. At least, this is at the function definition site. On the caller's side, it's less clear when a method call would mutate its receiver.
The lack of printing in const fn is probably my single biggest concern about them, since it's extremely useful to know the actual value that the function is being passed so that you can better determine what exactly you're supposed to block and how. Without knowing the actual type you should use or what preconditions have seemingly been forgotten, and without being able to just print out the value that shouldn't've made it through, the only remaining options are to either remove the const flag, or use a debugger to be able to effectively insert extra print points ad-hoc. I'm pretty sure several pure functional languages have impure escape hatches specifically for printf debugging (even if laziness means they're not as useful as they'd be in a strict language).
There's also the matter of const traits still being unstable, so if you have a pure function that you want to make generic over a particular (presumably pure) trait, you can't actually mark it as const quite yet.
I agree, I don't see how &mut could cause problems here, as only one mutable reference can exist at a time. They are also very useful, I use them to compute FFTs at compile time (unfortunately requires nightly compiler for now).
Printing could be considered pure if it's write-only from the point of view of the code - even though it's mutating global state it can't have any side effects if no function is allowed to read the log. Maybe for now we could have a macro that appends a message to a file instead of printing?
Does C++ get the same effect as Rust's const with constexpr? If not all the way, does it at least get most of the benefits?
Thanks!
Good content, as always. There's small typo on 7:00 : Cofigurable -> Configurable. Also on 9:04 : faddone -> addone.
thank you!
@@NoBoilerplate made a PR 👍
Finally! Waited so long for Rust treat😂
ikr!
“…Production, the popular night club where all the popular languages hang out” - 😂 amazing
You're the reason I'm learning rust!
WONDERFUL! You're going to have a really great time!
gosh I love your videos, none are like yours
also rayon is already 9 years old whoa whaa
That was very well presented and tantalising and moreover is a timely prompt for me to get beyond my very superficial knowledge of Rust.
*A correct program but not necessary the right correct program* ? 🙂
I'm not an expert in proofs, but they have always seemed like an impractical panacea to me, except in very simple use-cases. Sure we could formally prove that the code matches a potentially very elaborate specification but how do we know that the specification matches what we really wanted the program to do?
"I was going to have to act, if I wanted to live in a different world" - why does a banger song started playing in my head after hearing that?
So interesting.
I'd imagine the allowing the macro system in const fn's could possibly get a little bit messy when it comes to cross compiling.
I'll have to experiment.
I enjoyed that content
How did you make the venn diagram of sound formal languages and practical programming languages? The circles have some imperfections, which makes it look like they were drawn by hand, but they are much more circular than I could do by hand.
its likely something with a handdrawn theme. i think excalidraw has that?
Excalidraw plugin for Obsidian :-)
Aren't formal methods used to specify systems/applications before even getting to the coding part? That's where they come in useful cause they enforce reasoning about the What before starting implementing/code the How.
That's the beauty of formal methods where they help formulate the Functional Requirements into a formula that is hard to misunderstand before finally, a programmer translates the requirement into code.
You even get to run and test the specifications using model checkers to validate before moving forward to the coding aspect.
Can Constant Evaluation be compared with Zig's `comptime`?
I want a formal programming language that disallows stack allocations because moving rsp is a side effect.
I mean, that's kinda rust const functions!
even better, i want a programming language that disallows changing rip register
Food in a plate, tea in a mug, warm slippers and a No Boilerplate video..... can life get any better?
Tris, top vid as ever. Quick question, do you offer one-off mentoring sessions? (I tried DMing you about this but you very sensibly block these)
Yes, its normally monthly but no issue booking just one
also, feel free to join the discord and ask there
Woah these reminded me of Fortran's pure subroutines and functions.
easy to do in a simple language, imagine doing that in a language that runs in the browser ;-)
@@NoBoilerplate Haha fair enough. Glad I chose to be a physicist instead.
abouta start!!!!!
Haskell is getting dependent types added to the GHC so most of the you want is going to be natively supported. And I know other people have said this but Rust isn't an fp language nor is a general purpose language so most general purpose applications wouldn't use it because it deals with plenty of unnecessary details the same way formal proofs are. And haskell is far more practical than nearly every general purpose language, pretty much by definition
Ok, you got me interested and now I want to try Rust too. Where would you recommend to start? I was programming mainly in Ruby for 6 years and recently my workplace made me switch to TypeScript.
Tris has a whole video, but let me give you my opinion:
read "the book" twice, once fast without trying to understand deeply, then again slowly
do rustlings alongside the book, badically pre-made practice problems about a specific feature each
read rust code in Rust by Example
Oh wonderful! I made exactly this video, I hope it's useful: th-cam.com/video/2hXNd6x9sZs/w-d-xo.html
hey, if you have so much Ruby and considered FP language, Elixir is your bro
Thank you all folks 🙇
@@Randych I heard Elixir is quite cool, but I wanted to pick up something that is NOT similar to Ruby. Like Tris, I have ADHD and I need novelty to keep myself motivated. Also there is lots of hype around Rust and I wanted to see why :)
"Haskel standing on LISP's shoulders, hiding in C's raincoat trying to sneak into production" needs to be made into a cartoon!!!!
Great stuff to know ! And to remember ....
Provable code is actually very easy in any language. Just look at the code. If you're looking at code, you've proven that it is in fact code and can rest easy on the mathematical certainty that the system that it's running is 100% code.
What do you think about Roc lang?
TH-cam didn't send me notifs for this video. What happened
Not a Rust developer, but I have watched all the videos on the channel so I’m not sure if I’m missing something… if the Rust macro runs at compile time, would that imply that the PATH from the macro version would be the PATH environment variable of the machine that built the code, and not the one running the code? They seem to be presented as equivalent in the video, but I don’t get it unless you force the user to build on whatever machine they are deploying to or if I’m missing something else.
const functions can run at compile time too. if you could call the env method in a const context, it would be the same as the macro. but you can't. so you use env!() for the compiling machine and env() for the running one
One big reason you probably shouldn't make all possible functions const, most notably if you're writing a library: turning a const function into a non-const one is a breaking change, since your users won't be able to use it in their const functions anymore. So adding the "const" keyword should not be automatic: you have to think about whether you could need non-pure stuff in your implementation in the future (including loops etc).
Where would you pint someone to to learn mode about formal methods? My university did not cover them at all in my studies, although we did some proofs of algorithms' correctness and performance, this was all on paper and pure logic
Especially something that covers not just the mathematical and logical background to understand these systems thoroughly, but some examples of languages and applications
"Beauty is in the eye of the binary holder" 😄
It would be nice to have a compile time function type or something. As sometimes having code that could differ based on the processor is ok. For example I might want to do some matrix math which could involve sin and cos for rotation, and save the result to a const variable. Let us say the worst thing happens, and somehow we have a 90 degree difference between a runtime rotated object, and a compile time rotated object. It won't matter for game development, because the player would never know what rotation was intended unless they check the code. Perhaps it would be nice to have some sort of unconst block that alllows running non-const functions in a const function, when it is known that bad things won't happen.
Edit: Just got to the macro part of the vid, I had no idea that macros could do that, I'm going to quickly mess around with trig functions in macros, and see what happens. I may delete this comment if macros are good enough!!!
Update to the Previous Edit: Perhaps with proc macros it might be possible (but they are even more inconvenient than build scripts)! However with regular macros I don't see how this would be possible.
I am new to programming, do not undestand so much details, but there is a language called zig that is claiming to be rust killer. can you make a video about it if it actually is better than rust or not?
Reminds me of what c++ is doing with constexpr functions
I think Lean 4 is the closest thing to a perfect language for me. If it's good enough to prove the most complicated theorems in math, then it's good enough to prove simpler practical things. It's just so clean and powerful
hmm, whats the progress on its ecosystem like? is it general purpose enough to cover various topics from graphics, ui, web, api etc?
@@laundmo it's still very new and focused on mathematics built by mathematicians. But I have no doubt you can extend it to do whatever you want a programming language to do. In fact the former executive director (David Thrane Christiansen) of the Haskell Foundation recently moved to doing research for Lean, and just yesterday demo'd his markdown-like syntax in Lean used to generate documentation. I wish I could fast forward a few years to see what Lean is capable of, it seems very promising to me
Oh nice, I'll check it out too. Note: I'm not here raving about Rust because I think it's the best language, I'm here raving about rust because I can get paid to write *nearly* the best language :-D
Lean is a proof assistant, not a general purpose programming language. Dependent types are great for encoding fiber bundles and what have you, but several languages that employ dependent types have failed to gain any sort of mainstream traction as they are simply far too complicated and cumbersome for any sort of practical program that isn’t written by PhD students.
What are your favourite clippy (or rustc) lints? especially allow-by-default that you'd like to be warn by default, or perhaps even deny or forbid.
they're in this video!
@@NoBoilerplate I couldn't be sure you didn't hide a few more XD
Recently I've been on a kind of clippy addiction, went and tried to make as many lints work together as possible just for the fun of it, I ended up discovering quite a few that I like.
The most memorable ones for me must be:
- infinite_loop = "forbid", I think this should just be considered a compilatiom error, as `!` should not coerce into `()`, it can make it quite hard to predict the behaviour of a function, especially game loop related ones, for the same reasin I wish `Result>` should be mandatory over `dyn Box` in fallible loops.
- allow_attributes = "forbid", I see no reason not to use `allow` over `expect` if `lint_reasons` is enabled.
- mod_module_files = "deny", this naming scheme can make traversal via file finders quite difficult
- non_ascii_idents = "deny", without it it can be hard to understand contributioms on an open project with devs who speak different primary languages.
#[deny(unwrap_used)]
#[deny(expect_used)]
😐
How would compare Rust to zig ? DO you thing they have separate use cases ? Who would be more suited to learn either ?
imo: zig is for the few projects which need primarily unsafe rust. it has barely any safety guarantees like rust, and is much more a extension of C
Laund has the right of it - zig is a great modern C, but Rust can replace C, Java AND Javascript. I'm excited by having this universal language!
Hey Tris,
I started a discussion on the Rust internals forum to expand enum functionality.
Would love your input on that matter.
Cheers.
I'll have a look, cheers!
Nice command and conquer reference
SPACE!
Great video, as always! Hope you see this comment, I'd like to debate a little around determinism. I embrace purity in my functions as much as possible, especially because it allows a lot of compilation optimizations and pure functions are infinetely better to reason about, but after programming in Zig, it seems that determinism is something that's more present in theory. In the code you presented, Rust makes assumptions that you didn't run out of dynamic memory. It seems that the natural state of everything is not effect-free as there are many variables from the physical world that definitely affect the digital world and programs that run on it.
One example from the code in this video is your const fn sums x + 1. It makes the assumption that x is not the max value of your type, let's say, u8. Otherwise, you'd have a side-effect where the code is supposed to be effect-free.
Do you think we should embrace side effects as the normal, or keep the assumptions where it makes sense and rarely generate side-effects?
adding 1 to a u8::MAX is well defined though, and causes nothing except the u8 to change. wrapping in release and panic in debug mode.
„I want my code to be poetry”. Obsessive compulsive utopian JOY.
there's even no syntax highlighting on go.dev/ it's like they hate joy!?
Maybe I'm missing the point or misunderstanding in general, but const sounds like it has nothing to do with maintaining program state. In C++ I use const to express that the function doesn't modify the data coming in or the state of the object the function is a member of, or return values which I don't want the caller to mess with but don't want to necessarily copy. It sounds like in rust that const is more of a purity checker than a constness checker. Not allowing floating point operations is a specific example that would drive me crazy. I want to add two numbers together but I can't, not because it will modify state, but because it could return different values on different systems. It seems like there should be a const annotation for functions to accomplish what I said before, but a purity annotation should be separate. I'd be very interested to hear if I'm mistaken in any way in my analysis here.