Deno - Next Generation JavaScript Runtime
Explore Deno's advantages over Node.js, its production readiness, and how it solves TypeScript project inconveniences. Learn about ecosystem compatibility and deploying to NPM.
Antimony - A Real Time Distributed Stream Processing System
Explore real-time distributed stream processing with Antimony, a Rust-based system designed to outperform Apache Storm, addressing architectural and efficiency issues.
A Rust-based Runtime for the Internet of Things
Evaluating Rust for IoT: Experience porting Tock OS to Bluetooth Low Energy SoC, exploring memory safety, low runtime overhead, and power consumption compared to C implementations.
A RustFest Carol
Explore Rust's evolution through a modern fable. Felix Klock examines past, present, and future Rust epochs, addressing concerns about language stability and change while highlighting Rust's adaptability.
Testing Strategies and Pattern for Efficient TDD in Rust
Strategies for effective Test-Driven Development in Rust, overcoming obstacles like lack of reflection and strict compiler. Learn patterns to ship confidently using TDD methodology.
Type-Safe & High-Perf Distributed Actor Systems with Rust
Explore a prototype for a high-performance, type-safe distributed actor system in Rust, enabling complex and extensible distributed systems development with idiomatic code and efficient message handling.
Fearless Concurrency in Your Microcontroller
Explore efficient multitasking on microcontrollers using Rust's zero-cost, memory-safe abstractions for embedded systems. Learn about concurrent programming techniques for resource-constrained environments.
Tokio - How We Hit 88mph
Explore async I/O in Rust with Tokio, diving into futures, concurrency, and efficient server design. Learn how Rust's strengths are leveraged for high-performance asynchronous programming.
Macromancy - An Introduction to Rust Macros
Explore Rust macros: from basics to advanced techniques. Learn to write efficient, reusable code and unlock the power of metaprogramming in this comprehensive introduction.
Create Rust Games Easily
Learn to create Rust games using ggez framework. This talk guides you through the process of building a game from scratch to publishing, covering key concepts and practical implementation.
A Hammer You Can Only Hold by the Handle
Exploring Rust's type system to enforce API constraints and create self-documenting code. Learn how to leverage affine types for compile-time safety in complex operations.
Rust - An Alternative to High-Level Programming Languages
Exploring Rust's potential as a high-level language alternative, focusing on type safety, performance, and complexity for application development beyond systems programming.
Teaching an IDE to Understand Rust
Explore the development of IDE support for Rust, including Cargo workspace integration, RLS functionality, and the current state of Rust programming with IDEs. Learn how IDE tools can enhance your Rust projects.
SHAR - Rust's Gamedev Experience
Explore the development of SHAR, a 3D multiplayer action game, focusing on implementation details, challenges, and components like GUI, animations, networking, and modding in Rust.
Rust in Rhymes
Explore Rust programming concepts through witty limericks and rhymes. This unique presentation covers diverse topics with code examples, documentation, and memes for an engaging learning experience.
Mistakes to Avoid When Writing a Wrapper Around a C Library
Practical advice on creating safe and efficient Rust wrappers for C libraries, covering common pitfalls, API design considerations, and best practices for robust integration.
Impractical Macros
Explore Rust macros through an unconventional Brainfuck interpreter implementation, showcasing advanced techniques and creative solutions for compile-time programming.
Qt GUIs with Rust
Learn to build graphical applications combining Qt's mature GUI library with Rust's strict programming language, using Rust Qt Binding Generator to create powerful and efficient user interfaces.
Yew - A Rust+WebAssembly Framework for Client-Side Web Apps
Explore Yew, a Rust framework for building client-side web apps using WebAssembly. Learn its architecture, features, and advantages over JavaScript frameworks.
Monotron - Making a 80s Style Computer with a $20 Dev Kit
Recreating 80s-style computing with embedded Rust on a Cortex M4 devboard: VGA generation, text rendering, PS/2 keyboard input, and testing on modern PCs.
Rustls - Modern, Faster, Safer TLS
Explore rustls, a modern TLS stack in Rust, offering enhanced security, performance, and design. Learn about its features, deployment, and advantages over traditional implementations.