Moving to a different executor

[rylev]

Brief summary

We have a few stories which highlight the fact that choosing a runtime upfront can be quite expensive. However, we don't yet have a story about a mature application which has been built around a certain executor, deciding to make the switch to another.

This is because as things stand today, executors are usually bundled with runtimes that offer more than just a backing executor but also many convenience APIs that work only with that executor. Combined with the fact that most libraries are not runtime agnostic, this can really tie an application to a specific runtime.

I think the story would likely take the form of a character having written a service for work using an off-the-shelf runtime like tokio. This works great for many years, but then as requirements change and the team behind the application has more and more specific needs, they decide that it would be best if they have their own executor. They then realize what a daunting task this would be as their entire application makes subtle and not-so-subtle assumptions that they are running on a specific executor.

This is in many ways the mirror opposite of #45.

Optional details

• (Optional) Which character(s) would be the best fit and why?
  • Alan: the experienced "GC'd language" developer, new to Rust
  • Grace: the systems programming expert, new to Rust
  • Niklaus: new programmer from an unconventional background
  • Barbara: the experienced Rust developer
    • The problem here is not one that comes from making uninformed decisions. If Barbara had a crystal ball, she maybe could have done more work to make switching executors easier, but tokio was a really great choice for a very long time. Unforeseen changes in requirements have caused the building need to switch to a bespoke executor and the ecosystem makes this hard to actually do.
• What are the key points or morals to emphasize?
  • Switching executors is hard because executors are almost always bundled with rich runtimes that provide convenient APIs that ties applications to the runtime.