Top all-time · #813
Without boats, dreams dry up
Personal blog · without.boatsprogramming
Without boats, dreams dry up is a personal blog at without.boats about programming. Since 2020, 81 different Hacker News readers have linked it 148 times, most often “Revisiting a 'Smaller Rust'”. The last post was in 2024, but the archive is still widely read.
Sometimes recommended · 6 of 40 sampled comments recommend it?
Why HN links it
HN readers link without.boats for its Rust writing on async, io-uring, ownership and a "smaller Rust" design. Commenters cite it as the reference on these topics.
- Recommended for · 6 comments
- Commenters call one post a favourite piece of writing and say the smaller-Rust, registers and io-uring posts are worth reading.
Summarised by Claude from a sample of 40 HN comments that link here. Each comment is marked recommending, critical or neutral (citing without judging); how this works.
Most-linked posts?
- Revisiting a 'Smaller Rust'15 people · 17 mentions · first linked 2020-09-30
- Why Async Rust? (2023)10 people · 14 mentions · first linked 2023-10-15
- Notes on a Smaller Rust (2019)10 people · 14 mentions · first linked 2020-07-22
- The Scoped Task Trilemma8 people · 8 mentions · first linked 2023-04-08
- Pinned Places6 people · 7 mentions · first linked 2024-07-23
- A governance system, if you can keep it5 people · 5 mentions · first linked 2023-05-27
- The Registers of Rust5 people · 5 mentions · first linked 2023-03-08
- Notes on Io-Uring4 people · 5 mentions · first linked 2020-07-05
- References are like jumps4 people · 4 mentions · first linked 2024-05-13
- Let futures be futures3 people · 4 mentions · first linked 2024-02-03
What Hacker News says?
This is a complicated question, and ends up different for each individual. For me, I don't see the borrow checker as being more silly than GC, just an alternative, and one that speeds up my development process, not slows it down. I am also, of course, incredibly biased. Rust also has many, many features that are not the borrow checker. Some people prefer Rust because of those features, in spite of the borrow checker…
Comment linking /blog/notes-on-a-smaller-rust/
on “Single Page Applications using Rust”Submitted Pin as a story · 498 points
HN discussionhttps://github.com/tailscale/tailscale/pull/2370 was a practical drive toward this, will not proceed on this path. much more approachable, boats has written about challenges integrating in rust: https://without.boats/tags/io-uring/ in the most general form: you need a fairly "loose" memory model to integrate the "best" (performance wise) parts, and the "best" (ease of use/forward looking safety) way to integrate req…
Comment linking /tags/io-uring/
on “QUIC is not quick enough over fast internet”Submitted Coroutines and effects as a story · 248 points
HN discussionDoesn't work because it relies on caller-managed buffers. See withoutboats' post: https://without.boats/blog/io-uring/
Comment linking /blog/io-uring/
on “Why asynchronous Rust doesn't work”Submitted Let futures be futures as a story · 116 points
HN discussionHow does this proposal address the problems with "blocking on drop does not work" here? https://without.boats/blog/io-uring/ The problem here is not with Rust's async design. It's that Rust has affine types and not linear types. This is not something that could have been solved with more work on the design. It is not that there was "a decision" to allow dropping tasks; it's a constraint on the design that the langua…
Comment linking /blog/io-uring/
on “Why asynchronous Rust doesn't work”Submitted Shipping Const Generics in 2020 as a story · 107 points
HN discussionThis post is completely and totally wrong. At least you got to ruin my day, I hope that's a consolation prize for you. There is NO meaningful connection between the completion vs polling futures model and the epoll vs io-uring IO models. comex's comments regarding this fact are mostly accurate. The polling model that Rust chose is the only approach that has been able to achieve single allocation state machines in Ru…
Comment linking /tags/io-uring/
on “Why asynchronous Rust doesn't work”Submitted References are like jumps as a story · 98 points
HN discussionThat was my first reaction too, but then I realized it's also value vs. reference types i.e. Java doesn't have value types and that makes the syntax a lot cleaner vs. C++, and I'm pretty sure Kotlin must be the same So you could still have ownership in a language with references only, and the syntax could be cleaner than Rust. In fact I think there was a post about just that: Notes on a Smaller Rust https://without.…
Comment linking /blog/notes-on-a-smaller-rust/
on “Rust: A Critical Retrospective”Submitted The problem of effects in Rust (2020) as a story · 92 points
HN discussionI think some aspects of ownership are useful, e.g. move semantics and mutable/immutable references. withoutboats had a good post about a Rust-with-ownership-and-GC language a while back: https://without.boats/blog/revisiting-a-smaller-rust/
Comment linking /blog/revisiting-a-smaller-rust/
on “Rust Is Hard, Or: The Misery of Mainstream Programming”Submitted Asynchronous clean-up as a story · 87 points
HN discussionThis might not be exactly what you're looking for, but I really like "References are like jumps": https://without.boats/blog/references-are-like-jumps/
Comment linking /blog/references-are-like-jumps/
on “Flattening Rust’s learning curve”Submitted FuturesUnordered and the order of futures as a story · 43 points
HN discussionAlmost the entire early large scale adoption came from people writing async web services. From 2023: > In that regard, async/await has been phenomenally successful. Many of the most prominent sponsors of the Rust Foundation, especially those who pay developers, depend on async/await to write high performance network services in Rust as one of their primary use cases that justify their funding. https://without.boats/…
Comment linking /blog/why-async-rust/
on “Thoughts on Go vs. Rust vs. Zig”Submitted Thread-per-core as a story · 43 points
HN discussionThat's a really subtle version of the deadlock described in withoutboats FuturesUnordered post [0] When using “intra-task” concurrency, you really have to ensure that none of the futures are starving. Spawning task should probably be the default. For timeouts use tokio::select! but make sure all pending futures are owned by it. I would never recommend FuturesUnordered unless you really test all edge-cases. [0] https…
Comment linking /blog/futures-unordered/
on “Futurelock: A subtle risk in async Rust”Submitted Pinned Places as a story · 39 points
HN discussionHaving said all of that, I do agree that there are many programs where Rust's defaults don't add a lot of value, and it would be nice to have access to shared garbage-collected data without the syntax overhead of Arc<Mutex<T>> or crossbeam_epoch. I really like the discussion on resource types vs data types in this essay on higher-level rust-inspired languages: https://without.boats/blog/revisiting-a-smaller-rust/
Comment linking /blog/revisiting-a-smaller-rust/
on “Green vs. Brown Programming Languages”Submitted Coroutines and Effects as a story · 32 points
HN discussionI have lots of issues with async/await, but this is my primary beef with async/await: Remember the Gang of Four book "Design Patterns"? It was basically a cookbook on how to work around the deficiencies of (mostly) C++. Yet everybody applied those patterns inside languages that didn't have those deficiencies . Rust can run multiple threads just fine --it's not Javascript. As such, it didn't have to use async/await.…
Comment linking /blog/why-async-rust/
on “Why choose async/await over threads?”Submitted Changing the Rules of Rust as a story · 22 points
HN discussionMy blog is located at https://without.boats Here are some relevant posts: https://without.boats/blog/a-four-year-plan/ https://without.boats/blog/poll-next/ https://without.boats/blog/asynchronous-clean-up/ https://without.boats/blog/pinned-places/
Comment linking /blog/pinned-places/
on “Rewriting Rust”Submitted Pinned Places as a story · 13 points
HN discussion> If we could go back in time and have the rust project decide to never implement async, I wonder what rust would look like today. If withoutboats is right [1], then Rust would never have received the industry backing to be as successful as it is now. [1]: https://without.boats/blog/why-async-rust/ especially the section "Organizational considerations"
Comment linking /blog/why-async-rust/
on “Rewriting Rust”Submitted Revisiting a 'Smaller Rust' as a story · 13 points
HN discussionThese features are slow to be accepted for good reasons, not just out of some sort of pique. For example, the design space around combining `if let` pattern matching with boolean expressions has a lot of fraught issues around the scoping of the bindings declared in the pattern. This becomes especially complex when you consider the `||` operator. The obvious examples you want to use work fine, but the feature needs t…
Comment linking /blog/pinned-places/
on “Rewriting Rust”Submitted Asynchronous Clean-Up [in Rust] as a story · 8 points
HN discussion
