Видео

He tried to talk 1 hrs content in 5 minutes. And this pacing makes the whole video useless.

2:30 Wrong historical & conceptual information. Russell's Type Theory wasn't constructivist in any meaningful sense. It only aimed at incorporating Poincaré's "vicious circle principle" to avoid the contradictions of naïve set theory. Type theory didn't become properly construvist until Per Martin-Löf reconstructed it on an explicitly intuitionistic principles following an astute analysis of Brouwer's original program of intuitionsim.

6:57 ah but now we can, as generic constants have since landed in stable rust🎉

I'm recently waiting for some dnd or coc game in real life, and, I found one here.....

Finally grasped the mechanical steps I need to pay attention to when dealing with the borrow checker in today's rust code!! This needs to be documented in the rust book the way it was explained here, the best explanation of borrow checker yet !!

I don't get it. How does a typical OO background make traits hard to understand? Also, for a "deep dive", this doesn't dive very deep. I was hoping to learn the differences between using generics on a trait and having a type field.

The video game example is really good for understanding traits.

This is a lot like nix build

I wouldn't exactly consider myself a rustaceon, but I found this to be a nice talk

I came across this video today and I think this is the best explanation of Traits in Rust on the internet!

👀

In _raku_ (`raku_lang`) the type hierarchy starts with "Mu" - which puts "the developer" in the realm of logical philosophy and Buddhist metaphysics right from the get go.

18:41 should be Vec<Box<dyn Cast>>

❤

isn't it Box<dyn Cast>

omg let him hit the spacebar!!

I wish this project resumes development, because I actually really like KDevelop, and I think it's just a shame that it doesn't see much use because of the lack of language support in general. That being said, C/C++ support is fantastic.

Dang, unfortunately the project the become stagnant:(

I just wish slice::Windows could produce `Item`s of known length so that they could be unpacked. This would seem to be a solution. But there has got to be a limit somewhere; I think the typescript type system has been shown to be Turing complete. Maybe rust can beat it by being the first to run Doom on a type system.

Without defining what "0.999..." means or what operations you can do on that object, one can hardly consider this a proof. Here's one definition: "0.999..." is shorthand for the sequence 0.9, 0.99, 0.999, 0.9999 and so on(*). When we say that "1 = 0.999..." what we really mean is that 1 is the limit of this sequence. If this is what we mean, the proof should follow easily from the kind of real analysis I expect first-year math students to learn at most universities. I guess we can call the sequence X, and let 10X be the component-wise scaling by 10, i.e. 9, 0.9, 0.99, etc.; then the component-wise difference (= 9X) is 8.1, 0.81, 0.081 and so on. We can then divide by 9 and get back X = 0.9, 0.99, 0.999 and so on, i.e. we can go back to where we started. But this doesn't prove that the sequence has a limit. (*) Note: we can define the sequence recursively: x_0 = 0.9 and x_{n+1} = 1 - (1 - x_n)/10. This recurrence has a single fixpoint, at 1, the iterated function is continuous and the distance to the fixpoint decreases by a constant factor. Together these facts imply convergence to the fixpoint.

Mayb you should achieve volume first

The question I had that wasn't answered: what prevents this from being the way we do borrow checking today?

Will this solve this problem: - case that doesn't work: object.call(object.value()); - case that works: let value = object.value(); object.call(value);

Great talk! Cool timeline :)

The difference is in HOW you write an unsafe code. If the programmer has to do something too advanced for the Rust compiler to comprehend, you can take over control. There's nothing wrong in calling unsafe function that has no flaws (aka is "pure")

Hadn't seed that thing about dependent types moving up one universe level, very cool

lmao this is wonderful

That's not dependent types, but rather an overengineered, hardcoded, typed nightmare bullshit. Imagine trying to use this in a production code. Actual dependent types don't depend on types (pun not intended) and can be inferred automatically by proof checker from context.

Great talk!!

TBH, Most pragmatically useful content is at the beginning and end. IMO, the content in the middle while nice background information is a little light on utility. @ ~ 1:20 Ms. Manning points out difference between string.len() & string.char().count() @ ~ 15:40 Ms. Manning talks over UTF-8, UTF-16, & UTF-32

28:00 couldn't we save some space in Dashed variant by making it Option<NonZeroU32> and the resulting Option would have the same size as u32, 4 bytes? Dashed with zero spacing should theoretically look the same as Solid.

Thanks a lot for such an impressive talk!!

Wait, what happens if vector length is already usize::MAX, and then we push again? I don't see how the code presented deals with this potential problem.

Dangers of C++ starts at 5:10; Unsafe Rust intro starts at 14:47; Title slide at 19:50

I love this video makes it so clear

I also like rust, especially the rust compiler. I want to contribute. I don’t know where to start?

That was interesting. Thanks.

I think I'm missing the point here. What I took away from this talk is that I can replace a primitive or a Vec with a Trait for no reason. I feel like I understood traits better before I watched this, but everyone else is saying this talk was great. I realize she chose simple examples on purpose, but these are cases where traits shouldn't be used.

good job on not laughing each time she said "castrate"

"You forgot to initialize the variable". Lol. Close. Noob.

I also found rust when i ways thinking about learning C++

Great presentation.

As a Rust learner, I think it is being sold wrongly. The word "undefined behaviour" is thrown around too casually. The CPP conference people tend to abstract away hardware and concrete implementations, hence they just label anything not specified by the C++ specs as "undefined behaviour" because they cannot be sure how the implementations will handle such situations. But, almost all popular compilers do the most reasonable thing when it comes to these situations. Printing uninitialised memory will print whatever bits were stored in its place, overflowing an integer will result in it wrapping down to the smallest storable number, etc. This is not something CPP programmers would worry about while coding. This is fear-mongering. I fear I'm getting myself into a community full of these people, but damn the promise is too great not to give it a shot, and so far, I like it.

I wish more Rust talks were like this! The visuals really sold it for me.

Very informative and inspirational

So basically, don't use C/C++ lol

Next: how to fight and vanquish the borrow checker with half orc barbarian and elf wizard

I've had the same error with copy_from_slice, and it's bad, because it's basically memory corruption, something Rust is supposed to guarantee against.

im lookin for the same energy as the guy who shouted ‘woo!’

AHHHH that's why a Rust enum is a SUM-type; A FruitSnack so to speak; A variable can have enum-value 1 OR enum-value 2 OR ...; e.g. The Option enum can be either Some(x) or None.