Rust Programming Language / Rust Linz

This talk is aimed at experienced C++ devs looking to try Rust, not serving as an introduction or tutorial but simply an orientation quickly going over language features that may be alien to a C++ developers.

Material: https://github.com/unknowntrojan/talks

For the last two years, I worked on lychee, a new link checker which supports Markdown, HTML, and more. It heavily uses async Rust and has a focus on performance. During the session, I will talk about the challenges of writing a link checker and how Rust was the ideal language for this project. The key takeaway is that simple things can get complex very quickly and that the Rust ecosystem allows building high-performance CLI tools with relative ease.

---

Matthias Endler is a Rust developer and Open Source maintainer. He built popular Rust crates like tinysearch, hyperjson, and lychee. He spoke at conferences such as FOSDEM in Brussels, Cod{e}motion in Amsterdam, and BrisTech in Bristol. He gave workshops at emBO++ in Bochum, RustBeltRust in Columbus, OH, and RustFest Barcelona. He is passionate about Idiomatic Rust and an avid blogger.

How can we keep critical code private but still use modern cloud technologies? This is a experience report including self-hosting and the development of medium to large size projects.

--

Stefan Schindler started over 15 years ago on the hardware deployment side of IT and has ever since become an OSS maintainer and Lead Software Engineer for tipi.build working on the next generation of compiler toolchains for reliable software.

Vector search engines have recently been gaining popularity. In this session, we will be explaining what they can achieve, peek under the hood to check what is inside, and see why Rust is a good fit for the job.

---

Arnaud Gourlay is a software engineer at Qdrant where he contributes to the Qdrant vector search engine. Long time OSS user and maintainer, he enjoys programming in Rust and sharing his knowledge.

Discover the unbeatable synergy of Rust with serverless components such as AWS Lambda or GCP Cloud Run. Why Rust is the perfect match for serverless architecture? Uncover the unique features of Rust that make it the top choice for building ultra-efficient and robust serverless apps. Don't miss this chance to revolutionize your cloud development game and enjoy a 100% serverless pizza tracker demo! 🍕

--

Maxime David is a life-long open source aficionado and Senior Software Engineer advancing serverless topics at Datadog. He’s keen on code profiling, and believes that performance in software matters. When he’s not optimizing software, he likes to try every banana bread he can find.

At Aleph Alpha we strive to create a sovereign, European AI tech stack. We use Rust to build our API. In doing so we also stumble upon Problems outside of the Domain of AI and Large Language Models. One of these sparked the Open Source `async-events` crate, which might also be helpful in your Distributed System.

--

Markus Klein is the Engineering Lead at Aleph Alpha. He spend most of his career as a C++ Developer, working in the Domains of Distributed Systems and Data Engineering. He is using Rust as his go-to Language for private Projects for eight years and is the core maintainer of several crates, with his most meaningful contribution to the Rust ecosystem probably being `odbc-api` crate. He also finds it strange to write about himself in third person.

Rust is a very powerful and full-featured systems language. However, its native idioms (at least in their default implementations) can be quite verbose. Even when you just want to GET a JSON document and do something with it. Explicitly matching every Result case is required to avoid panic. Or is it? Let's learn together to use turbofish syntax and the anyhow crate to produce more elegant but still idiomatic Rust code that allows us to explicitly handle Result(s) as necessary. We'll demonstrate making Rest API calls using Rust reqwest and we'll show how to incrementally minimize the amount of boilerplate it takes.

--

Elliott Frisch is a Senior Developer at JFrog with over 20 years of software design and development experience in a variety of languages. He has been working in Rust for the past year at JFrog on Pyrsia, an open source decentralized package network. His personal mantra for contributions to software is: producing exceptional products that delight users and stakeholders alike. He enjoys helping other developers with tough challenges and he is currently ranked in the top 500 users of all time on Stackoverflow. His other hobbies include a lifetime of reading and watching science fiction.

Almost 30 years ago, the Gang of Four wrote about software design patterns. They were highly influential, and over the course of decades, the proposed patterns have been cited, reused, misused, thrown away, and found again, over and over. One of those patterns -- the builder pattern -- gained some popularity in Rust's libraries. Let's take a look at what does, why the builder pattern is such a great fit for Rust, and how we can use some of the unique features of Rust's type system to make them even better.

--

Stefan Baumgartner works at Dynatrace. He writes for Manning, Smashing Magazine and A List Apart and made the Kessel run in less than 12 parsecs.

In his spare time, he organizes ScriptConf and DevOne in Linz, and co-hosts the German language Working Draft podcast. Stefan enjoys Italian food, Belgian beer and British vinyl records.

Practical lessons from anyinput, a new macro for easily accepting string/path/iterator/array-Like inputs (Based on my recently published free article in Towards Data Science)

Article: https://medium.com/towards-data-science/nine-rules-for-creating-procedural-macros-in-rust-595aa476a7ff
Slides: https://1drv.ms/p/s!AkoPP4cC5J641sMUBT9olBqrd-JoZw?e=kJ38eo

Rust Linz:
https://sessionize.com/rust-linz
https://rust-linz.at
https://fosstodon.org/@rustlinz
https://twitter.com/rustlinz

Profiling is a way to understand program behavior in terms of time and memory usage at runtime. Profiling is generally considered an advanced topic, but it doesn't have to be hard at all!

In this talk, I want to present and discuss various approaches, tools, and crates that help us to explore time and memory usage of our programs. We’ll explore a simple project, discover its characteristics and see what can be done to optimize them. We’ll see how to measure the timings of code fragments and functions reliably. We'll look at flame graphs and learn how to understand them. We’ll talk about such techniques as reserving memory in advance, avoiding creating auxiliary data structures, and removing unnecessary memory operations. We’ll also see that extensive correctness testing is a must-do when optimizing code because making programs faster and more memory-efficient should not lead to making them incorrect.

It's okay to profile our code along with writing it. It's not about unneeded premature optimization, it's about doing it right at the first run!

Slides: https://bit.ly/profiling-rust

Rust Linz:
https://sessionize.com/rust-linz
https://rust-linz.at
https://fosstodon.org/@rustlinz
https://twitter.com/rustlinz

Rust is an excellent language for building embedded systems. Espressif Systems and ESP-RS Open source community made it possible to develop for ESP32 (S2, S3) chips with Xtensa and ESP32-C3 with RISC-V architecture. Developing embedded projects are possible both with STD and Bare Metal. It's very easy to start playing with chips even without hardware, just using the simulator https://wokwi.com/rust . Espressif community also introduced an Open Hardware board with KiCad templates so that anybody can design their own Rust board, a.k.a esp-rs/esp-rust-board.

Juraj on Twitter: https://twitter.com/jurajmichalek
Rust Linz: https://fosstodon.social/@rustlinz - https://twitter.com/rustlinz

A year ago we started an OS from scratch in Rust. Reflections on the journey and the lessons learned.

Rust Linz: https://fosstodon.social/@rustlinz - https://twitter.com/rustlinz

Visualizing something is often fascinating even if the math behind it is quite simple. A good way to start in that topic is to choose a simple simulation, choose the technology, and then start implementing it on your own. Especially implementing a cellular automaton is a good first step. In this session, Diemo wants to introduce you to the world of cellular automata and how to use Rust and the Bevy framework for visualization.

Diemo Heuer is a Software-Developer from Rostock (Germany) employed at Altow Digital Innovation. He uses Rust for professional projects mainly in the backend but for his hobby projects, he explores the further capabilities of that technology. He also is the host of different community events in Rostock; e.g. the Rust Meetup Rostock, Elixir Meetup Rostock, or the Altow Inspire.

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

Hypervisors are an incredibly powerful tool that can be used to run your FaaS or just virtual machines. Windows also secured their OS by utilizing a hypervisor. But hypervisors can also be used for bad things. Malware and game hacks use it to get around detections. This talk aims to show you the process of how I wrote an AMD hypervisor for Rust.

Matthias is a passionate Software Engineer with an interest in Software Security. He first heard about Rust in school and decided to give it a try. A few months after reading the Rust book, he finally had the time to rewrite some personal projects and started to understand why Rust is awesome.

Resources:
Matthias Blog: https://not-matthias.github.io/
Hypervisor List: https://github.com/stars/not-matthias/lists/hypervisor
Custom Allocators in Rust: https://not-matthias.github.io/posts/rust-kernel-adventures/

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

When I learned Rust, I was a Python programmer. This meant that I had no idea what a pointer was. Luckily, the Rust compiler is a good coach.

Tim is an experienced programmer with a deep interest in natural language processing, text mining, and wider forms of machine learning and artificial intelligence. Tim is also the author of "Rust in Action", published by Manning. He is very active in open source communities including the New Zealand Open Source Society.

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

Tower is a library from the Tokio ecosystem, featuring reusable components and abstractions for building networking clients and servers. We look at some of its use-cases, learn how to read and write Service trait implementations, and discuss some of its downsides.

About Stefan
Stefan Baumgartner is a developer from Austria and co-organizer of the Rust Linz Meetup. He writes regularly for the "Ferris Talk" column at Heise and publishes technical guides and books for various publishers.

Resources:
https://fettblog.eu/slides/introduction-to-tower/
https://github.com/ddprrt/lambda-hyper-example-workspace
https://tokio.rs/blog/2021-05-14-inventing-the-service-trait
https://github.com/ddprrt/axum-tower-layer-services

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

When you run a Rust program, you may be tempted to think that the first code to execute is the main function. However, this is far from the case. In this talk, we'll explore what happens before the main function runs. By the end, you'll have a deeper understanding of what happens before the bits that rustc compiles your program into ever run.

Ryan has been writing Rust since around version 0.10. He now focuses on Rust full time at Microsoft. When he's not doing Rust, he enjoys cooking, traveling and exploring Berlin where he lives.

Resources:
The Bits Between the Bits: https://www.youtube.com/watch?v=dOfucXtyEsU
Making Your Own Executable Packer: https://fasterthanli.me/series/making-our-own-executable-packer
How the heck do we get to main(): http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html
Everything You Ever Wanted to Know About DLLs: https://www.youtube.com/watch?v=JPQWQfDhICA
Minimizing Rust Binary Size: https://github.com/johnthagen/min-sized-rust

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

One of Rust's biggest draws is the promise of easily writing and compiling code for embedded devices. But where do you start with embedded development when you have zero clue and just want to dip your toes in some physical computing? This is just the talk for you! We'll use a Raspberry Pi and will write some Rust to interact with the real world.

Lisa is a Berlin-based creative technologist, artist, and researcher. Her main obsessions are playful interactions with computers and creative uses of civic tech and data.

Resources:
From 0 to no_std in one session: https://www.youtube.com/watch?v=Pu4MZmB0E28
The Discovery Book: https://docs.rust-embedded.org/discovery/
Embedded Rust Documentation: https://docs.rust-embedded.org/book/

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

Rust is a great programming language for creative coding, building games, implementing interactive sculptures, etc. It has been the most loved programming language in the famous Stack Overflow Survey for many years in a row. This workshop offers an introduction to Rust for artists who want to use it in their digital art. You will learn language fundamentals and discover Nannou (https://nannou.cc/), a framework for creative-coding in Rust.

Lisa is a Berlin-based creative technologist, artist, and researcher. Her main obsessions are playful interactions with computers and creative uses of civic tech and data.

Rust Linz: https://rust-linz.at
Speak at Rust Linz: https://sessionize.com/rust-linz
Twitter: https://twitter.com/rustlinz

Spin (https://spin.fermyon.dev) is a framework for building and running event-driven microservice applications with WebAssembly (Wasm) components.

With Spin, we’re trying to make it easier to get started with using WebAssembly on the server so that we can all take advantage of the security, portability, and speed WebAssembly provides when it comes to running microservices.

In this session, we will introduce the WebAssembly component model, and how Fermyon uses it together with Rust to create fast, secure, and portable microservices.

Everybody knows constants from other programming languages. But as so often, Rust is different and knows a lot of tricks regarding constants that other languages don't. Rust's *const fn* recently got new features (v1.61), so we decided to do an overview session about consts in Rust. This is a beginner-friendly session for people who are starting with Rust or haven't taken a deeper look into constants and *const fn* in Rust.

Last year, AWS launched a new SDK for Rust in developer preview (https://aws.amazon.com/about-aws/whats-new/2021/12/aws-sdk-rust-developer-preview/), enabling customers developing in Rust to use the language constructs they are used to, and to provide customers new to Rust an SDK that behaves similarly to SDKs they have used in other language environments. Zelda, a member of the AWS Rust SDK team, will be giving a whirlwind tour of the AWS Rust SDK. In this talk, she’ll cover:

- How to use the SDK to make requests
- What’s actually happening when using the SDK to make requests
- How the AWS Rust SDK team generates SDKs for 300+ Services
- What to do if you’re interested in contributing to the SDK

Ever wondered what the bang ("!") after "println" means? Not anymore! I will show you exactly how macros work, how to use them, and how to write your own macros.
This is the perfect talk for you if you are using macros, but you always wanted to know how they work and how to implement them yourself.

Async Rust: Portability and Interoperability

I'll talk about the portability and interoperability initiative of the async working group, an attempt to make async programming in Rust less tied to specific runtimes and improve interoperability in the async ecosystem.

I'll cover some of the problems with async programming today, what the initiative will try to achieve, and some detail about current work on async IO traits (Read, Write, etc).

No async programming experience required!

Nick's slides: https://t.co/v0UPeOQpqH

About Nick Cameron

Rust at Microsoft. Previously: Rust core team, distributed databases at PingCAP, Firefox graphics and layout, research in PL and type systems. He/him.

Nick on Twitter: https://twitter.com/nick_r_cameron
Rust Linz on Twitter https://twitter.com/rustlinz

Is Rust a great language for building Kubernetes ecosystem?

When it comes to building tools for the Kubernetes ecosystem, your first thought would be Golang, I'm here to explore if Rust is a better alternative, especially for in-cluster tooling that needs to have minimal overhead and for WebAssembly workloads. Rust is also great for building Kubernetes tooling like CLI apps and so on.

I'll be also sharing and showcasing KDash - a Kubernetes CLI dashboard that I built using Rust and we will look at the Kubernetes-Rust ecosystem that is rapidly evolving and why you should consider it

- Rust vs Golang for k8s use cases
- Advantages of Rust over Golang
- Ideal Kubernetes use cases for Rust (WASI, tools, proxies)
- Real-life use case and example (KDash)
- State of the Rust ecosystem for DevOps and K8s


About Deepu K Sasidharan

Deepu K Sasidharan is a Software Engineer by passion and profession. He is a Java Champion working as a Senior Developer Advocate at Okta. He is the co-lead of JHipster and the creator of KDash and JDL Studio. He is a polyglot programmer working with Java, JavaScript, Go, Rust, and so on. He is also a cloud technology advocate and an open-source software aficionado. He has authored books on Full-stack development and frequently writes about Java, JavaScript, Go, Rust, DevOps, Kubernetes, Linux, and so on, on his blog.

Deepu on Twitter: https://twitter.com/deepu105
Rust Linz on Twitter: https://twitter.com/rustlinz
Slides: https://speakerdeck.com/deepu105/is-rust-a-great-language-for-building-kubernetes-ecosystem

CGI is back! The experimental WAGI project allows you to write HTTP handlers as WebAssembly binaries. And the best thing: You don't need any libraries for it.

Stefan and Rainer experimented with WAGI. They would like to present a brief intro to this project consisting of some architectural background and Rust sample code.

About Stefan Baumgartner and Rainer Stropek
Stefan and Rainer are the founders and moderators of the Rust Linz meetup. Both have many years of practical experience in full-stack development and cloud computing.

Material, links, and slides: https://fettblog.eu/slides/introduction-to-wagi/

Thanks to Microsoft for their support!

Rust Linz:
https://rust-linz.at
https://sessionize.com/rust-linz
https://twitter.com/rustlinz

Rust for Linux is a project that aims to bring Rust support to the Linux kernel as a first-class language. This means providing support for writing kernel modules in Rust, such as drivers or filesystems, with as little unsafe code as possible.

This session will briefly explain how the Rust support works in the kernel and will give an update on the status of the project, as well as what is planned for the near future. It will also show a wishlist of Rust features that could help the project.

About Miguel
Miguel is a software engineer that maintains the Rust for Linux effort, as well as the auxdisplay, compiler attributes, and clang-format trees. He also participates in the ISO C committee, with an interest in UB and memory-safety topics. Previously, Miguel was a Staff Member at CERN in the Beams department and a Fellow in the Physics department.

About Wedson
Wedson is a software engineer that maintains the Rust for Linux effort; he is currently part of the Android platform security team at Google. For the past 19+ years, he has worked on kernels, bootloaders, hypervisors, etc. at Google, Facebook, and Microsoft.

Thanks to Microsoft for their Support!

Rust Linz:
https://rust-linz.at
https://sessionize.com/rust-linz
https://twitter.com/rustlinz

In this session, Zeeshan (https://twitter.com/zeenix) will walk us through the challenges of implementing an async library that's agnostic to the various current and future async runtimes. We will also look into possible solutions and workarounds to these challenges by following Zeeshan's personal journey with zbus, a D-Bus crate that is runtime-agnostic.

Special Thanks to Microsoft for their support
Rust Linz: https://rust-linz.at - https://twitter.com/rustlinz - https://sessionize.com/rustlinz

Tauri is a rust-based system for making small, fast, and secure applications using system Web views for desktops (and mobile very soon). In this talk, I will speak about the history, philosophy, approach, and future of the OSS Project Tauri.

Special Thanks to Microsoft for their support
Rust Linz: https://rust-linz.at - https://twitter.com/rustlinz - https://sessionize.com/rustlinz

Luca's talk is based on this article: https://www.lpalmieri.com/posts/error-handling-rust/

Rust does not rely on exceptions - errors are values, handled via the `Result` enum. Calling a fallible function forces you to account for errors - the type system does not let you ignore them.

Developers speak highly of Rust's approach to error handling. At the same time, they often report feeling lost and confused when modeling the unhappy path of their Rust applications. They have questions and the answers are not always straightforward: how do errors fit within the broader architecture of our application? What does a good error look like? What are errors for? Should we use a library? Which one?

This talk will offer a pragmatic framework to determine how to approach error modeling/handling in a variety of different scenarios.

About Luca Palmieri
Luca Palmieri is a Principal Engineer at TrueLayer. He is a co-organizer of the Rust London User Group and the author of "Zero To Production In Rust", an introduction to backend development using the Rust programming language.

He is the author of a few crates in the Rust ecosystem (e.g. cargo-chef, wiremock, ndarray-stats, linfa, etc.) as well as a few workshops (i.e. build-your-own-jira-with-rust and ndarray-koans).


Luca on Twitter: https://twitter.com/algo_luca
Luca's book: https://www.zero2prod.com/

We are aware of the audio issues.

curl is adding support for Rust components. In this talk, Daniel will explain why and how it will work. We will also find out how this impacts curl and its further usage. Daniel will also share learnings from the journey so far.

About Daniel Stenberg
Daniel Stenberg created curl and was involved in the working groups for HTTP/2 and QUIC (HTTP/3) with the IETF.

Daniel on Twitter: https://twitter.com/bagder

Learn how to use no_std to write bare-metal Rust applications. We will start with a normal user-space application and remove more and more layers of libraries and the OS until our code can run on bare metal. That way we learn all the steps necessary to handle raw memory registers in a no_std environment.

About Marco Amann
Having used Rust in a university-project in 2016, it quickly grew to be my favorite language. While I focus on low-level networking with Rust, the strong guarantees of the language range from high-level application development to bare-metal usage. At Digitalfrontiers, we currently write a Book about Rust for Application Development.

Examples on Github: https://github.com/trimoq/rust-meetup-linz-embedded
Slides: https://fettblog.eu/wp-content/uploads/rust-meetup-linz-no-std.pdf

Marco on Twitter: https://twitter.com/amann_dev
Rust Linz on Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

Each year, thousands of developers are practicing their coding skills in the *Advent of Code* event. Each day in December, you get a coding puzzle in which you have to help Santa Claus in order to save Christmas. Advent of Code is a great opportunity for those of you who are looking for ways to practice Rust in a fun and entertaining way. Rainer will introduce you to Advent of Code and use some exemplary puzzles to illustrate what you can learn in terms of Rust development.

Slides: https://slides.com/rainerstropek/rust-linz-aoc-2021/fullscreen
Rust Advent of Code Mob Meetup: https://www.meetup.com/Mob-Programming-on-Open-Source-Software/events/282176679

Rainer on Twitter: https://twitter.com/rstropek
Rust Linz on Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

Armin is going to tell us about his experiences with Serde, the popular Serialization/Deserialization crate. Serde is format-independent and lets you work with JSON, YAML, and a range of different formats. Despite all of this, there is a lot that can be accomplished with it and some of the use cases are quite interesting and worth sharing.

Armin's blog: https://lucumr.pocoo.org/2021/11/14/abusing-serde/
Minijinja: https://github.com/mitsuhiko/minijinja
Armin on Twitter: https://twitter.com/mitsuhiko
Rust Linz on Twitter: https://twitter.com/rustlinz

Speak at Rust Linz: https://sessionize.com/rustlinz

WebAssembly is the next big thing on the server and in the cloud. By leveraging tools like Krustlet (https://krustlet.dev/), we can get rid of containers in Kubernetes! What does that mean? What can you achieve today, and what is still experimental? And how can you get hands-on right now? Join this talk by Azure MVP and cloud-native enthusiast Thorsten Hans to get those questions answered. It's time to embrace the platform of the future.

Slides: https://speakerdeck.com/thorstenhans/webassembly-beyond-the-browser
Github: https://github.com/ThorstenHans/krustlet-at-rust-linz

Thorsten on Twitter: https://twitter.com/ThorstenHans
Rust Linz on Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

Rust 2021 came with a significant enhancement regarding closures: Disjoint Capturing. In this session, Rainer Stropek starts by describing how closures work in Rust. This is for relative beginners in Rust who know closures from other programming languages and want to know what's different in Rust. Based on that, Rainer illustrates the new disjoint capturing feature in Rust 2021 based on a "fairy tale" code sample.

https://twitter.com/rstropek
https://twitter.com/rustlinz
https://rust-linz.at
https://sessionize.com/rust-linz

Tokio, Warp, and Websockets
In his talk, Stefan will show you how to build a Server with Tokio, Warp, and Websockets. Demo repository: https://github.com/ddprrt/warp-websockets-example

https://twitter.com/ddprrt
https://twitter.com/rustlinz
https://sessionize.com/rust-linz
https://rust-linz.at

(offline per speaker's request) Want to speed up your microservices? Want to make e-money? Well, we’ve got you covered, at least for the former. Learn to build simple, secure, and well-factored gRPC microservices in Rust with Bazel. From the introduction to migration strategies for your microservice architectures. Join us for this production-ready talk, the TOUCHDOWN of this year!

Rust Linz on Twitter: https://twitter.com/rustlinz

One of the capabilities async Rust enables is the ability to easily execute code concurrently. We have solutions for this in the ecosystem, but none yet provided by the stdlib. That’s because there is still a lot of design work left to be done.

In this talk, Yosh will cover a basic model for concurrent execution of futures. Then walk you through the design space of this feature, showing various ways in which it can be implemented. And finally showcase a novel futures concurrency library that ergonomically implements concurrent futures execution in Rust.

Yosh on Twitter: https://twitter.com/yoshuawuyts
Rust Linz on Twitter: https://twitter.com/rustlinz

This year, important things have been improved in Rust regarding iterators and arrays. Finally, we can iterate over arrays by value using a "for"-loop. It is kind of strange that this seemingly simple language feature took so long to arrive, isn't it?

In his talk about iterators, Rainer quickly demonstrates the new iterator features that came with Rust 1.53. Then he tries to shed some light on what problems the Rust team had to solve to deliver this important language enhancement.

For beginners, Rainer will also recap what iterators are and how they work behind the scenes in Rust. So if you are new or you have limited Rust experience, don't hesitate to join.

Together with heise developer, the Rust Linz meetup gives a small tour on what's to like about the Rust programming language

Developers who approach Rust from the viewpoint of other OO languages like TypeScript, C#, or Java frequently misinterpret Rust's traits as interfaces. That might be true to a certain extent, but on closer examination traits are much more powerful than you might think. In this demo-only session, Rainer Stropek starts by introducing you to the fundamentals of traits. You will see how to create your own ones, how to manually implement system traits, and how to auto-implement them. Once we covered those basics, Rainer dives deeper into unique features of traits. We will look at default implementations, trait parameters, trait objects, and trait bounds for generics.

Rainer on Twitter: https://twitter.com/rstropek
Rust Linz on Twitter: https://twitter.com/rustlinz

If you run your software in the cloud, you might have already done some Serverless programming. Be it either as glue code that connects existing services or for your entire web API. But can we run Serverless workloads with our most favorite programming language as well?

We can! In this talk, we are going to look at how to run serverless workloads in Rust in Azure Functions and AWS Lambda. In doing so, we will see the fundamental differences between both serverless providers, and what effect this has on your applications!

Stefan on Twitter: https://twitter.com/ddprrt
Rust Linz on Twitter: https://twitter.com/rustlinz

JT takes a look at Nushell, a shell/language written in Rust leveraging Rust's strengths to build a modern way for working with your system, data, and more.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
JT: https://twitter.com/jntrnr

Speak at Rust Linz: https://sessionize.com/rust-linz

Rust is a complicated programming language with a helpful, yet pedantic compiler. This talk aims to provide you some strategies for learning Rust your next programming language.
In this session, you will deepen your understanding of some fundamental Rust concepts, learn to deconstruct its syntax into simpler pieces, and discover many tools available to you to help you learn.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Tim McNamara: https://twitter.com/timClicks

Speak at Rust Linz: https://sessionize.com/rust-linz

A native language like C++ is still a natural choice for real-time graphics applications and also has an established workflow for bridging code between the desktop and browser world. For revamping our old 3D rendering module, we also wanted to consider other alternatives. It was quite clear Rust offers great modern tooling and promising new concepts. But most importantly after evaluating two proof of concepts, we saw that the Rust environment is already very mature and supports all our critical requirements. Additionally, future browser features like WebGPU and WebAssembly SIMD (for CPU rendering) are first-class Rust citizens which will get interesting for us once they get production-ready. Join our experience report on why we think that Rust is a great choice for our use case and how we want to use it in the future.

About Harald Reingruber
Harald Reingruber is passionate about visual computing, software crafting, ensemble- (a.k.a mob-)programming, and hiking on the weekends.


Rust Linz at https://rust-linz.at​
Twitter: https://twitter.com/rustlinz​
Harald Reingruber: https://twitter.com/Harald3DCV​

Speak at Rust Linz: https://sessionize.com/rust-linz

We use programs to automate tasks or solve specific problems for us. Too seldomly we use it to create art or simply write playful programs just for the fun of it. How do you write creative code in Rust? I'm so glad you asked! We'll take a look at some algorithms and tricks in the creative coding toolbox to get you started and use the nannou library to make them a (digital) reality.

About Lisa Passing
Lisa is a Berlin-based creative technologist, artist, and researcher. Her main obsessions are playful interactions with computers and creative uses of civic tech and data.

Rust Linz at https://rust-linz.at​
Twitter: https://twitter.com/rustlinz​

Speak at Rust Linz: https://sessionize.com/rust-linz

Moving to the cloud is a Big Deal™. So why would you want to throw a new language like Rust into the mix? Join us as we demonstrate how Rust can be used with Azure to simplify and bring safety to your code. We'll give a brief overview of the strengths and weaknesses of using Rust in the cloud in general before demoing how you can use Rust to connect to and leverage the Azure APIs. Kubernetes more your thing? We've got that covered too! We'll show how Rust makes interfacing with and writing tooling for Kubernetes a breeze, followed by a practical demo of a Rust project (Krustlet) in action on AKS.

Thomas on Twitter: https://twitter.com/_oftaylor​
Ryan on Twitter: https://twitter.com/ryan_levick
Rust Linz on Twitter: https://twitter.com/rustlinz​
Submit your talk: https://sessionize.com/rust-linz​
On the web: https://rust-linz.at

In this talk, Herbert will walk you through how he got started with Rust, created the Rust Roguelike Tutorial and then Hands-On Rust. The talk will focus on using game development as a means of learning Rust, and step through the creation of Flappy Dragon - a simple game used in Hands-On Rust to teach the language basics.

About Herbert Wolverson
Herbert Wolverson has worked as a programmer and an indie game developer since the late 1990s. He’s taught programming and IT skills at a variety of levels, contributes to multiple Open Source projects, and is active in the game development scene.

Rust Linz at https://rust-linz.at​
Twitter: https://twitter.com/rustlinz​
Herbert Wolverson: https://twitter.com/herberticus​

Speak at Rust Linz: https://sessionize.com/rust-linz

At Mozilla, Firefox is not the only product we ship. Many others — including a variety of smartphone applications, and certainly not just web browsers — are built by various teams across the organization. These applications are composed of a multitude of libraries that, when possible, are reused across platforms.

In the past 2 years we used Rust to rebuild one of these libraries: the library powering the telemetry in our mobile applications is now integrated into Android and iOS applications and since earlier this year on Desktop as well.

About Jan-Erik Rediger
At Mozilla, Jan-Erik writes stuff so others can measure thingies. He's an active member of the Rust community team since 2014. He coached at Rust workshops & runs Rust conferences in Europe. To get away from computers he picked up scuba diving to see the world underwater.

Rust Linz at https://rust-linz.at​
Twitter: https://twitter.com/rustlinz​
Jan-Erik: https://twitter.com/badboy_​

Speak at Rust Linz: https://sessionize.com/rust-linz

Rust's Ownership and Borrowing System has repercussions beyond the mere topic of memory safety. This talk approaches the topic from a different angle: interaction between components. I found this view a useful one to take when teaching Rust to programmers that enter Rust with a background of memory-safe programming languages such as Ruby, Java, or Python.

Florian on Twitter: https://twitter.com/Argorak
Rust Linz on Twitter: https://twitter.com/rustlinz
Rust Linz on the web: https://rust-linz.at
Submit your talk: https://sessionize.com/rust-linz

One year ago, my team released Krustlet, a Kubernetes Kubelet implementation for running WASM modules written in Rust. Since then, we've spent plenty of time out on the frontier, implementing full Kubernetes functionality, all in Rust. In this session, we'll cover why we chose Rust and how WASM and Rust work together. Using examples from Krustlet, we'll also review the pros and cons of using Rust for writing software for the cloud and address how it compares to languages like Go.

Thomas on Twitter: https://twitter.com/_oftaylor​
Rust Linz on Twitter: https://twitter.com/rustlinz​
On the web: https://rust-linz.at
Submit your talk: https://sessionize.com/rust-linz​

A talk showcasing the typical workflow of someone contributing to an open-source project through Github. The talk details the process of forking, branching, finding an issue, fixing the issue in VS-Code with Rust, making a PR, and more through a fun demo that can be revisited post-session. Concludes with an exploration of Embark Studios' several open-source Rust projects (including GPU code in Rust, PhysX in Rust, and more) and how you can start using/contributing to them.

Celia on Twitter: https://twitter.com/celiawrite
Rust Linz on Twitter https://twitter.com/rustlinz
Submit your talk: https://sessionize.com/rust-linz
On the web: https://rust-linz.at

In this short session, I will share the story of investigating the difference in performance between a `for v in expression` loop and a `while` loop. The talk will cover topics in the Rust language itself, compiler optimization levels and how to benchmark performance.

Code: https://github.com/hawkinsw/speed_limits_of_loops_in_rust
Will on Twitter: https://twitter.com/hawkinsw
Rust Linz on Twitter: https://twitter.com/rustlinz
Submit your talk: https://sessionize.com/rust-linz
On the web: https://rust-linz.at

Mosaic - A Rusty Terminal Workspace and Multiplexer

Mosaic is an open-source terminal multiplexer being developed in Rust (https://github.com/mosaic-org/mosaic)
This talk will introduce the project, talk about its architecture, and some of the ways Rust is unique in helping us build it (eg. webassembly and WASI for our plugin system).

Aram on Twitter: https://twitter.com/im_snif
Rust Linz:
https://twitter.com/rustlinz
https://sessionize.com/rust-linz
https://rust-linz.at

Unleash the Power of your Comments

A quick introduction to *rustdoc*, and how it helps you to make the probably most boring part of programming more pleasant.

Rust Linz:
https://twitter.com/rustlinz
https://rust-linz.at
https://sessionize.com/rust-linz

Web APIs with Rust Rocket
Is Rust only relevant for systems programming? Do you need platforms like Go or Node.js to build great web APIs? Rainer has been building cloud-based distributed systems for many years and for this Rust Linz meetup he looked into the Rocket framework. He will give a short introduction and compare it to frameworks he knows from other programming languages.

About Rainer Stropek (https://twitter.com/rstropek)
Rainer Stropek is co-founder and CEO of the company software architects and has been serving this role since 2008. At software architects, Rainer and his team are developing the award-winning SaaS time tracking solution “time cockpit”. Previously, Rainer founded and led two IT consulting firms that worked in the area of developing software solutions based on the Microsoft technology stack.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

The Exercist
Do you want to know a new programming language and don't know where to start? Do you have a certain project in mind but are scared about all the concepts you have to pick up to reach your goal? Going back to basic algorithms and Programming 101 exercises can help a lot! I want to show you exercism.io, a platform that helped me a lot in learning Rust. Maybe it's the right platform for you, too!

About Stefan Baumgartner (https://twitter.com/ddprrt)
Stefan Baumgartner works at Dynatrace. He writes for Manning, Smashing Magazine, and A List Apart and made the Kessel run in less than 12 parsecs.

In his spare time, he organizes ScriptConf and DevOne in Linz and co-hosts the German language Working Draft podcast. Stefan enjoys Italian food, Belgian beer, and British vinyl records.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

Stefan (https://twitter.com/dns2utf8) speaks about Atomic Counters and Cache Lines

How do atomic counters and cache lines interact with each other and why do they affect the performance of my programs?

About Stefan Schindler
Stefan has been working with Rust since 2015, is a member of the RustFest Project and the maintainer of the threadpool and sudo crate, and many others.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

DISCLAIMER: Due to some technical challenges the video image started to flicker as the video progresses. Sorry for that.

Trusted Computing with Rust and Intel SGX
Do you like a challenge and at the same time don't trust the cloud? Then this talk is for you!

Working without the standard library is a core (no pun intended) aspect of Rust - and it's useful for many things, including embedded development, WASM, and working with encrypted computation such as SGX. In this talk we'll look closer at the latter: Intel's Software Guard EXtensions (SGX) and how we can get started running (mostly) safe no_std code hidden from the eyes of your cloud provider.

About Claus Matzinger
Claus Matzinger is a software engineer with a very diverse background. After working with several legacy programming languages early on, a database start up (Crate.io) was the stepping stone towards sophisticated data pipelines. At Microsoft, two years later, this should prove useful where Claus helps customers build machine learning pipelines, sort out their MLOps, and the occasional modelling. Along the way, Claus has written two books about the Rust programming language and blogs at https://blog.x5ff.xyz.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Follow Claus: https://twitter.com/0x5ff
Speak at Rust Linz: https://sessionize.com/rust-linz

Having fun with Rust everywhere possible. With a short insight into the skeleton of a web extension, we are going to manipulate websites to our liking. Including a small dive into a comfortable build setup for a full-blown web extension.

About Karl Grasegger
Passionate web developer with a love for trying out new things.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Speak at Rust Linz: https://sessionize.com/rust-linz

Writing a (Windows) Kernel Driver with Rust
Anti-Virus', Anti-Cheats, and even Hackers are utilizing Kernel Drivers. Why? Because they want to have full control over your operating system to either protect or harm you. This talk will explain how you can use Rust to start developing your own Kernel Drivers.

About Matthias Heiden
Matthias is a passionate Software Engineer with an interest in Software Security. He first heard about Rust in school and decided to give it a try. A few months after reading the Rust book, he finally had the time to rewrite some personal projects and started to understand why Rust is awesome.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Matthias Heiden: https://twitter.com/not_matthias

Speak at Rust Linz: https://sessionize.com/rust-linz

How not to rely on inheritance
As opposed to many languages, Rust doesn't have a concept of inheritance, relying instead on Traits. In this talk, we'll talk about Traits and how to use them for common programming patterns.

About Valentin Tolmer
I am a craftsman, always working to improve my code and others' around me.

Slides: https://docs.google.com/presentation/d/1qGrhRDUgFrnMsSm4MHO0IGozfSlNomn3mlmktWcvI5M/edit

Build, debug, and test an application

Rust empowers developers to build reliable and efficient software. It is fun to write, easy to read, and high performing. Join Microsoft Program Manager Meaghan Lewis to explore some fundamental concepts and syntax of Rust through a simple command-line application. Along the way, she will debug, test, and clearly explain all the parts of the application.

About Meaghan Lewis
Meaghan Lewis currently focuses on creating and delivering learning experiences centered around emerging technology for Microsoft Reactors worldwide. Meaghan has a superpower in quality engineering and previously worked in the QA field for nearly a decade. Meaghan has a passion for teaching lifelong learners and has spent years speaking at conferences and delivering online courses. Meaghan is a native of California and lives in the San Francisco Bay Area with her husband and two dogs.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Meaghan Lewis: https://twitter.com/iammeaghanlewis

Speak at Rust Linz: https://sessionize.com/rust-linz

Building a digital logic analyzer from scratch with embedded Rust

Introduction to embedded and its ecosystem, using a hands-on example project: building a digital logic analyzer. We will learn about coding bare metal rust code, interacting with peripherals, and creating & using abstractions over hardware.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Roland Ruckerbauer: https://twitter.com/ruambua

Speak at Rust Linz: https://sessionize.com/rust-linz

C# has NuGet, Java has Maven, JavaScript has npm - and Rust has Cargo. Cargo is a package manager and build-tool. In this session, Rainer Stropek will introduce Cargo and demonstrate how to use it when building Rust applications. This will be an introductory talk for people who are rather new to Rust.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Rainer Stropek: https://twitter.com/rstropek

Speak at Rust Linz: https://sessionize.com/rust-linz

It seems like most developers these days have heard about Rust, but many are still wondering if the language is relevant to them. In this talk, we'll explore why learning Rust might be of interest to you.

Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Ryan Levick: https://twitter.com/ryan_levick

Speak at Rust Linz: https://sessionize.com/rust-linz