Video

Frédéric could easily be the first ever person that doesn't grind my gears as a Frenchman, and yet he is. Great talk 👏🏻👏🏻👏🏻

Giving a talk is not easy, and the best delivery comes when you plan ahead and know exactly what you’re going to say and demonstrate. I think this one would have benefited from more prep, and less wandering around in the editor dealing with irrelevant compiler errors.

Is it Zellij running in Alacrity?

I am not sure about use case for Leptos. It looks like React in Rust.

i hate that amazon has infiltrated rust

Exactly what I was looking for. Thank you!

Yet another Jon awesome presentation 👏👏

The whole thing doesn't feel like an "easy" Rust. It feels more like a collection of weird, contrived dance moves that beginners need to learn in order to avoid those invisible, contrived barriers that the language put up for the name of safety. "If you wanna avoid using lifetimes, use Arc. What is Arc you might ask? Well, let me explain about Rc first before we go into Arc, so that you can "easily" avoid lifetime annotations." Only Rust people think this is ok. Don't get me wrong. I'm totally onboard with the capabilities the language brings. But if those capabilities come with a learning curve, then just let people climb that curve, properly, and maybe even painfully to an extend, in order to bring them the full benefits.

I do wonder... What is the most used package that includes an unsafe block? I mean, including transient uses. If one knows what that is, and re-implement the unsafe blocks in a safe way (or provide extra features in core to do it), the number of projects with unsafe would go way down.

greaaaaat talk! thx

wow, this was pretty cool talk. thank you.

Very hard to listen to due to his pronounciation.

I learned a lot, thanks Chris!

At 34:08 it should be // unlock the mutex

Title is inadvertently hilarious

i thought this was easy mode.

Wait, who's on first? Not a hit on the speaker, oc. It's just another part of rust that's a bit wonky atm.

YOU MADE MY DAY, I WAS STUCK WITH LEPTOS AND YOU HELPED ME GET IT WORKING,... thanks for the sharing of your knowledge ☕

If you are looking for how bevy’s Query system implemented, this may be a wrong place😂 to start

This talk made me more invested in rust after 3 years of partial use. Would love to use it full time.

Very cool video! The performance problem with wasm-bridge got fixed in version 0.3 (objects are no longer passed through JS and are directly sent as bytes instead). It is sad that the project got cancelled, using WASM for plugins is a very cool idea, but I think you need a good game (or a good product in general) first to get people interested.

I watch a lot of videos at 2x speed so I can get through enough of them (so much stuff being throw at us). The banjo at 2x was pretty cool. This was a great talk. Also, use easy frameworks - some are more involved than others. Bevy actually is easy Rust imo because of the framework.

Nice talk, but sponsored by Huawei is horrible considering their involvement in genocide and ethnic cleansing. Weird seeing such good people with a pseudo hate symbol on stage with them.

Some excellent points and whilst i try and advocate for Rust for (safety) critical software I always seem to come up against arguments that the Rust ecosystem/style is not compatible with formal safety requirements & standards?

Where can I find this project? Do you have an address for the project?I want to do this.

Where can I find this project? Do you have an address for the project?

Chris, we need a fine-tuned LLM for Bevy development. And after fine tuning, further refining using constitutional AI / RLHF. Then a voice integration - so we can just talk our systems. Curious about when to implement a Command versus just another function for the reusable aspects?

Now i wish there'd be a company in switzerland i could work for with rust ngl

Regarding code doc and comments, I'd add one thing: *don't use confusing foo/bar identifiers* . Don't be that lazy guy and take the time to find something *meaningful* the reader can relate to and remember. That's how our brain works, so use it. For the tests, code coverage is also very helpful, unless you have some ATPG tool available.

Oh look, it’s the BEAM! (not being mean, I love to see a marriage between my two favorite languages!)

It seems like you are not using OpenTelemetry trace ids? Is there a particular reason for that? It could be useful if this is only used as part of a larger system.

Amazing list of things that are important to reliable software. About the only thing I can think of that hasn't been mentioned that would fit in with the rest of the topics is observability in your production environments, make sure you track everything there that is important to later figure out what did go wrong since you can't really rely on the ability to wait for several occurrences of an issue for a pattern to form or to reproduce it if you didn't track everything important the first time around. Basically ask yourself at every error path in your code "what is the information I wish I had if I had to figure out that this error occurred and why?" and often you will realize that there are values that are available in local variables or similar easy to reach locations for your code that you did not log or otherwise preserve or that there are connections between components that call each other that could be more easily correlated in your logs or traces if they shared some trace or request id or similar identifier you can pass on trivially if you think about it up front.

Impeccable Rust, Impeccable Speech!

This is so great ❤

Great retrospective, thanks! Also, good luck with your future projects! :)

I didn't click on this video to listen to shitty guitar and singing

Why doesn't he use the add method on the pointer, which will add the size of the type to the address for him?

Great as always!

Great talk! It brought me back to my Scala/Akka days! Developing non-trivial applications (and I have done a few) in Akka was not easy, but the end-result was always predictable. Modeling the behaviour was relatively easy. The 'message window' feature seems to be equivalent to the way *back-pressure* is implemented in Akka! Will take a look at the docs of _elfo_ !

Why not just use the layout from the C shared library ABI? As it is right now, you can export your code to the C ABI like a C shared library, and make a bindings crate to add in metadata like lifetimes, type definitions, even member functions if your member function is just defined as a C function in your crate that will be compiled down to a dll has inside of it. Like: ```rust // This should go in a "common" crate that both the shared library crate can access the type and the bindings crate can re-export it without creating circular dipendenciy. // This will import from the dll "my_shared_library.dll", and only with the "imports" feature. We only want to import this function in the bindings crate, to avoid double definition. // Importing is a tad bit different on Linux, but shouldn't be too hard to look up. Sorry! #[link(name = "my_shared_library", kind="rawdylib")] #[cfg(feature = "imports"] extern "C" { pub fn MyTrait_some_function(this: *const MyTrait) -> bool; } #[repr(C)] pub struct MyType { some_size: usize, some_bool: bool, } impl MyTrait { #[cfg(feature = "imports"] pub fn some_function(&self) -> bool { unsafe { MyTrait_some_function(addr_of!(*self)) } } } // this in your shared library crate that compiles to dll pub extern "C" fn MyType_some_function(this: *const MyType, value: usize) -> bool { // do some work } ``` and then in your bindings crate, you make a safe wrapper around that function, as I loosely demonstrate here. You just have to make sure MyType is #[repr(C)] as well as you use the right calling convention

Jon… I love your talks and streams but you gotta consider your employers better…

Today, I found out she's the lady behind the answers of the problems I searched on the forum. Thank you for your service

Loved this talk - exactly the kind of balanced discussion we need to have for all long term non-trivial software projects with external dependencies regardless of language, to be able to move forward responsibly and not getting stuck in old versions or upgrade recklessly.

7:45 It seems like `items.clone().iter()` will still have an issue with `modify(item)` being able to return an owned `T`. Perhaps `for item in items.clone()` to use IntoIterator directly? Aah, I'm thinking too complicated... I suppose `modify` can clone the input

a parenthasee a parenthado

I think there's a typo in the speaker's name. It should be Heiko Seeberger, and not Seeburger.

The lack of exceptions is a sign of quality. Exceptions should've never been a thing.

Watching this I came to conclusion that I prefer "non live coding" style of presentations. I find it much easier to follow when you show the code on the slide and invest more time into describing what it is and what it does, then watching all this typing and all possible errors one can stumble upon when writing code. As far for the Leptos project itself, fantastic work from everyone involved. 🙂

Weren't they already using Ada/Spark to prevent such problems?

The Scammer. 😂😂😂