#Devoxx

[forever-stuck-on-java-8]

Watch Java Architect leads Brian Goetz and Viktor Klang talk about the work that's happening to fix Java's worst design mistake improve serialization at Devoxx Belgium.

[this-week-in-rust]

This Week in Rust 534

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Announcing Rust 1.76.0

This Development-cycle in Cargo: 1.77

Project/Tooling Updates

zbus 4.0 released. zbus is a pure Rust D-Bus crate. The new version brings a more ergonomic and safer API. Release: zbus4

This Month in Rust OSDev: January 2024

Rerun 0.13 - real-time kHz time series in a multimodal visualizer

egui 0.26 - Text selection in labels

Hello, Selium! Yet another streaming platform, but easier

Observations/Thoughts

Which red is your function?

Porting libyaml to Safe Rust: Some Thoughts

Design safe collection API with compile-time reference stability in Rust

Cross compiling Rust to win32

Modular: Mojo vs. Rust: is Mojo 🔥 faster than Rust 🦀 ?

Extending Rust's Effect System

Allocation-free decoding with traits and high-ranked trait bounds

Cross-Compiling Your Project in Rust

Kind: Our Rust library that provides zero-cost, type-safe identifiers

Performance Roulette: The Luck of Code Alignment

Too dangerous for C++

Building an Uptime Monitor in Rust

Box Plots at the Olympics

Rust in Production: Interview with FOSSA

Performance Pitfalls of Async Function Pointers (and Why It Might Not Matter)

Error management in Rust, and libs that support it

Finishing Turborepo's migration from Go to Rust

Rust: Reading a file line by line while being mindful of RAM usage

Why Rust? It's the safe choice

[video] Rust 1.76.0: 73 highlights in 24 minutes!

Rust Walkthroughs

Rust/C++ Interop Part 1 - Just the Basics

Rust/C++ Interop Part 2 - CMake

Speeding up data analysis with Rayon and Rust

Calling Rust FFI libraries from Go

Write a simple TCP chat server in Rust

[video] Google Oauth with GraphQL API written in Rust - part 1. Registration mutation.

Miscellaneous

The book "Asynchronous Programming in Rust" is released

January 2024 Rust Jobs Report

Chasing a bug in a SAT solver

Rust for hardware vendors

[audio] How To Secure Your Audio Code Using Rust With Chase Kanipe

[audio] Tweede Golf - Rust in Production Podcast

[video] RustConf 2023

[video] Decrusting the tracing crate

Crate of the Week

This week's crate is microflow, a robust and efficient TinyML inference engine for embedded systems.

Thanks to matteocarnelos for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

* Hyperswitch - [FEATURE]: Setup code coverage for local tests & CI * Hyperswitch - [FEATURE]: Have get_required_value to use ValidationError in OptionExt

If you are a Rust project owner and are looking for contributors, please submit tasks here.

CFP - Speakers

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

Devoxx PL 2024 | CFP closes 2024-03-01 | Krakow, Poland | Event date: 2024-06-19 - 2024-06-21

RustFest Zürich 2024 CFP closes 2024-03-31 | Zürich, Switzerland | Event date: 2024-06-19 - 2024-06-24

If you are an event organizer hoping to expand the reach of your event, please submit a link to the submission website through a PR to TWiR.

Updates from the Rust Project

466 pull requests were merged in the last week

add armv8r-none-eabihf target for the Cortex-R52

add lahfsahf and prfchw target feature

check_consts: fix duplicate errors, make importance consistent

interpret/write_discriminant: when encoding niched variant, ensure the stored value matches

large_assignments: Allow moves into functions

pattern_analysis: gather up place-relevant info

pattern_analysis: track usefulness without interior mutability

account for non-overlapping unmet trait bounds in suggestion

account for unbounded type param receiver in suggestions

add support for custom JSON targets when using build-std

add unstable -Z direct-access-external-data cmdline flag for rustc

allow restricted trait impls under #[allow_internal_unstable(min_specialization)]

always check the result of pthread_mutex_lock

avoid ICE in drop recursion check in case of invalid drop impls

avoid a collection and iteration on empty passes

avoid accessing the HIR in the happy path of coherent_trait

bail out of drop elaboration when encountering error types

build DebugInfo for async closures

check that the ABI of the instance we are inlining is correct

clean inlined type alias with correct param-env

continue to borrowck even if there were previous errors

coverage: split out counter increment sites from BCB node/edge counters

create try_new function for ThinBox

deduplicate tcx.instance_mir(instance) calls in try_instance_mir

don't expect early-bound region to be local when reporting errors in RPITIT well-formedness

don't skip coercions for types with errors

emit a diagnostic for invalid target options

emit more specific diagnostics when enums fail to cast with as

encode coroutine_for_closure for foreign crates

exhaustiveness: prefer "0..MAX not covered" to "_ not covered"

fix ICE for deref coercions with type errors

fix ErrorGuaranteed unsoundness with stash/steal

fix cycle error when a static and a promoted are mutually recursive

fix more ty::Error ICEs in MIR passes

for E0223, suggest associated functions that are similar to the path

for a rigid projection, recursively look at the self type's item bounds to fix the associated_type_bounds feature

gracefully handle non-WF alias in assemble_alias_bound_candidates_recur

harmonize AsyncFn implementations, make async closures conditionally impl Fn* traits

hide impls if trait bound is proven from env

hir: make sure all HirIds have corresponding HIR Nodes

improve 'generic param from outer item' error for Self and inside static/const items

improve normalization of Pointee::Metadata

improve pretty printing for associated items in trait objects

introduce enter_forall to supercede instantiate_binder_with_placeholders

lowering unnamed fields and anonymous adt

make min_exhaustive_patterns match exhaustive_patterns better

make it so that async-fn-in-trait is compatible with a concrete future in implementation

make privacy visitor use types more (instead of HIR)

make traits / trait methods detected by the dead code lint

mark "unused binding" suggestion as maybe incorrect

match lowering: consistently lower bindings deepest-first

merge impl_polarity and impl_trait_ref queries

more internal emit diagnostics cleanups

move path implementations into sys

normalize type outlives obligations in NLL for new solver

print image input file and checksum in CI only

print kind of coroutine closure

properly handle async block and async fn in if exprs without else

provide more suggestions on invalid equality where bounds

record coroutine kind in coroutine generics

remove some unchecked_claim_error_was_emitted calls

resolve: unload speculatively resolved crates before freezing cstore

rework support for async closures; allow them to return futures that borrow from the closure's captures

static mut: allow mutable reference to arbitrary types, not just slices and arrays

stop bailing out from compilation just because there were incoherent traits

suggest [tail @ ..] on [..tail] and [...tail] where tail is unresolved

suggest less bug-prone construction of Duration in docs

suggest name value cfg when only value is used for check-cfg

suggest pattern tests when modifying exhaustiveness

suggest turning if let into irrefutable let if appropriate

suppress suggestions in derive macro

take empty where bounds into account when suggesting predicates

toggle assert_unsafe_precondition in codegen instead of expansion

turn the "no saved object file in work product" ICE into a translatable fatal error

warn on references casting to bigger memory layout

unstably allow constants to refer to statics and read from immutable statics

use the same mir-opt bless targets on all platforms

enable MIR JumpThreading by default

fix mir pass ICE in the presence of other errors

miri: fix ICE with symbolic alignment check on extern static

miri: implement the mmap64 foreign item

prevent running some code if it is already in the map

A trait's local impls are trivially coherent if there are no impls

use ensure when the result of the query is not needed beyond its Resultness

implement SystemTime for UEFI

implement sys/thread for UEFI

core/time: avoid divisions in Duration::new

core: add Duration constructors

make NonZero constructors generic

reconstify Add

replace pthread RwLock with custom implementation

simd intrinsics: add simd_shuffle_generic and other missing intrinsics

cargo: test-support: remove special case for $message_type

cargo: don't add the new package to workspace.members if there is no existing workspace in Cargo.toml

cargo: enable edition migration for 2024

cargo: feat: add hint for adding members to workspace

cargo: fix confusing error messages for sparse index replaced source

cargo: fix: don't duplicate comments when editing TOML

cargo: relax a test to permit warnings to be emitted, too

rustdoc: Correctly generate path for non-local items in source code pages

bindgen: add target mappings for riscv64imac and riscv32imafc

bindgen: feat: add headers option

clippy: mem_replace_with_default No longer triggers on unused expression

clippy: similar_names: don't raise if the first character is different

clippy: to_string_trait_impl: avoid linting if the impl is a specialization

clippy: unconditional_recursion: compare by Tys instead of DefIds

clippy: don't allow derive macros to silence disallowed_macros

clippy: don't lint incompatible_msrv in test code

clippy: extend NONMINIMAL_BOOL lint

clippy: fix broken URL in Lint Configuration

clippy: fix false positive in redundant_type_annotations lint

clippy: add autofixes for unnecessary_fallible_conversions

clippy: fix: ICE when array index exceeds usize

clippy: refactor implied_bounds_in_impls lint

clippy: return Some from walk_to_expr_usage more

clippy: stop linting blocks_in_conditions on match with weird attr macro case

rust-analyzer: abstract more over ItemTreeLoc-like structs

rust-analyzer: better error message for when proc-macros have not yet been built

rust-analyzer: add "unnecessary else" diagnostic and fix

rust-analyzer: add break and return postfix keyword completions

rust-analyzer: add diagnostic with fix to replace trailing return <val>; with <val>

rust-analyzer: add incorrect case diagnostics for traits and their associated items

rust-analyzer: allow cargo check to run on only the current package

rust-analyzer: completion list suggests constructor like & builder methods first

rust-analyzer: improve support for ignored proc macros

rust-analyzer: introduce term search to rust-analyzer

rust-analyzer: create UnindexedProject notification to be sent to the client

rust-analyzer: substitute $saved_file in custom check commands

rust-analyzer: fix incorrect inlining of functions that come from MBE macros

rust-analyzer: waker_getters tracking issue from 87021 for 96992

rust-analyzer: fix macro transcriber emitting incorrect lifetime tokens

rust-analyzer: fix target layout fetching

rust-analyzer: fix tuple structs not rendering visibility in their fields

rust-analyzer: highlight rustdoc

rust-analyzer: preserve where clause when builtin derive

rust-analyzer: recover from missing argument in call expressions

rust-analyzer: remove unnecessary .as_ref() in generate getter assist

rust-analyzer: validate literals in proc-macro-srv FreeFunctions::literal_from_str

rust-analyzer: implement literal_from_str for proc macro server

rust-analyzer: implement convert to guarded return assist for let statement with type that implements std::ops::Try

Rust Compiler Performance Triage

Relatively balanced results this week, with more improvements than regressions. Some of the larger regressions are not relevant, however there was a real large regression on doc builds, that was caused by a correctness fix (rustdoc was doing the wrong thing before).

Triage done by @kobzol. Revision range: 0984becf..74c3f5a1

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 2.1% [0.2%, 12.0%] 44 Regressions ❌ (secondary) 5.2% [0.2%, 20.1%] 76 Improvements ✅ (primary) -0.7% [-2.4%, -0.2%] 139 Improvements ✅ (secondary) -1.3% [-3.3%, -0.3%] 86 All ❌✅ (primary) -0.1% [-2.4%, 12.0%] 183

6 Regressions, 5 Improvements, 8 Mixed; 5 of them in rollups 53 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

eRFC: Iterate on and stabilize libtest's programmatic output

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

RFC: Rust Has Provenance

Tracking Issues & PRs

Rust

[disposition: close] Implement Future for Option<F>

[disposition: merge] Tracking Issue for min_exhaustive_patterns

[disposition: merge] Make unsafe_op_in_unsafe_fn warn-by-default starting in 2024 edition

Cargo

[disposition: merge] feat: respect rust-version when generating lockfile

New and Updated RFCs

No New or Updated RFCs were created this week.

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

RFC: Checking conditional compilation at compile time

Testing steps

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2024-02-14 - 2024-03-13 💕 🦀 💕

Virtual

2024-02-15 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn

2024-02-15 | Virtual + In person (Praha, CZ) | Rust Czech Republic

Introduction and Rust in production

2024-02-19 | Virtual (Melbourne, VIC, AU)| Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 1

2024-02-20 | Virtual (Melbourne, VIC, AU) | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 2

2024-02-20 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2024-02-20 | Virtual | Rust for Lunch

Lunch

2024-02-21 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust for Rustaceans Book Club: Chapter 2 - Types

2024-02-21 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2024-02-22 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-02-27 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-02-29 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup | Mirror: Berline.rs page

2024-02-29 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Surfing the Rusty Wireless Waves with the ESP32-C3 Board

2024-03-06 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-03-07 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-03-12 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2024-03-12 | Hybrid (Virtual + In-person) Munich, DE | Rust Munich

Rust Munich 2024 / 1 - hybrid

Asia

2024-02-17 | New Delhi, IN | Rust Delhi

Meetup #5

Europe

2024-02-15 | Copenhagen, DK | Copenhagen Rust Community

Rust Hacknight #2: Compilers

2024-02-15 | Praha, CZ - Virtual + In-person | Rust Czech Republic

Introduction and Rust in production

2024-02-21 | Lyon, FR | Rust Lyon

Rust Lyon Meetup #8

2024-02-22 | Aarhus, DK | Rust Aarhus

Rust and Talk at Partisia

2024-02-29 | Berlin, DE | Rust Berlin

Rust and Tell - Season start 2024

2024-03-12 | Munich, DE + Virtual | Rust Munich

Rust Munich 2024 / 1 - hybrid

North America

2024-02-15 | Boston, MA, US | Boston Rust Meetup

Back Bay Rust Lunch, Feb 15

2024-02-15 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group Meetup

2024-02-20 | New York, NY, US | Rust NYC

Rust NYC Monthly Mixer (Moved to Feb 20th)

2024-02-20 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2024-02-21 | Boston, MA, US | Boston Rust Meetup

Evening Boston Rust Meetup at Microsoft, February 21

2024-02-22 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-02-28 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2024-03-07 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

Oceania

2024-02-19 | Melbourne, VIC, AU + Virtual | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 1

2024-02-20 | Melbourne, VIC, AU + Virtual | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 2

2024-02-27 | Canberra, ACT, AU | Canberra Rust User Group

February Meetup

2024-02-27 | Sydney, NSW, AU | Rust Sydney

🦀 spire ⚡ & Quick

2024-03-05 | Auckland, NZ | Rust AKL

Rust AKL: Introduction to Embedded Rust + The State of Rust UI

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

For some weird reason the Elixir Discord community has a distinct lack of programmer-socks-wearing queer furries, at least compared to Rust, or even most other tech-y Discord servers I’ve seen. It caused some weird cognitive dissonance. Why do I feel vaguely strange hanging out online with all these kind, knowledgeable, friendly and compassionate techbro’s? Then I see a name I recognized from elsewhere and my hindbrain goes “oh thank gods, I know for a fact she’s actually a snow leopard in her free time”. Okay, this nitpick is firmly tongue-in-cheek, but the Rust user-base continues to be a fascinating case study in how many weirdos you can get together in one place when you very explicitly say it’s ok to be a weirdo.

– SimonHeath on the alopex Wiki's ElixirNitpicks page

Thanks to Brian Kung for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[craigbrownphd]

The Code Written in Timefold Outsmarted the Solution Provided by ChatGPT for Devoxx Talks Scheduling

https://www.infoq.com/news/2024/01/timefold-chatgpt-optimal-plan/?utm_campaign=infoq_content&utm_source=dlvr.it&utm_medium=tumblr&utm_term=AI%2C%20ML%20%26%20Data%20Engineering-news

[wernerkeil]

Watch Devoxx Ukraine 2020 Online

[btc-current-blog]

In less than 24hrs Arkane is going to demo a VeChain application while performing a keynote on how to build blockchain apps with Zero-Knowledge at the largest Java developer conference in Europe Devoxx !! Keynote will be live broadcasted!!

In less than 24hrs Arkane is going to demo a VeChain application while performing a keynote on how to build blockchain apps with Zero-Knowledge at the largest Java developer conference in Europe Devoxx !! Keynote will be live broadcasted!!

[ad_1]

In less than 24hrs Arkane is going to demo a VeChain application while performing a keynote on how to build blockchain apps with Zero-Knowledge at the largest Java developer conference in Europe Devoxx !! Keynote will be live broadcasted!!

[ad_2] View Reddit by DravenChenZhen – View Source

[digvijayb]

Rx World

[akshay-makersalley-blog]

IoT with Dart

Ten years back when I was a kid I started making autonomous robots like line follower and obstacle avoider with C programming as a hobby so from that I’m doing C programming comfortably,but after that I found an influencing line about Dart,“Dart is an object-oriented, class-based, garbage-collected language with C-style syntax”, this line made me so fascinated about the new programming language Dart,because it has exactly similar syntax as C programming (Dart looks a bit like C) and I started learning Dart for IoT development.

Obviously as a common person we all are familiar with the dart pad game which we have been enjoying for past decades,the game itself a very popular in all age groups also it is traditional pub games that remains popular to the present day in many countries.But google took out this word very aggressively for programming singularity.

The word dart means itself the singularity in the sense of programming, word-full meaning of dart is known as a small pointed missile that can be thrown into so the dart justifies this word and becomes a client-optimized programming language for apps on multiple platforms.

This is so amazing that a single programming language could give us a common development in all sources. And it is used to build mobile, desktop, server, and web applications.I like dart because it can compile code in native or java script.Dart code compiled to native ARM or X64 machine code for mobile, desktop, and server apps.

The first (1.0)stable version of dart release was released on November 14th, 2013 and the latest stable version 2.8.0-dev.17.0 / was released on March 24, 2020.Let’s look the first interview of Lars Bak and Kasper Lund after the announcement of dart at Devoxx 2013.

(https://www.youtube.com/watch?v=iKhxgcR1GZg).

It has many of the same statements and expressions as C, Java, JavaScript and other languages.Dart is so simple and handy because it is equipped with features like string interpolation to initialize formals, to developers you express your intent more simply and easily.

If there are multiple ways to say something, you should generally pick the most to the point and meaningful logic. The dart’s main objective is making code that is economical, not dense due to this Dart analyzer has always been ready to help you write good, consistent code…

Using a dart we can also develop an IoT hub for edge hardware as many types of protocols can be connected to various cloud services with data flows,it contributes in many IoT simulators and architecture development tools.

So isn’t it soo astonishing!

If you found this programming workable to you,If you found this programming workable to you,Let’s start with the introduction of DartPad.

Drt Pad is an online code editor for the Dart language(https://dartpad.dev/)

In addition to executing regular Dart programs, it can run Flutter programs and show graphic output. DartPad enables learners to engage with the content without having to set up a development environment. The following screenshot shows DartPad.

1. Tabs: Dart, Solution(hidden) & Tests (hidden)

2. Code pane

3. Tutorial codes

4. Format: Runs the code formatter (dartfmt)

5. Reset: Erases your work and restores the editor to its original state

6. Run

7. Output: Console, UI output

8. Analyzer: Instantly checks the code

I am learning Dart because of Flutter,as Dart is the backend programming language of Flutter by which we can develop the user interface(UI Designing) of applications. So,may be in next blog we could see about introduction of Flutter.

[bathouseofnews]

Tensorflow, deep learning and modern convolutional neural nets, without a PhD by Martin Görner The hottest topic in computer science today is machine learning and deep neural networks. Many problems deemed "impossible" only 5 years ago have now been solved by deep learning: playing GO,... source

[hacklo5]

Veille de la semaine #45 [2017]

Veille de la semaine #45 [2017]

Cette semaine, un petit condensé de ressources pour créer des PWA (Progressive Web Apps). Il y a aussi plusieurs vidéos de conférences intéressantes, issues notamment du Devoxx Belgique et du BDX I/O. Bonne lecture !

Progressive Web Apps

Progressive Web App Checklist Google

Your first PWA Google

Les PWA : une révolution pour le web mobile ?

Bien comprendre les PWA

Intro to PWA Udacity

Clap de…

[visualstudiocodetutorial]

RT @brunoborges: At #SpringOne we announced that VS @code was soon going to have #IntelliCode support for #Java. ML-powered recommendations. Well, here it is folks! #Devoxx // @delabassee @burrsutter https://t.co/QQnfoBMC2V https://t.co/CxwTdfP2ir

[d3v4w3b]

Dynamic Web Apps Without JavaScript - HTMX Showcase at DjangoCon and Devoxx

[taysaynews]

Nantes startups meet developers at Devoxx

Nantes startups meet developers at Devoxx

Devoxx France is a reference event for technology and innovation professionals. Dedicated mainly to developers, each year it brings together more than 3,000 professionals from the sector. For its tenth edition, which will take place from April 20 to 22 at the Palais des Congrès in Paris, you can count on the arrival of the collective A job in Nantes #Tech. For the first time in the history of…

[this-week-in-rust]

This Week in Rust 548

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Faster linking times on nightly on Linux using rust-lld

Foundation

Announcing the First Set of RustConf 2024 Talks & Keynotes

Unsafe Rust in the Wild: Notes on the Current State of Unsafe Rust

Project/Tooling Updates

100 Exercises To Learn Rust

RustRover Is Released and Includes a Free Non-Commercial Option

Mysqlclient-sys 0.3.0: Bundled builds and updated bindings

Ratatui 0.26.3 is released! - a Rust library for cooking up terminal user interfaces

Maelstrom v0.9.0: Added local-only tests, LPT scheduling, and more

r3bl_terminal_async v0.5.3 released

Observations/Thoughts

Some notes on Rust, mutable aliasing and formal verification

Towards fast thread_local! context

Rust's iterators optimize nicely—and contain a footgun

Why We Forked Quinn

[audio] AMP - Rust in Production Podcast

[audio] Rama with Glen De Cauwsemaecker

[video] What's New in Rust 1.72-1.78 Rustacean Station marathon

[video] Rust 1.78.0: Last Rust News Video...ever?

[video] Devoxx UK - Rust 101: Understand the Hype

Rust Walkthroughs

Using Rust Macros for Custom VTables

NULL BITMAP Builds a Database #1: The Log is Literally the Database

The rainbow bridge between sync and async Rust

developerlife.com - Effective async Rust, non-blocking, concurrent, parallel, event loops, cancellation safety

Let's build a Load Balancer in Rust - Part 2

Miscellaneous

Free Rust ebooks for Amazon Kindle

Crate of the Week

This week's crate is ralertsinua, a text user interface for getting information about Russian air raids in Ukraine.

Thanks to Vladyslav Batyrenko for the suggestion!

Please submit your suggestions and votes for next week!

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

RFCs

No calls for testing were issued this week.

Rust

No calls for testing were issued this week.

Rustup

No calls for testing were issued this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

* [hyperswitch - [FEATURE] : add pagination support for customers list] (https://github.com/juspay/hyperswitch/issues/3746) * [hyperswitch - [FEATURE] : [GlobalPayments] Currency Unit Conversion] (https://github.com/juspay/hyperswitch/issues/2227) * [hyperswitch - [FEATURE] : Add support for sending additional metadata in the MessagingInterface] (https://github.com/juspay/hyperswitch/issues/4472)

If you are a Rust project owner and are looking for contributors, please submit tasks here.

CFP - Speakers

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

Rust Argentina June 2024 | Closes 2024-05-31 | Buenos Aires, AR | Event date: 2024-06-04

EuroRust 2024 | Closes 2024-06-03 | Vienna, Austria & online | Event date: 2024-10-10

Scientific Computing in Rust 2024 | Closes 2024-06-14 | online | Event date: 2024-07-17 - 2024-07-19

Rust Ukraine 2024 | Closes 2024-07-06 | Online + Ukraine, Kyiv | Event date: 2024-07-27

Conf42 Rustlang 2024 | Closes 2024-07-22 | online | Event date: 2024-08-22

If you are an event organizer hoping to expand the reach of your event, please submit a link to the submission website through a PR to TWiR.

Updates from the Rust Project

364 pull requests were merged in the last week

add x86_64-unknown-linux-none target

enable rust-lld on nightly x86_64-unknown-linux-gnu

rustc_hir_typeck: Account for skipped_ref_pats in expr_use_visitor

rustc_resolve cleanups

actually use the #[do_not_recommend] attribute if present

add #[inline] to float Debug fallback used by cfg(no_fp_fmt_parse)

add fn into_raw_with_allocator to Rc/Arc/Weak

add an experimental feature gate for global registration

add and use generics.is_empty() and generics.is_own_empty, rather than using generics' attributes

also expand weak alias tys inside consts inside expand_weak_alias_tys

android: use posix_memalign for aligned allocations

avoid using aligned_alloc; posix_memalign is better-behaved

check whether the next_node is else-less if in get_return_block

coverage: CoverageIdsInfo::mcdc_bitmap_bytes is never needed

coverage: memoize and simplify counter expressions

defrost RUST_MIN_STACK=ice rustc hello.rs

delegation: implement list delegation

don't ICE because recomputing overflow goals during find_best_leaf_obligation causes inference side-effects

don't do post-method-probe error reporting steps if we're in a suggestion

fix ICE in non-operand aggregate_raw_ptr intrinsic codegen

fix println! ICE when parsing percent prefix number

fix suggestion in E0373 for !Unpin coroutines

fix the dedup error because of spans from suggestion

improve error message: missing ; in macro_rules

include line tables in compiler profile

lldb-formatters: use StdSliceSyntheticProvider for &str

make EvalCtxt generic over InferCtxtLike

make crashes dump mir to build dir

never type unsafe lint improvements

note for E0599 if shadowed bindings has the method

only find segs chain for missing methods when no available candidates

only make GAT ambiguous in match_projection_projections considering shallow resolvability

refactor: add rustc-perf submodule to src/tools

report better WF obligation leaf obligations in new solver

style-guide: when breaking binops handle multi-line first operand better

suggest setting lifetime in borrowck error involving types with elided lifetimes

temporarily revert to NonZeroUsize in rustc-abi to fix building on stable

track cycle participants per root

use a proper probe for shadowing impl

use a single static for all default slice Arcs

warn against changes in opaque lifetime captures in 2024

miri: adjust Allocation Bytes used by Miri to custom MiriAllocBytes

miri: directly implement native exception raise methods in miri

miri: give FileDescription::{read, write} access to the MiriInterpCx

miri: ignore the Helix configuration directory

miri: make basic things work on Android

miri: properly print error in 'cargo miri setup --print-sysroot'

miri: support aligned_alloc for unixes

miri: use throw_unsup_format! instead of returning ENOTSUP in the mmap shim

miri: use a little arg-parsing helper for miri-script

remove libc from MSVC targets

optimize character escaping

alloc: implement FromIterator for Box<str>

implemented Default for Arc<str>

fix read_exact and read_buf_exact for &[u8] and io:Cursor

fix assertion when attempting to convert f16 and f128 with as

inline Duration construction into Duration::from_{secs, millis, micros, nanos}

remove bound checks from BorrowedBuf and BorrowedCursor methods

optimize inplace collection of Vec

make Debug impl for Term simpler

invert comparison in uN::checked_sub

add f128 float to integer conversion functions

add addition, subtraction, multiplication, and compare operations for f128

add powi fo f16 and f128

add v0 symbol mangling for f16 and f128

re-add From<f16> for f64

cargo: add special check-cfg lint config for the unexpected_cfgs lint

cargo: fix warning about unused Permissions

cargo: fix warning output in build_with_symlink_to_path_dependency_with_build_script_in_git

cargo: fix: make path dependencies with the same name stays locked

cargo: fix: support IPv6-only network for cargo fix

cargo: load libsecret by its SONAME, libsecret-1.so.0

cargo: preserve file permissions on unix during write_atomic

cargo: silence warnings running embedded unittests

rustdoc: don't strip items with inherited visibility in AliasedNonLocalStripper

rustdoc: negative impls are not notable

add - (stdin) support in rustdoc

clippy: assigning_clones: move to pedantic so it is allow by default

clippy: doc_lazy_continuation: do not warn on End events

clippy: add configuration option for ignoring panic!() in tests

clippy: don't lint path statements in no_effect

clippy: don't lint missing_panic_docs for panics in const environments

clippy: improve match_same_arms messages, enable rustfix test

clippy: less aggressive needless_borrows_for_generic_args

clippy: make sure the msrv for const_raw_ptr_deref is met when linting missing_const_for_fn

clippy: manually set library paths in .github/driver.sh

rust-analyzer: fix metrics workflow not actually updating the toolchain

rust-analyzer: fix: don't emit --keep-going for custom build script commands

rust-analyzer: fix: expand macro recursively expands both fp-like and attribute macros when intertwined

rust-analyzer: fix: extract mod to file should respect path attribute

rust-analyzer: fix: hash file contents to verify whether file actually changed

Rust Compiler Performance Triage

Fairly quiet week with the exception of a very large improvement coming from the switch to rust-lld on nightly Linux. This can have very large impacts on benchmarks where linking dominates the build time (e.g., ripgrep, exa, small binaries like hello-world). Aside from that change, there were a few small regressions that were either deemed worth it or are still being investigated.

Triage done by @rylev. Revision range: 9105c57b..1d0e4afd

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 0.7% [0.1%, 2.5%] 30 Regressions ❌ (secondary) 0.5% [0.2%, 0.8%] 5 Improvements ✅ (primary) -30.4% [-71.7%, -0.4%] 35 Improvements ✅ (secondary) -25.6% [-70.9%, -0.5%] 75 All ❌✅ (primary) -16.1% [-71.7%, 2.5%] 65

4 Regressions, 1 Improvement, 4 Mixed; 2 of them in rollups 66 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

MaybeDangling

RFC: New range types for Edition 2024

Merge RFC 3484: Unsafe extern blocks

RFC: cargo-script

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

No RFCs entered Final Comment Period this week.

Tracking Issues & PRs

Rust

[disposition: merge] change method resolution to constrain hidden types instead of rejecting method candidates

[disposition: merge] Tracking Issue for asm_const

[disposition: merge] rustdoc: Add support for --remap-path-prefix

[disposition: merge] Make std::env::{set_var, remove_var} unsafe in edition 2024

[disposition: merge] Tracking Issue for slice_flatten

[disposition: merge] Edition 2024: Make ! fall back to !

[disposition: merge] Stabilize div_duration

[disposition: merge] Panic if PathBuf::set_extension would add a path separator

[disposition: merge] Support C23's Variadics Without a Named Parameter

[disposition: merge] Stabilize LazyCell and LazyLock

[disposition: merge] Turn remaining non-structural-const-in-pattern lints into hard errors

[disposition: merge] Edition 2024: don't special-case diverging blocks

Cargo

No Cargo Tracking Issues or PRs entered Final Comment Period this week.

Language Team

No Language Team RFCs entered Final Comment Period this week.

Language Reference

[disposition: merge] document guarantee about evaluation of associated consts and const blocks

Unsafe Code Guidelines

No Unsafe Code Guideline RFCs entered Final Comment Period this week.

New and Updated RFCs

[new] [RFC] Add #[export_ordinal(n)] attribute

[new] [RFC] Add #[diagnostic::blocking] attribute

[new] Guard Patterns

Upcoming Events

Rusty Events between 2024-05-22 - 2024-06-19 🦀

Virtual

2024-05-23 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-05-23 | Virtual (Israel) | Rust in Israel

Web development in Rust using Rocket (Hebrew)

2024-05-24 | Virtual (Rotterdam, NL)| Bevy Game Development

Bevy Meetup #4

2024-05-28 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-05-28 & 2024-05-28 | Virtual | Mainmatter

Remote Workshop: Telemetry for Rust APIs – you can't fix what you can't see (fee)

2024-05-29 | Virtual | Training 4 Programmers LLC

Enums, Structs, and Traits - Essential Building Blocks of Rust Programming

2024-05-30 | Virtual + In Person (Barcelona, ES) | Mainmatter & BcnRust

Rust for the web, Barcelona 2024

2024-05-30 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-06-04 | Virtual | Women in Rust

Lunch & Learn: A Creative Thinker's Programming Language

2024-06-04 | Virtual (Buffalo, NY) | Buffalo Rust Meetup

Buffalo Rust User Group

2024-06-05 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-06-06 | Virtual | Code Mavens

Rust Maven Workshop: Your first contribution to an Open Source Rust project

2024-06-06 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-06-11 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2024-06-13 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-06-13 | Virtual (Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online

2024-06-18 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2024-06-19 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

Africa

2024-06-01 | Kampala, UG | Rust Circle Kampala

Rust Circle Meetup

Asia

2024-05-22 | Singapore, SG | SG Rust Meetup

SG Rustaceans! Updated - SG Rust Meetup at CraftsforGreen Whole Studio

Europe

2024-05-22 | Leiden, NL | Future-proof Software Development by FreshMinds

Coding Dojo Session

2024-05-23 | Bern, CH | Rust Bern

2024 Rust Talks Bern #2

2024-05-23 | Łodz, PL | Mobica

Zapisz się na warsztat Rust / Embedded w Łodzi! / What's all the fuss about Rust?

2024-05-23 | Manchester, UK | Rust Manchester

Rust Manchester May Code Night

2024-05-23 | Salzburg, AT | SRUG: Salzburg Rust User Group

SRUG: Salzburg Rust User Group

2024-05-24 | Bordeaux, FR | Rust Bordeaux

Rust Bordeaux #3: Discussions

2024-05-25 | Stockholm, SE | Stockholm Rust

Ferris' Fika Forum #3 [Embedded lab edition]

2024-05-25 | Tampere, FI | Finland Rust-lang Group

May Meetup

2024-05-28 - 2024-05-30 | Berlin, DE | Oxidize

Oxidize Conf 2024

2024-05-30 | Amsterdam, NL | Rust Developers Amsterdam Group

Rust Developer Meetup @ Avalor AI

2024-05-30 | Barcelona, ES | Mainmatter & BcnRust

Rust for the web, Barcelona 2024

2024-05-30 | Berlin, DE | Rust Berlin

Rust and Tell - Title

2024-05-30 | Copenhagen, DK | Copenhagen Rust Community

Rust meetup #47 sponsored by Microsoft!

2024-05-30 | Oslo, NO | Rust Oslo

Rust Hack'n'Learn at Kampen Bistro

2024-05-30 | Vienna, AT | Rust Vienna

Rust Vienna Meetup - May - Rust Backend 101

2024-06-05 | Hamburg, DE | Rust Meetup Hamburg

Rust Hack & Learn June 2024

2025-06-06 | Vilnius, LT | Rust Vilnius

Enjoy our second Rust and ZIG event

2024-06-19 - 2024-06-24 | Zürich, CH | RustFest Zürich

RustFest Zürich 2024

North America

2024-05-22 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2024-05-25 | Chicago, IL, US | Deep Dish Rust

Rust Talk Double Feature

2024-05-30 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-05-31 | Boston, MA, US | Boston Rust Meetup

Boston Common Rust Lunch, May 31

2024-06-08 | Somerville, MA, US | Boston Rust Meetup

Porter Square Rust Lunch, Jun 8

2024-06-13 | Spokane, WA, US | Spokane Rust

Monthly Meetup: Topic TBD!

2024-06-18 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

Oceania

2024-05-28 | Sydney, NSW, AU | Rust Sydney

a demo 🤯 & a lightning ⚡show ✨

South America

2024-06-06 | Buenos Aires, AR | Rust en Español | Rust Argentina

Juntada de Junio

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

In other words, I do not want the compiler to just insert code to uphold the bare minimum guarantees, I want the compiler to check my work for me and assist me in developing an algorithm I can confidently assert is right.

– without boats

Thanks to scottmcm for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[reportwire]

Devoxx UK 2022: Designing Your Best Architecture Diagrams

Devoxx UK 2022: Designing Your Best Architecture Diagrams

As mentioned previously, I’ve pushed a few talks to the Devoxx UK 2022 conference being held May 11-13 in London. The Devoxx series is well known, and I’ve attended and spoken at multiple sessions for the Belgian version in the past. It’s very developer-centric with a lot of good depth and knowledgeable attendees.  The selection committee decided that the workshop I submitted would fit their…

[daianymargarita]

Why not trying a quickie?

Quickies are underestimated, in my opinion. I’ve tried them a couple of times and it was really cool. Ways better than people would think. I really enjoyed each time!

Of course I am talking about quick presentations, lightning talks. What else? :P

Without really intending to, I believe I am becoming an ignite speaker. Because I’ve managed to present 3 times in that format in the past months and I’ve discovered I like it a lot. Here are the three main reasons why:

It forces me to stay concise and say more with less: which is not a piece of cake. It’s a real challenge and of course it depends on the topic choice. Although I do believe that any topic can be well presented in 5 minutes, it is true that some are more difficult than others to compact like that. Even bigger is the challenge to put up an interesting presentation with such a time constraint. But I gladly take that challenge because it trains my ability of cutting the crap and going straight to the point.

It’s easier to rehearse until the talk is completely dominated: for the simple reason that it takes only 5 min. I’ve given 30-min talks before and I could practice only a couple of times, with lots of effort to find the moment for it. And something that gives me a lot of self-confidence when performing on stage is having practiced my speech enough so I feel totally comfortable with it. With this I don’t mean memorizing every word, of course, that’s a very wrong thing to do. I mean feeling confident that I know the speech structure well and the key points of the presentation, with the main message I want to deliver.  

When recorded, the talk is more likely to be watched when shared: because it’s easier for people to find 5 minutes time to watch, while going in the bus or underground on the way to work for example. Hence, there are higher chances to reach out to more people and maybe get some/more feedback. Which is always good!

Since I kind of enjoy getting on stage to tell people stories, I follow quite some number of tech conferences on twitter to keep an eye on speaking opportunities. On the other hand, since I discovered that I like quick presentations, I couldn’t help noticing that only a minority of events offer this format. And when a conference offers it, the number of slots is incredibly small in comparison to normal-length talks. Take a look at these two examples:

1. Devoxx Belgium

2. Devoxx Morocco

Those images were published in twitter by each conference respectively. By the time I am writing this post, the CfP for the Belgium edition was already closed, so the numbers on the image are final. But the CfP for the Morocco edition is still open for a week. In any case, it’s easy to see how underrepresented the quickies are. 

Of course not every event is suitable for quick formats, mostly due to the target audience. Personally I like a good mixture of presentation formats in a conference, because I think it makes it more interesting. I just would like that the available slots for quick formats were more. I believe it would also stimulate more speakers who never did it before to dare and try it out, which in turn would make the formats more popular and hopefully more enjoyable/demanded by the audiences.

Speakers don’t seem to like quickies much...

I suspected it before, but I definitely confirmed it when I volunteered as a reviewer for the last CfP of the DevOpsDays London. When I read their tweet asking for volunteers I decided to give it a try, so I could get a first-hand impression of the submissions of such a successful community conference, to better estimate my future chances should I decide to submit something next year (this year I couldn’t). They have a really cool and exemplary anonymising process for their proposals reviews, by the way. 

The DevOpsDays conferences have the particularity that (usually) the number of available speaking slots for 30-min talks and ignite talks are the same. This is something I haven’t seen in any other tech conference so far. And I like it!

But, for the DevOpsDays London for example there were around 120 submissions for full length talks and only around 13 for ignites. So, speakers don’t seem to like ignites much, uh?

That’s a shame, in my opinion. 

Speakers out there, why not trying a quickie? Come on, you might like it! :-)

[bythebayio]

Adam Warski: “Writing down the main problems, challenges, use-cases helps to design the right abstractions.”

Adam Warski is one of the co-founders of SoftwareMill, where he codes mainly using Scala and other interesting technologies. He is involved in open-source projects, such as sttp, tapir, Quicklens, ElasticMQ and others. He has been a speaker at major conferences, such as JavaOne, LambdaConf, Devoxx and ScalaDays. Apart from writing closed- and open-source software, in his free time he tries to read the Internet on various (functional) programming-related subjects. Any ideas or insights usually end up with a blog.

What are the highlights of your software engineering career? How did you get into your current area, and what's the most interesting thing about it for you? What made you especially prepared for your work?

The highlight of my career is definitely being part of SoftwareMill, and as that is still unfolding, I expect the most exciting parts might be still ahead! We've been evolving the company for the last 11 years, starting with no business knowledge and not long after finishing university, so as you might expect we've made a couple of mistakes and learned a lot along the way.

On the technical side, we've evolved from JEE/JBoss-focused software consultancy towards being oriented on Scala (with some "modern" Java as well), functional programming, distributed systems and ML. That's a big jump, and making that jump consciously - that is, understanding *why* a given technology or programming style is "better" - takes quite a lot of work. But also serves as great material for blogs or conference talks!

A key theme that unites the best SBTB talks is Thoughtful Programming. Can you describe some situations where you stepped back and rethought your approach? Where you needed better or higher abstractions? How do the choices of technology help you being thoughtful?

Programming styles vary from person to person, so I think this might be a matter of personal preference, but given any non-trivial task I always like to layout the approach using (analogue) pen & paper. Writing down the main problems, challenges, use-cases helps to design the right abstractions. Of course, most of the time unforeseen problems arise when half-way implementing the designed solution, which means going back to the drawing board.

I think the work we're doing on sttp client is a good case study. In itself, sttp client wraps "lower-level" HTTP clients with a programmer-friendly (and that's the emphasis of the project) API. So all of the hard work is delegated to other libraries, such as akka-http, async-http-client or Java's HttpClient. Still, it turns out that even such a not-very-complicated problem as sending HTTP requests isn't that trivial to model. Since we are working on version 3 right now, that means at least 2 major "step backs" rethinking some of the design basics (and causing major, backwards-incompatible changes).

Libraries are in a somewhat special position when it comes to thoughtful programming, as they need to serve a wide range of use-cases. And even simple things - or things that *should* be simple - need a lot of thought, so that they don't end up unnecessarily complex or surprising for the audience: the programmers using the API.

How do tools and devops infrastructure affect your life day to day? How do you see developers and operators (devops) working together in the future? What needs to be done to improve it on your end?

I think I'll need to build a better tolerance towards YAML, and they'll need to build better tolerance towards programming languages. There's a lot of research and practice that went into programming language development, and it's painful to see all of it be discarded with forcibly using and abusing YAML for everything.

That said, I do understand the appeal of YAML's perceived simplicity, declarativness and (to some degree) readability. But I'd hope that at some point it becomes obvious that we need some means of abstraction. I'd go with functional programming of course, but I'm open to being persuaded otherwise as well. There's definitely room for improvement and finding middle ground here.

"Cloud-Native" computing as it first emerged is operator-centric. It's getting easier to run the clouds themselves. Does it get easier for developers to build apps on top of these new clouds? What kind of abstractions are needed to develop the Cloud-Native Applications of tomorrow?

I think that especially the Kubernetes ecosystem is great in its capabilities and flexibility for really large deployments and large organizations, where there's a good business reason for the operational costs of this platform, and where it makes sense to have a DevOps team taking care of the K8S installation.

On the other end of the spectrum, the needs for small-scale applications are also quite well met with solutions such as Heroku, Netlify or simply AWS.

However, the needs for medium-sized projects, where it already makes sense to develop multiple microservices (or "midiservices"), is not yet well served. These are projects which will have a couple of microservices, but not hundreds; where it's beneficial to use a service mesh, but the DevOps team is small. There are some new projects which try to address this niche, but I think there's no clear leader yet.

What are some of the ways we can make the best lemonade out of the lemons of online-only setup this year? How do you plan to make the best of it?

That's a good question! I don't know. We've been organizing an online conference this year as well, and it is a challenge. Even being a stereotypical programmer-caveman, I do appreciate the networking opportunities that conferences gave us. The talks are easy to move into the virtual space, but the hallway is much more problematic. But we've got to try to make the best out of it.

What are some other talks that you're eager to see at SBTB, and which ones look like good companions for yours?

There's quite a lot that seem interesting, so as always it's not an easy pick. For sure, I'll listen to the Twitter talks (how their API got redesigned, and ML using Scala 3), as Twitter is both an early Scala adopter, and if anybody, they do have a lot of traffic to handle. So this should be interesting even taking into account only the distributed systems aspect.

I also saw some Rust talks, which I'd like to learn more about, but have never put enough time to see if it's a good fit for functional programming. Finally, there are some talks about GraphQL, TypeScript, Haskell and smart contracts - it's always good to be up-to-date as to what's happening outside your bubble.

Do not miss Adam Warski and his "Project Loom? Better Futures? What’s next for JVM concurrent programming" at Scale By the Bay on November 12. Tickets are available so book yours now.