List of videos

Rust enforces unique lifetime and access bounds to data inside a program and thus impacts how memory must be managed. This is especially relevant for multi-threaded systems or applications where multiple parts may want to access some congested data. In this talk, I will cover some data synchronisation theory in Rust, starting at the common Arc˂Mutex˂T˃˃ pattern, and ending in an exploration of smart pointers and lock-free data structure design.

What does the Rust Foundation do? Why all the focus on security? How does the Foundation work with the Rust Project? The Rust Foundation team are here to answer your questions. Ask us anything!

What makes Rust on embedded hardware exciting and challenging is that we want to realize two conflicting objectives. On the one hand, we want to use safe and convenient high-level abstractions. This is particularly true for Tock OS, an embedded OS whose security model is built around Rust’s type safety guarantees. On the other hand, we want to efficiently use the platform’s resources, particularly regarding code size and memory usage. This becomes especially challenging when we account for all of the requirements that Tock OS imposes, including supporting dynamically-loaded applications and running the OS and the applications from arbitrary positions in ROM and RAM in devices without support for virtual memory. In this case study, we discuss how lowRISC is improving Rust support for RISC-V embedded platforms, driven by Tock OS. We describe our efforts for adding support for RISC-V position-independent code optimized for embedded applications, including the changes needed in the toolchain, rustc, the ABI, Tock OS and its libraries. We also detail how we are trying to optimize the Rust abstractions used in Tock OS, including the compiler transformations involved, metrics for the binary size improvements, and the current status of those optimizations.

More than 100 all new limericks about Rust. Delivered by the Rust bard himself. Ukulele included.

Rust and its ecosystem are in constant flux, and this can be scary, especially when you're building an application with stability and long-term project sustainability in mind. New Rust versions bring ever-higher editions, must-have new features, and lint and tool changes to keep on top. And as new features emerge, they'll fade into oblivion. In this talk, we'll look at the changes that may happen to you when working with Rust and how to live with them. We'll talk about Rust and crate versioning, backwards compatibility, unstable features, minimum supported Rust versions, and 1.0 releases. This talk is geared towards those using Rust to build applications and services, not those building Rust libraries. It won't tell you the right way to set up CI for your library crate or decide whether a change is backwards compatible. Instead, we'll dig into the kinds of stability challenges that can arise in Rust, what to do when they crop up, and some promising avenues for making the stable life easier.

Live stream from Track 1 of Rust Nation UK.

Many of us use debuggers, from the basic standard library pdb to many other fancier alternatives, but what makes it possible to debug Python code? Have you ever wondered why the entry function of pdb is named pdb.set_trace()? To make a basic debugger, you need to be able to: * Stop the program at a certain position * View as much information as possible in a convenient way * Evaluate expressions and even run arbitrary code * Control the program execution How does Python debugger like pdb achieve this? We will discuss the magic of sys.settrace, and the rich runtime information Python provides. However, there's still a pitfall. The mechanism introduces a huge overhead in order to achieve features like breakpoints. Can we do something about it? Can we have a overhead-free debugger that can do exactly what pdb can do now? It becomes possible with PEP 669, the low-cost monitoring system introduced in Python 3.12. We will talk about the difference between the current mechanism based on sys.settrace and PEP 669, or sys.monitoring. With proper implementation, we can achieve 100x speed up for breakpoints. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/6/2024-05-17T02%3A51%3A17.540542/PyCon2024-TianGao.pptx

Hello 👋! I'll review few great ways to test data pipelines in this talk. This approach's primary goal is to ensure data flows smoothly through the pipelines by quickly identifying and fixing any problems. While the talk uses Airflow as the base, the techniques presented are toolkit-agnostic. When it comes to testing pipelines, the process is similar to testing software applications. It includes running unit tests for each pipeline component, integration tests for the entire pipeline, and end-to-end tests to ensure accurate data output. However, I'll also discuss unique methods like data snapshot testing and online and offline data quality checks. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/46/2024-05-17T03%3A49%3A26.293574/_Testing_Data_Pipelines1.pdf

Full title: Open Source Industrial Control: Turning 2,800 Tons of Metal with Python and Flask This is a story of how Python can fit into the physical world around us. It is a story of system design and product development. It is a tale of great breadth, covering distributed computing, custom printed circuits, electromagnetism, some of the largest hydropower generators in the world, and the software and hardware that brings this all together. This tale covers several years of research and development, culminating in a cyber physical system built on open-source software and easily attainable off-the-shelf products and components. The Bureau of Reclamation is the 2nd largest hydropower generator in the United States and operates 53 hydroelectric plants with 14.7 gigawatts of installed capacity. On average, Reclamation plants generate 40 billion kilowatt hours of electricity annually. It takes a large fleet of rotating machines (generators and pumps) across the western United States to produce this much electricity, and operations and maintenance of this fleet is a significant part of Reclamation’s annual budget. During routine diagnostic and maintenance tasks, it is often necessary to slowly and precisely turn a machine’s rotor to make measurements at various rotational positions. This was previously done with many personnel climbing into the machine and pushing (or, for very large machines, complicated crane maneuvers). This is dangerous, inefficient, and lacks precision. With custom software and intelligent system design, we have developed a modular system that can easily scale to turn even our largest machines with the click of a button. The software can track the machine’s rotational position in real time to one thousandth of a degree and can easily expand to accommodate future diagnostic test methods. What once put personnel at risk and potentially took days to carry out can now be done in hours with little to no risk to personnel. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/59/2024-05-15T19%3A12%3A48.417762/pycon_2024-open_source_industrial_control.pptx