BEGIN:VCALENDAR VERSION:2.0 PRODID:-//Pentabarf//Schedule 0.3//EN CALSCALE:GREGORIAN METHOD:PUBLISH X-WR-CALDESC;VALUE=TEXT:Rust devroom X-WR-CALNAME;VALUE=TEXT:Rust devroom X-WR-TIMEZONE;VALUE=TEXT:Europe/Brussels BEGIN:VEVENT METHOD:PUBLISH UID:14539@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T103000 DTEND:20230204T111000 SUMMARY:Building an actor library for Quickwit's indexing pipeline. DESCRIPTION:
Quickwit is an opensource distributed search engine.The most challenging component of a search engine is its indexing pipeline.
It takes a stream of JSON documents, processes them in batches, and emits index artefacts we call splits.
We needed our implementation to be robust, testable, observable, and efficient...But even more importantly, our code had to be easy to work with.
I will explain why we chose to develop our own actor framework and discuss the uniquefeatures of our implementation.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/building_an_actor_library_for_quickwits_indexing_pipeline/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Paul Masurel":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14455@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T111500 DTEND:20230204T115500 SUMMARY:Building a distributed search engine with tantivy DESCRIPTION:Follow me as I walk through my journey of building lnx, a distributed search engine written in Rust akin to Elasticsearch or Algolia that aims to be faster and more efficient using tantivy.I cover the challenges and solutions I encountered while developing lnx over the last year, the tradeoffs made and how you can build your own search engine using the tools the Rust ecosystem provides.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_building_a_distributed_search_engine_with_tantivy/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Harrison Burt":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:13671@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T120000 DTEND:20230204T124000 SUMMARY:Aurae: Distributed Runtime DESCRIPTION:In this talk I share the motivation, goals, and architecture of my new project Aurae. Informed by my experience of operating large production platforms I discuss my thesis of how bringing deliberate runtime controls to a node will unlock a new generation of higher order distributed systems.
The audience walks away with an in-depth understanding of the current state of affairs Rust and the Aurae runtime project. We learn about my journey to Rust from working with Go in Kubernetes.
I am an accomplished Go engineer who has made the jump into Rust and I believe my story is worth compiling and sharing with FOSDEM. I believe there will be many like me in the future.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_aurae_a_new_pid_1_for_distributed_systems/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Kris Nóva":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14613@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T124500 DTEND:20230204T125500 SUMMARY:Presentation of BastionLab, a Rust open-source privacy framework for confidential data science collaboration DESCRIPTION:We present BastionLab, a Rust open-source privacy framework for confidential data science collaboration.We aim to help data owners open access to their datasets to outside data scientists. The current approaches, such as opening Jupyter notebooks, provide no elaborate control over what is shared. Datasets can easily be extracted from them, which means they offer little privacy guarantees and make data collaboration difficult.
BastionLab provides an interactive interface for data scientists to explore remote datasets, yet answers the privacy concerns of data owners, as only results compliant with the privacy policy defined by the data owners can be communicated.
Data exposure is limited as data scientists never have direct access to the data, they can only use a limited set of operators which preclude arbitrary code execution to exfiltrate data, and a strict access control policy is put in place. Differential Privacy and Trusted Execution Environments are supported as well to ensure maximum privacy.We will provide an example to show how a COVID dataset could be shared to a remote data scientist to perform data exploration, cleaning and visualization, while making sure only anonymized results are communicated.The server side of BastionLab is developed in Rust for its memory safety, performance and community. It allows the use of cutting-edge libraries like polars, an open source DataFrame library in Rust several times faster than pandas, the go-to solution in Python.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_bastionlab/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Mehdi Bessaa":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:13645@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T125500 DTEND:20230204T130500 SUMMARY:Neovim and rust-analyzer are best friends DESCRIPTION:In programming we use editors and IDEs all the time. Previously if one use Vi/Vim like text editor it typically means you just edit soruce code as simple text, but nowadays things have been changed.Especially after releasing support of the Language Server Protocol(LSP), which works as a client to LSP servers for example rust-analyzer.This talk gives deep dive of Language server Protocol implementation for Rustand how to build friendly relationships between rust-analyzer and Neovim.
In this talk i’ll start from brief of what’s LSP and rust-analayzer, some missing features you probably didn’t know about? E.g. go-to-definition, find-references, hover,completion, rename, format, refactor, etc., using semantic whole-project analysis.Also i’ll show you how to write you first plugin using Rust and interact with some LSP primitives. to turn you editor in God mode surf trough it like a pro.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_neovim_and_rust_analyzer_are_best_friends/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Andrii Soldatenko":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14298@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T130500 DTEND:20230204T131500 SUMMARY:A Rusty CHERI - The path to hardware capabilities in Rust DESCRIPTION:CHERI defines hardware extensions to encode access constraints on pointers, enabling hardware enforcement of such restructions based on metadata stored alongside pointers. There is an ongoing drive to support compiling Rust code in a way that can make use of these extensions.
Doing this provides another layer of protection. We can encode knowledge about provenance validity, bounds and other access restrictions that the compiler (and OS/etc.) knows about in a way the hardware can enforce at runtime. The Rust memory model is famous for being able to enforce these types of restrictions at compile time, but not for unsafe Rust code. Unsafe Rust code needs to be written sometimes, which presents situations which can only be verified at run time. Some other nice benefits could come from this work. For example, runtime bounds checking can now be done by hardware rather than software, and since provenance information is necessary for operations on capabilities, closing gaps where it is not currently preserved forms a part of this work.
This talk is a discussion on what is required for this support, and gives an overview of the state of the various attempts to implement this support.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_a_rusty_cheri_the_path_to_hardware_capabilities_in_rust/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Lewis Revill":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14528@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T131500 DTEND:20230204T132500 SUMMARY:Slint: Are we GUI yet? DESCRIPTION:Slint is an Open Source GUI toolkit for Desktop and Embedded. It is written in Rust, and comes with a declarative UI description language that compiles into native Rust code.We will present Slint and show how you can build an reactive GUI in Rust
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_slint_are_we_gui_yet/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Olivier Goffart":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14636@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T133000 DTEND:20230204T141000 SUMMARY:Rust API Design Learnings DESCRIPTION:In this talk I'm going over some lessons learned from building internal APIs in Rust as well as some public APIs such as the Redis rust crate, the insta snapshot testing library, the MiniJinja template engine and more.
It covers lessons learned from making mistakes, more crafty abstractions with generics and more of building libraries in Rust for 10 years.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_rust_api_design_learnings/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Armin Ronacher":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14415@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T141500 DTEND:20230204T145500 SUMMARY:A deep dive inside the Rust frontend for GCC DESCRIPTION:Started in 2014, the gccrs project is working toward creating an alternativecompiler implementation for the Rust programming language. At the moment, theproject targets the 1.49 version of the language and hopes to catch up oncethat milestone is reached.
In that talk, we will explore some of the components inside gccrs, as well asdive into some of the hurdles encountered during the project's lifetime.
Finally, we will explore ways to cross-pollinate with the Rust community, inorder to help and benefit both projects. Specifically, we will dive into someways we plan to share components with rustc, and how to achieve that: namely,we will look at how we plan on integrating the Polonius project to performborrow-checking inside gccrs, what our efforts with running the rustc
1.49testsuite are, and what we need to achieve to start being useful to the Rust-for-Linux project.
This talk will shortly present how a patch gets merged for the rust compiler and how the whole process happens and what happens after it was merged.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_merging_process_of_the_rust_compiler/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Guillaume Gomez":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:13730@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T152500 DTEND:20230204T160500 SUMMARY:Let's write Snake game! DESCRIPTION:Game developing is hard: models, concurrency, physics and so on are difficult without any helps from the framework. In this talk we introduce Bevy Engine library that allows us to create simple games in a smart way.With the merely excuse to build a Snake Game, in this talk we create Snake Game compiling it as native application and webapp (wasm) application.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_lets_write_snake_game/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Tommaso Allevi":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14242@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T161000 DTEND:20230204T164000 SUMMARY:Glidesort DESCRIPTION:Sorting is one of the most common algorithms used in programming, and virtually every standard library contains a routine for it. Despite also being one of the oldest problems out there, surprisingly large improvements are still being found. Some of these are fundamental novelties, and others are optimizations matching the changing performance landscape in modern hardware.
In this talk we present Glidesort, a general purpose in-memory stable comparison sort. It is fully adaptive to both pre-sorted runs in the data similar to Timsort, and low-cardinality inputs similar to Pattern-defeating Quicksort, making it to our knowledge the first practical stable sorting algorithm fully adaptive in both measures. Glidesort achieves a 3x speedup over a Rust’s standard library Timsort routine on sorting random 32-bit integers, with the speedup breaking the order of magnitude barrier for realistic low-cardinality distributions. It achieves this without the use of SIMD, processor-specific intrinsics or assumptions about the type being sorted: it is a fully generic sort taking an arbitrary comparison operator.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_glidesort/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Orson Peters":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14304@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T164500 DTEND:20230204T172000 SUMMARY:How Pydantic V2 leverages Rust's Superpowers DESCRIPTION:Pydantic is a data validation library for Python that has seen massive adoption over the last few years - it is estimated that Pydantic is now used by about 10% of professional web developers!
Over the last year I've been working full time to rebuild Pydantic from the ground up, using Rust for virtually all the validation and serialization logic. Pydantic V2, with these changes included, will be released early in 2023.
In this talk I will give a brief introduction to Pydantic V2 before diving into how the use of Rust has allowed us to completely change the architecture of Pydantic to make it easier to extend and maintain while also improving performance significantly.
The majority of the talk will be devoted to using examples from the pydantic V2 code base (rust and python) to demonstrate the advantages (and disadvantages) of writing libraries like Pydantic in Rust.
This talk should be interesting to any Rust or Python developer who's interested in combining the two languages - no knowledge of Python or Pydantic is required. However if you'd like to get some context or learn more about the topics discussed, here are some useful resources:
Graphs are used in many different applications as they are an intuitive way for representing complex relationships between entities, as for example in social, communication, financial or geographical networks. Graphs in these domains can be very large, potentially spanning multiple millions and even billions of nodes and edges. In order to get analytical insights out of these structures, scalable implementations of graph algorithms are necessary. Rust is the ideal language for implementing such algorithms, due to its well-known aspects, such as "fearless concurrency" and memory safety as well as its great out-of-the-box performance and its expressive type system.
In our presentation, we will talk about the "graph" project, a collection of open source crates that we are working on. The project includes an in-memory graph representation, APIs for building in-memory graphs from various data sources, and a small collection of high-performance graph algorithms. In addition to these building blocks, we started developing a Python wrapper called graph-mate for a NetworkX-like experience and an Apache Arrow endpoint for integrating the project in distributed applications. The presentation will include a project overview, a walk through the Rust API, and a demo for using the project via Python.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_scalable_graph_algorithms_in_rust_and_python/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Martin Junghanns":invalid:nomail ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Paul Horn":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14790@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T175000 DTEND:20230204T181000 SUMMARY:Using Rust for your network management tools! DESCRIPTION:When creating a script or a tool to manage your network configuration it is hard to decide which language should you use. In Nmstate we noticed we could get plenty of benefits from Rust. Nmstate is a library with an accompanying command line tool that manages host networking settings in a declarative manner written in Rust. In this talk, we are going to see how we combined several existing libraries and also created our own ones to create a powerful networking tool.
In addition, we will share our lessons learned from rewriting a project from Python to Rust. Of course, the talk will be full of crabs, so don't miss it!
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_using_rust_for_your_network_management_tools/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Fernando Fernandez Mancera":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:14801@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T181500 DTEND:20230204T183500 SUMMARY:Backward and forward compatibility for security features DESCRIPTION:Application developers working and testing with a specific kernel version should be able to easily control their application compatibility behavior with previous (and future) kernel versions as well. We developed a Landlock library (for security sandboxing purpose) that protects users as much as possible while making the work of application developers easier and safer.
This talk gives feedback about the development of a security library that needs to deal with backward and forward compatibility, because of security features tied to specific kernel versions, handling different use cases in a safe and secure way. We explain patterns that we used to make it possible to fine tune the requested (optional) features while providing a safe default behavior. For simple use cases, the idea is to provide a best-effort security approach for potentially unsupported kernel features: use available features and ignore others. However, in more complex use cases, we may want to make some features depend on others. We may also want to handle errors differently based on unsupported features.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_backward_and_forward_compatibility_for_security_features/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Mickaël Salaün":invalid:nomail END:VEVENT BEGIN:VEVENT METHOD:PUBLISH UID:13797@FOSDEM23@fosdem.org TZID:Europe-Brussels DTSTART:20230204T184000 DTEND:20230204T190000 SUMMARY:atuin: magical shell history with Rust DESCRIPTION:Atuin aims to make your experience with your shell history delightful. It stores every command and the context around it (eg, directory it ran in, duration, etc) in a SQLite database, and then provides fuzzy search on top of that. Along with the Atuin sync server, this history can be made available on every machine the user has.
I'll be walking the audience through how the project works, what problems it solves, as well as how it was implemented. I will assume the audience has some working familiarity with the shell, but the talk will be friendly for Rust beginners or anyone curious about the language.
CLASS:PUBLIC STATUS:CONFIRMED CATEGORIES:Rust URL:https:/fosdem.org/2023/schedule/2023/schedule/event/rust_atuin_magical_shell_history_with_rust/ LOCATION:H.1302 (Depage) ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;CN="Ellie Huxtable":invalid:nomail END:VEVENT END:VCALENDAR