1. Welcome
  2. Charter
  3. Meetings
    ❱
    1. Discussion schedule
    2. Triage
  5. The vision
    ❱
    1. ❓How to vision
      ❱
      1. Owning a goal or initiative
      2. Being a stakeholder
      3. Writing an evaluation
      4. Authoring "Status quo" stories
      5. Authoring "Shiny future" stories
      6. Commenting on stories
      7. Awards
    3. 🥰 How using async Rust ought to feel
    4. 🙋‍♀️ Cast of characters
      ❱
      1. Alan
      2. Grace
      3. Niklaus
      4. Barbara
    6. ⚡ Projects
      ❱
      1. Template
      2. MonsterMesh (embedded sensors)
      3. DistriData (Generic Infrastructure)
      4. TrafficMonitor (Custom Infrastructure)
      5. YouBuy (Traditional Server Application)
      6. SLOW (Protocol implementation)
    8. 😱 Status quo
    9. ✨ Shiny future
      ❱
      1. 📚 User's manual of the future
    11. 📅 Roadmap
      ❱
      1. Async fn everywhere
        ❱
        1. Boxable async fn
        2. Async main and tests
      3. Scoped spawn and reliable cancellation
        ❱
        1. Capability
          ❱
          1. Variant: Async trait
          2. Variant: Leak trait
        3. Scope API
      5. Async iteration
        ❱
        1. Traits
        2. Generators
      7. Portable and interoperable
        ❱
        1. Read/write traits
        2. Timers
        3. Spawn
        4. Runtime
      9. Polish
        ❱
        1. must_not_suspend lint
        2. Lint blocking fns
        3. Lint large copies
        4. Error messages for the most confusing scenarios
        5. Stacktraces
        6. Precise Generator Captures
        7. Sync and async behave the same
      11. Tooling
        ❱
        1. Crashdump
      13. Testing
      14. Documentation
        ❱
        1. Async book
      16. Threadsafe portability
      17. Async overloading
    13. ❓ Major unresolved questions or controversies
      ❱
      1. Default runtime?
      2. How to represent the AsyncFn traits?
      3. How best to integrate voluntary cancellation?
      4. Extend stdlib to permit portable async without generics?
      5. To await or not to await?
    15. 💝 Appendix: Submitted stories
      ❱
      1. 😱 Status quo
        ❱
        1. Template
        2. Alan builds a task scheduler
        3. Alan creates a hanging alarm
        4. Alan finds dropping database handles is hard
        5. Alan has an external event loop
        6. Alan hates writing a Stream
        7. Alan iteratively regresses performance
        8. Alan lost the world
        9. Alan misses C# async
        10. Alan needs async in traits
        11. Alan runs into stack trouble
        12. Alan started trusting the Rust compiler, but then... async
        13. Alan thinks he needs async locks
        14. Alan tries using a socket Sink
        15. Alan tries to debug a hang
        16. Alan tries to cache requests, which doesn't always happen
        17. Alan tries tries processing some files
        18. Alan wants a prefetch iterator
        19. Alan wants to migrate a web server to Rust
        20. Alan writes a web framework
        21. Alan extends an AWS service
          ❱
          1. Writing a Java-based service at AWS
          2. Getting started with Rust
          3. Coming from Java
          4. Exploring the ecosystem
          5. Juggling error handling
          6. Failure to parallelize
          7. Borrow check errors
          8. Solving a deadlock
          9. Encoutering pin
          10. Figuring out the best option
          11. Testing his service
          12. Using the debugger
          13. Missed Waker leads to lost performance
          14. Debugging performance problems
          15. Getting ready to deply
          16. Using JNI
        23. Barbara anguishes over HTTP
        24. Barbara awants single threaded optimizations
        25. Barbara battles buffered streams
        26. Barbara begets backpressure and benchmarks async_trait
        27. Barbara bridges sync and async in perf.rust-lang.org
        28. Barbara builds an async executor
        29. Barbara carefully dismisses embedded Future
        30. Barbara compares some C++ code
        31. Barbara gets burned by select
        32. Barbara makes their first foray into async
        33. Barbara needs Async Helpers
        34. Barbara plays with async
        35. Barbara polls a Mutex
        36. Barbara tries async streams
        37. Barbara tries Unix socket
        38. Barbara trims a stacktrace
        39. Barbara wants async insights
        40. Barbara wants to use GhostCell-like cell borrowing
        41. Barbara wishes for an easy runtim switch
        42. Barbara writes a runtime-agnostic library
        43. Grace debugs a crash dump
        44. Grace deploys her service and hits obstacles
        45. Grace tries new libraries
        46. Grace waits for gdb next
        47. Grace wants a zero copy API
        48. Grace wants to integrate a C-API
        49. Grace writes a new Facebook service
        50. Niklaus builds a hydrodynamics simulator
        51. Niklaus wants to share knowledge
      3. ✨ Shiny future
        ❱
        1. Template
        2. Alan learns async on his own
        3. Alan's trust in the compiler is rewarded
        4. Alan switches runtimes
        5. Barbara appreciates great performance analysis tools
        6. Barbara enjoys an async sandwich
        7. Barbara makes a wish
        8. Barbara wants async read write
        9. Barbara wants async tracing
        10. Grace debugs a crash dump again
  7. Design docs
    ❱
    1. ⚠️ Yield-safe lint
    2. ☔ Stream trait
    3. ⚡ Generator syntax
    4. 📝 AsyncRead, AsyncWrite traits
    5. 🧬 Async fn in traits
    6. 🔒 Mutex (future-aware)
    7. 📺 Async aware channels
    8. 📦 Async closures
    9. 🤝 Join combinator
    10. 🤷‍♀️ Select combinator
    11. 🚰 Sink trait
    12. 🎇 Async main
    13. 🗑️ Async drop
      ❱
      1. ♻️ Async lifecycle
    15. ⏳ Completion-based futures
    16. 🥞 Async Stack Traces
  9. Conversations
    ❱
    1. 2021-02-12 Twitter thread
  11. Glossary
  12. Acknowledgments