async-std

@asyncrs

The twitter account of the project.

In your cores
Joined August 2019

Tweets

You blocked @asyncrs

Are you sure you want to view these Tweets? Viewing Tweets won't unblock @asyncrs

  1. Retweeted
    Jan 29

    Next little step towards Dat in achieved: A working Noise handshake between Rust and Node! Also, my exploration into how modern crypto works & a nice example of how simple is. Code here:

    Undo
  2. Retweeted
    Jan 24

    First blog post on writing your own async executors in Rust. Here's how to implement block_on() in a few lines of safe code.

    Undo
  3. Retweeted
    Jan 21

    Decided to write a basic TCP proxy using and this weekend as an excuse to play with async/.await. Here’s the link so people can send me some feedback on how to make it better!

    Undo
  4. Retweeted

    Currently, giving an explainer session on how `Pin` works on the YT channel. Now with correct URL, thanks to .

    Undo
  5. Jan 14

    Tiny update in the background: our task allocation library, `async-task`, is now a `no_std` library, allowing it to be used in more contexts.

    Undo
  6. Retweeted
    Jan 6
    Show this thread
    Undo
  7. Retweeted

    Just published async-tar@0.1.0, for all your tar needs. All based on the great work in

    Undo
  8. 24 Dec 2019

    Woooo! We're over 50000 downloads and counting!

    52.521 downloads on crates.io
    Undo
  9. Retweeted
    23 Dec 2019

    New post: Streams Concurrency In this post we talk about concurrency, apply it to streams, and explore future directions. Illustrated by .

    A graph representing the fan-out / fan-in pattern. Elegant black spheres on a white background, tied together by thin lines.
    Show this thread
    Undo
  10. Retweeted
    22 Dec 2019

    So excited to have released my first crate this morning! The goal of the crate was to add additional functionality to the async BufReader implementation provided by the async-std lib . Here it is! crate: github:

    Undo
  11. 20 Dec 2019

    async-std v1.4.0 has been released! ⬩ Future::timeout ⬩ Documentation fixes ⬩ io::Bytes ⬩ io::Chain ⬩ io::Take Changelog:

    use async_std::prelude::*; use async_std::future; use std::time::Duration;  let fut = future::pending::<()>(); // This future will never resolve. let res = fut.timeout(Duration::from_millis(100)).await; assert!(res.is_err()); // The future timed out, returning an err.
    Undo
  12. Retweeted

    This is really cool!! Some thoughts follow

    Show this thread
    Undo
  13. 18 Dec 2019
    Undo
  14. Retweeted
    16 Dec 2019

    "The new runtime enables you to fearlessly use synchronous libraries like diesel or rayon in any async-std application." It's like the team is speaking right to my heart ! <3

    Show this thread
    Undo
  15. 16 Dec 2019

    So, how about speed? The new runtime is faster over 1.3.0, especially scaling much better. How do you use it? Just try out our current PR branch, instructions are in the blog post. async-std is fully compatible to futures-rs, for your ease!

    Show this thread
    Undo
  16. 16 Dec 2019

    The new runtime also allows you to use mature sync libraries like without fear! No need to manage a secondary threadpool for blocking tasks! On top of that, the new runtime is also much better at scaling down, effectively becoming single-threaded if possible.

    Show this thread
    Undo
  17. 16 Dec 2019

    Don't let anyone block you! We're introducing a new adaptive, -inspired, async runtime that automatically detects blocking behaviour and just continues to run and run. Don't worry about separate blocking and non-blocking tasks anymore!

    Show this thread
    Undo
  18. 16 Dec 2019

    We're very happy about the new gtk-rs release! Especially about the new futures executor based on gio! Here's an example on how to integrate our runtime independent async-tls library into it!

    Undo
  19. 13 Dec 2019

    async-std v1.3.0 has been released! ⬩ Stream::delay ⬩ Faster compilation ⬩ DoubleEndedStream::rfind ⬩ DoubleEndedStream::nth_back ⬩ DoubleEndedStream::rfold ⬩ Documentation fixes Changelog:

    let start = Instant::now(); let mut s = stream::from_iter(vec![0u8, 1]).delay(Duration::from_millis(200));  // The first time will take more than 200ms due to delay. s.next().await; assert!(start.elapsed().as_millis() >= 200);  // There will be no delay after the first time. s.next().await; assert!(start.elapsed().as_millis() <= 210);
    Undo
  20. 5 Dec 2019

    Wooooo! We're over 30000 downloads and counting!

    Undo

Loading seems to be taking a while.

Twitter may be over capacity or experiencing a momentary hiccup. Try again or visit Twitter Status for more information.

    You may also like

    ·