baby steps

follow: @[email protected]

Posts

Rust, Python, and TypeScript: the new trifecta

You won't believe what this AI said after deleting a database (but you might relate)

Using Rust to build Aurora DSQL

Rust turns 10

Dyn you have idea for `dyn`?

Dyn async traits, part 10: Box box box

Rust in 2025: Language interop and the extensible compiler

Rust in 2025: Targeting foundational software

View types redux and abstract fields

Rust 2024 Is Coming

How I learned to stop worrying and love the LLM

Preview crates

MinPin: yet another pin proposal

The `Overwrite` trait and `Pin`

Making overwrite opt-in #crazyideas

More thoughts on claiming

Claiming, auto and otherwise

The borrow checker within

Unwind considered harmful?

Sized, DynSized, and Unsized

Ownership in Rust

Borrow checking without lifetimes

What I'd like to see for Async Rust in 2024 🎄

Being Rusty: Discovering Rust's design axioms

Project Goals

Idea: "Using Rust", a living document

Eurorust reflections

Easing tradeoffs with profiles

Polonius revisited, part 2

Empathy in open source: be gentle with each other

Polonius revisited, part 1

New Layout, and now using Hugo!

Stability without stressing the !@#! out

Higher-ranked projections (send bound problem, part 4)

Giving, lending, and async closures

Fix my blog, please

Thoughts on async closures

Must move types

Temporary lifetimes

To async trait or just to trait

Trait transformers (send bounds, part 3)

Return type notation (send bounds, part 2)

Async trait send bounds, part 1: intro

Rust in 2023: Growing up

Rust 2024...the year of everywhere?

Dyn async traits, part 9: call-site selection

What I meant by the "soul of Rust"

Dyn async traits, part 8: the soul of Rust

Come contribute to Salsa 2022!

Many modes: a GATs pattern

What it feels like when Rust saves your bacon

Async cancellation: a case study of pub-sub in mini-redis

Coherence and crate-level where-clauses

Implied bounds and perfect derive

dyn*: can we make dyn sized?

Dare to ask for more #rust2024

Panics vs cancellation, part 1

Dyn async traits, part 7: a design emerges?

Rustc Reading Club, Take 2

CTCFT 2021-11-22 Agenda

View types for Rust

Rustc Reading Club

Dyn async traits, part 6

Dyn async traits, part 5

CTCFT 2021-10-18 Agenda

Dyn async traits, part 4

Dyn async traits, part 3

Dyn async traits, part 2

Dyn async traits, part 1

Rustacean Principles, continued

CTCFT 2021-09-20 Agenda

Rustacean Principles

Next CTCFT Meeting: 2021-09-20

CTCFT 2021-07-19 Agenda

CTCFT Social Hour

CTCFT 2021-06-21 Agenda

Edition: the song

CTCFTFTW

[AiC] Vision Docs!

Async Vision Doc Writing Sessions VII

Async Vision Doc Writing Sessions VI

Async Vision Doc Writing Sessions V

Async Vision Doc Writing Sessions IV

My "shiny future"

Async Vision Doc Writing Sessions III

Async Vision Doc Writing Sessions II

Async Vision Doc Writing Sessions

The more things change...

Looking back on 2020

Rotating the compiler team leads

Async Interview #8: Stjepan Glavina

Async interviews: my take thus far

Library-ification and analyzing Rust

Async Interview #7: Withoutboats

Async Interview #6: Eliza Weisman

Async Interview #5: Steven Fackler

Async Interview #4: Florian Gilcher

Towards a Rust foundation

Async Interview #3: Carl Lerche

Async Interview #2: cramertj, part 3

Async Interview #2: cramertj, part 2

Async Interview #2: cramertj

AiC: Improving the pre-RFC process

Rust 2020

Async Interview #1: Alex and Nick talk about async I/O and WebAssembly

Announcing the Async Interviews

why async fn in traits are hard

AiC: Shepherds 3.0

AiC: Unbounded queues and lang design

Async-await status report #2

AiC: Language-design team meta working group

AiC: Collaborative summary documents

AiC: Adventures in consensus

More than coders

Async-await status report

Rust lang team working groups

Salsa: Incremental recompilation

Polonius and the case of the hereditary harrop predicate

Polonius and region errors

Rust in 2019: Focus on sustainability

After NLL: Moving from borrowed data and the sentinel pattern

Splash 2018 Mid-Week Report

After NLL: Interprocedural conflicts

MIR-based borrowck is almost here

October Office Hour Slots

Office Hours #1: Cyclic services

Office Hours #0: Debugging with GDB

Rust office hours

Rust pattern: Iterating an over a Rc<Vec<T>>

Never patterns, exhaustive matching, and uninhabited types (oh my!)

Proposal for a staged RFC process

MIR-based borrow check (NLL) status update

An alias-based formulation of the borrow checker

Rust pattern: Precise closure capture clauses

Rust pattern: Rooting an Rc handle

Maximally minimal specialization: always applicable impls

In Rust, ordinary vectors are values

An on-demand SLG solver for chalk

#Rust2018

Lessons from the impl period

Chalk meets SLG

Cyclic queries in chalk

Non-lexical lifetimes: draft RFC and prototype available

Query structure in chalk

gnome-class: Integrating Rust and the GNOME object system

Unification in Chalk, part 2

Rayon 0.7 released

Unification in Chalk, part 1

The Lane Table algorithm

Nested method calls via two-phase borrowing

Non-lexical lifetimes using liveness and location

Project idea: datalog output from rustc

Compiler design sprint summary

Unsafe code and shared references

Lowering Rust traits to logic

Assigning blame to unsafe code

Parallel iterators, part 3: Consumers

Associated type constructors, part 4: Unifying ATC and HKT

Associated type constructors, part 3: What higher-kinded types might look like

Associated type constructors, part 2: family traits

Associated type constructors, part 1: basic concepts and introduction

Switching to Jekyll

Supporting blanket impls in specialization

Observational equivalence and unsafe code

Announcing intorust.com

Distinguishing reuse from override

Intersection Impls

Thoughts on trusting types and unsafe code

'Tootsie Pop' Followup

The 'Tootsie Pop' model for unsafe code

Unsafe abstractions

Non-lexical lifetimes: adding the outlives relation

Non-lexical lifetimes based on liveness

Non-lexical lifetimes: introduction

Nice errors in LALRPOP

Parallel Iterators Part 2: Producers

Parallel Iterators Part 1: Foundations

Rayon: data parallelism in Rust

Virtual Structs Part 4: Extended Enums And Thin Traits

LALRPOP

Virtual Structs Part 3: Bringing Enums and Structs Together

Virtual Structs Part 2: Classes strike back

Virtual Structs Part 1: Where Rust's enum shines

A few more remarks on reference-counting and leaks

On reference-counting and leaks

Modeling graphs in Rust using vector indices

Little Orphan Impls

Purging proc

Allocators in Rust

Multi- and conditional dispatch in traits

Attribute and macro syntax

An experimental new type inference scheme for Rust

Implied bounds

Follow up to Focusing on Ownership

Focusing on ownership

Parallel pipelines for JS

Typed Objects Status Report

Value types in JavaScript

Rust RFC: Opt-in builtin traits

Rust RFC: Stronger guarantees for mutable borrows

Closures and the borrow checker

Rvalue lifetimes in Rust

DST, Take 5

Structural arrays in Typed Objects

Thoughts on DST, Part 4

Thoughts on DST, Part 2

Thoughts on DST, Part 3

Thoughts on DST, Part 1

Optimizing SIMD, part 2

Optimizing SIMD

Parameter coercion in Rust

Treating vectors like any other container

Intermingled parameter lists, take 2

Optimizing complex typed object assignments

Intermingled parameter lists

PJS Roadmap

Iterators yielding mutable references

Iterators yielding mutable references, take 2

Single inheritance

Typed object handles

Fn types in Rust, take 3

Type specifications in Parallel JS

Integrating binary data and type inference in SpiderMonkey

Rust presentation at Northeastern

Data Parallelism in Rust

On the connection between memory management and data-race freedom

Reducing DST Annotation