Rust Nation UK is the first conference dedicated to the Rust programming language. It will be held at The Brewery in the heart of London on the 16th & 17th of February 2023.
We'll be sharing video of all of our talks as well as live streaming them on the day.
Пікірлер
Great talk! I don't agree though that platforms are best at UI - technically this may be true but it just doesn't scale. Needing two separate teams for basically the same application is just not a good enough solution in my opinion. Being idiomatic on a platform is hugely overrated - none of the "big" apps really are, they just follow their own UI/UX guidelines. It's only important to be consistent and provide a good user experience without conflicting with the underlying OS. Also the web is a mess anyway and people use it everyday. I worked previously on a pretty big cross-platform project and we resorted to Qt/Qml, which I really don't like, but it was okayish at least. UI/UX for sure wasn't the problem - no one ever complained, not a single user! The main issues were related to C++ and Qt bugs. We really need a solid platform-independent UI framework. Flutter could have become it if Google didn't make the really stupid decision to base it on Dart. Maybe Slint will fill this role in future? I don't know. Unfortunately they don't really support mobile very well as of today.
Great talk! Leptos is amazing, I hope it get's the attention it deserves. Together with Tauri it's the best thing since sliced bread for writing cross-platform apps.
i was excited to use it but after a speed comparison with postgres, postgres smoked surreal
Thanks! It was great to see these real-world examples.
Leptos helped me build a website and API for an event last year and it was delightfully easy and fast (after a little help from Greg). I updated that site and API a month ago with the latest Leptos version and was again delighted with how all the changes made things easier with less boilerplate. Leptos's rate of development is amazing 🚀
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.
What are the use-cases for React?
i hate that amazon has infiltrated rust
Why? No different than RHEL paying Kernel devs to do stuff.
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
You don't need a new ABI or layout for anything if you are just adding metadata. You can add that in the executable files resource section. You don't need to describe these things at the binary level. The C ABI should work fine. Unless there's something incredibly new that needs to be built from the ground up, there's no reason not to go with the C ABI with a few minor tweaks, and only IF we NEED those tweaks.
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