The Curious Engineer

All blogs / Rust

All Posts on baby steps

smallcultfollowing.com/babysteps/blog

Recent content in All Posts on baby steps

RustOther languagesAI / ML

’15’20’25
Posts
362 from 2 Dec 2011 to 30 Oct 2026
Posting
monthly (19 in the last year)
Kind
personal blog
Feed
https://smallcultfollowing.com/babysteps/blog/index.xml

2026 15

  1. 'Trust but verify'; or, 'the correctness ratchet'
  2. What agents mean for Rust (and vice versa)
  3. Why 'externalized' proofs of cyclic trait impls does not work
  4. Cylic trait implementations: motivation
  5. Battery packs: Let's talk about crates, baby
  6. Only Bounds
  7. Symposium: community-oriented agentic development
  8. Maximally minimal view types, a follow-up
  9. Maximally minimal view types
  10. How Dada enables internal references
  11. What it means that Ubuntu is using Rust
  12. Sharing in Dada
  13. Dada: moves and mutation
  14. Hello, Dada!
  15. Fun With Dada

2025 23

  1. Move Expressions
  2. Just call clone (or alias)
  3. But then again...maybe alias?
  4. Bikeshedding `Handle` and other follow-up thoughts
  5. Explicit capture clauses
  6. Move, Destruct, Forget, and Rust
  7. We need (at least) ergonomic, explicit handles
  8. SymmACP: extending Zed's ACP to support Composable Agents
  9. The Handle trait
  10. Symposium: exploring new AI workflows
  11. Rust, Python, and TypeScript: the new trifecta
  12. You won't believe what this AI said after deleting a database (but you might relate)
  13. Using Rust to build Aurora DSQL
  14. Rust turns 10
  15. Dyn you have idea for `dyn`?
  16. Dyn async traits, part 10: Box box box
  17. Rust in 2025: Language interop and the extensible compiler
  18. Rust in 2025
  19. Rust in 2025: Targeting foundational software
  20. View types redux and abstract fields
  21. Rust 2024 Is Coming
  22. How I learned to stop worrying and love the LLM
  23. Preview crates

2024 11

  1. MinPin: yet another pin proposal
  2. The `Overwrite` trait and `Pin`
  3. Making overwrite opt-in #crazyideas
  4. More thoughts on claiming
  5. Claiming, auto and otherwise
  6. The borrow checker within
  7. Unwind considered harmful?
  8. Sized, DynSized, and Unsized
  9. Ownership in Rust
  10. Borrow checking without lifetimes
  11. What I'd like to see for Async Rust in 2024 🎄

2023 22

  1. Being Rusty: Discovering Rust's design axioms
  2. Project Goals
  3. Idea: "Using Rust", a living document
  4. Eurorust reflections
  5. Easing tradeoffs with profiles
  6. Polonius revisited, part 2
  7. Empathy in open source: be gentle with each other
  8. Polonius revisited, part 1
  9. New Layout, and now using Hugo!
  10. Stability without stressing the !@#! out
  11. Higher-ranked projections (send bound problem, part 4)
  12. Giving, lending, and async closures
  13. Fix my blog, please
  14. Thoughts on async closures
  15. Must move types
  16. “must move”
  17. Temporary lifetimes
  18. To async trait or just to trait
  19. Trait transformers (send bounds, part 3)
  20. Return type notation (send bounds, part 2)
  21. Async trait send bounds, part 1: intro
  22. Rust in 2023: Growing up

2022 14

  1. Rust 2024...the year of everywhere?
  2. Dyn async traits, part 9: call-site selection
  3. What I meant by the "soul of Rust"
  4. Dyn async traits, part 8: the soul of Rust
  5. Come contribute to Salsa 2022!
  6. Many modes: a GATs pattern
  7. What it feels like when Rust saves your bacon
  8. Async cancellation: a case study of pub-sub in mini-redis
  9. Coherence and crate-level where-clauses
  10. Implied bounds and perfect derive
  11. dyn*: can we make dyn sized?
  12. Dare to ask for more #rust2024
  13. Panics vs cancellation, part 1
  14. Dyn async traits, part 7: a design emerges?

2021 29

  1. Rustc Reading Club, Take 2
  2. CTCFT 2021-11-22 Agenda
  3. View types for Rust
  4. Rustc Reading Club
  5. Dyn async traits, part 6
  6. Dyn async traits, part 5
  7. CTCFT 2021-10-18 Agenda
  8. Dyn async traits, part 4
  9. Dyn async traits, part 3
  10. Dyn async traits, part 2
  11. Dyn async traits, part 1
  12. Rustacean Principles, continued
  13. CTCFT 2021-09-20 Agenda
  14. Rustacean Principles
  15. Next CTCFT Meeting: 2021-09-20
  16. CTCFT 2021-07-19 Agenda
  17. CTCFT Social Hour
  18. CTCFT 2021-06-21 Agenda
  19. Edition: the song
  20. CTCFTFTW
  21. [AiC] Vision Docs!
  22. Async Vision Doc Writing Sessions VII
  23. Async Vision Doc Writing Sessions VI
  24. Async Vision Doc Writing Sessions V
  25. Async Vision Doc Writing Sessions IV
  26. My "shiny future"
  27. Async Vision Doc Writing Sessions III
  28. Async Vision Doc Writing Sessions II
  29. Async Vision Doc Writing Sessions

2020 11

  1. The more things change...
  2. Looking back on 2020
  3. Rotating the compiler team leads
  4. Async Interview #8: Stjepan Glavina
  5. Async interviews: my take thus far
  6. Library-ification and analyzing Rust
  7. Async Interview #7: Withoutboats
  8. Async Interview #6: Eliza Weisman
  9. Async Interview #5: Steven Fackler
  10. Async Interview #4: Florian Gilcher
  11. Towards a Rust foundation

2019 22

  1. Async Interview #3: Carl Lerche
  2. Async Interview #2: cramertj, part 3
  3. Async Interview #2: cramertj, part 2
  4. Async Interview #2: cramertj
  5. AiC: Improving the pre-RFC process
  6. Rust 2020
  7. Async Interview #1: Alex and Nick talk about async I/O and WebAssembly
  8. Announcing the Async Interviews
  9. why async fn in traits are hard
  10. AiC: Shepherds 3.0
  11. AiC: Unbounded queues and lang design
  12. Async-await status report #2
  13. AiC: Language-design team meta working group
  14. AiC: Collaborative summary documents
  15. AiC: Adventures in consensus
  16. More than coders
  17. Async-await status report
  18. Rust lang team working groups
  19. Salsa: Incremental recompilation
  20. Polonius and the case of the hereditary harrop predicate
  21. Polonius and region errors
  22. Rust in 2019: Focus on sustainability

2018 20

  1. After NLL: Moving from borrowed data and the sentinel pattern
  2. Splash 2018 Mid-Week Report
  3. After NLL: Interprocedural conflicts
  4. MIR-based borrowck is almost here
  5. October Office Hour Slots
  6. Office Hours #1: Cyclic services
  7. Office Hours #0: Debugging with GDB
  8. Rust office hours
  9. Rust pattern: Iterating an over a Rc >
  10. Never patterns, exhaustive matching, and uninhabited types (oh my!)
  11. Proposal for a staged RFC process
  12. MIR-based borrow check (NLL) status update
  13. An alias-based formulation of the borrow checker
  14. Rust pattern: Precise closure capture clauses
  15. Rust pattern: Rooting an Rc handle
  16. Maximally minimal specialization: always applicable impls
  17. In Rust, ordinary vectors are values
  18. An on-demand SLG solver for chalk
  19. #Rust2018
  20. Lessons from the impl period

2017 16

  1. Chalk meets SLG
  2. Cyclic queries in chalk
  3. Non-lexical lifetimes: draft RFC and prototype available
  4. Query structure in chalk
  5. gnome-class: Integrating Rust and the GNOME object system
  6. Unification in Chalk, part 2
  7. Rayon 0.7 released
  8. Unification in Chalk, part 1
  9. The Lane Table algorithm
  10. Nested method calls via two-phase borrowing
  11. Non-lexical lifetimes using liveness and location
  12. Project idea: datalog output from rustc
  13. Compiler design sprint summary
  14. Unsafe code and shared references
  15. Lowering Rust traits to logic
  16. Assigning blame to unsafe code

2016 21

  1. Parallel iterators, part 3: Consumers
  2. Associated type constructors, part 4: Unifying ATC and HKT
  3. Associated type constructors, part 3: What higher-kinded types might look like
  4. Associated type constructors, part 2: family traits
  5. Associated type constructors, part 1: basic concepts and introduction
  6. Switching to Jekyll
  7. Supporting blanket impls in specialization
  8. Observational equivalence and unsafe code
  9. Announcing intorust.com
  10. Distinguishing reuse from override
  11. Intersection Impls
  12. Thoughts on trusting types and unsafe code
  13. 'Tootsie Pop' Followup
  14. The 'Tootsie Pop' model for unsafe code
  15. Unsafe abstractions
  16. Non-lexical lifetimes: adding the outlives relation
  17. Non-lexical lifetimes based on liveness
  18. Non-lexical lifetimes: introduction
  19. Nice errors in LALRPOP
  20. Parallel Iterators Part 2: Producers
  21. Parallel Iterators Part 1: Foundations

2015 10

  1. Rayon: data parallelism in Rust
  2. Virtual Structs Part 4: Extended Enums And Thin Traits
  3. LALRPOP
  4. Virtual Structs Part 3: Bringing Enums and Structs Together
  5. Virtual Structs Part 2: Classes strike back
  6. Virtual Structs Part 1: Where Rust's enum shines
  7. A few more remarks on reference-counting and leaks
  8. On reference-counting and leaks
  9. Modeling graphs in Rust using vector indices
  10. Little Orphan Impls

2014 16

  1. Purging proc
  2. Allocators in Rust
  3. Multi- and conditional dispatch in traits
  4. Attribute and macro syntax
  5. An experimental new type inference scheme for Rust
  6. Implied bounds
  7. Follow up to Focusing on Ownership
  8. Focusing on ownership
  9. Parallel pipelines for JS
  10. Value types in JavaScript
  11. Typed Objects Status Report
  12. Rust RFC: Opt-in builtin traits
  13. Rust RFC: Stronger guarantees for mutable borrows
  14. Closures and the borrow checker
  15. Rvalue lifetimes in Rust
  16. DST, Take 5

2013 48

  1. Structural arrays in Typed Objects
  2. Thoughts on DST, Part 4
  3. Thoughts on DST, Part 3
  4. Thoughts on DST, Part 2
  5. Thoughts on DST, Part 1
  6. part 2
  7. Optimizing SIMD, part 2
  8. Optimizing SIMD
  9. Parameter coercion in Rust
  10. Treating vectors like any other container
  11. Optimizing complex typed object assignments
  12. Intermingled parameter lists, take 2
  13. PJS Roadmap
  14. Intermingled parameter lists
  15. Iterators yielding mutable references, take 2
  16. Single inheritance
  17. Iterators yielding mutable references
  18. Typed object handles
  19. Fn types in Rust, take 3
  20. Type specifications in Parallel JS
  21. Integrating binary data and type inference in SpiderMonkey
  22. Rust presentation at Northeastern
  23. On the connection between memory management and data-race freedom
  24. Data Parallelism in Rust
  25. Reducing DST Annotation
  26. More on fns
  27. Removing procs
  28. Integrating binary data and PJs
  29. Procedures, continued
  30. Mutable fn alternatives
  31. Recurring closures and dynamically sized types
  32. Dynamically sized types, revisited
  33. Parallelizable JavaScript Subset
  34. The Case of the Recurring Closure
  35. Nested lifetimes
  36. A tour of the Parallel JS implementation (Part 2)
  37. Associated items continued
  38. Associated items
  39. Guaranteeing parallel execution
  40. A tour of the Parallel JS implementation (Part 1)
  41. Parallel JS lands
  42. Splitting the PJs API
  43. Interfacing with C functions in Rust
  44. Destructors and finalizers in Rust
  45. Revised for loop protocol
  46. Lifetime notation redux
  47. The case FOR deterministic results
  48. Deterministic or not?

2012 64

  1. Lifetime notation
  2. Improving our parallel intrinsic
  3. Self-hosted Parallel JS
  4. Imagine never hearing the phrase 'aliasable, mutable' again
  5. Restrict pointers
  6. Purity in Parallel JavaScript
  7. Function and object types
  8. Extending the definition of purity in Rust
  9. Rivertrail
  10. Termination of trait matching
  11. A postscript on traits and impls
  12. Refining traits and impls
  13. Moves based on type
  14. Type system for borrowing permissions
  15. Rvalue lifetimes
  16. Datasort refinements
  17. Type inference in Spidermonkey
  18. Generalizing inherited mutability
  19. Yet another tutorial on borrowed pointers
  20. About that 'tutorial'...
  21. Borrowed pointer tutorial
  22. Concurrent maps
  23. Fn types
  24. Borrowed Pointer Tutorial
  25. Hotpar
  26. Unifying patterns in alts and lets
  27. Mutability
  28. Mutability idea retracted
  29. Simple effect system
  30. Moving mutability into the type
  31. approach to mutability I recently discussed
  32. Vectors, slices, and functions, oh my!
  33. Iface types
  34. Fn types
  35. Borrowing errors
  36. Borrowing
  37. In favor of types of unknown size
  38. Permission regions for race-free parallelism
  39. References
  40. Vectors, strings, and slices
  41. On types and type schemes
  42. Syntax matters...?
  43. DOA: Don't overabstract
  44. Declared vs duckish typing
  45. Rust's object system
  46. For loops
  47. Servo design
  48. Avoiding region explosion in Rust
  49. Progress on inlining
  50. Serialization without type information via impls
  51. Regions tradeoffs
  52. Versioning considered OK
  53. CCI and versioning
  54. Returning refs
  55. Regions-lite...ish
  56. my previous post
  57. Using futures in the task API
  58. Task API
  59. Auto-serialization in Rust
  60. Breaking out is hard to do
  61. Cross-crate inlining
  62. Update
  63. Proposed JS parallelism vs actors
  64. Parallel Javascript

2011 16

  1. Composing blocks
  2. Block sugar in expressions
  3. Tone and criticism
  4. Dynamic race detection
  5. Implementing unique closures
  6. Const vs Mutable
  7. Partially ordered unique closures
  8. Challengines implementing unique closures
  9. Pure blocks
  10. Why not modes?
  11. Sendable functions
  12. Rust usability problems
  13. Coroutines for Rust
  14. Statement-level parallelism
  15. Rust without implicit copies
  16. Why case classes are better than variant types

Undated 4

  1. paper describing the current version of the Typed Objects API
  2. slides from my talk
  3. outlines various possible schemes and also details use cases that are enabled by these schemes
  4. proposal for Rust that aims to eliminate implicit copies