Completion-model IO systems don't work naturally with the Read trait. In this post I want to explore why that is and some alternatives. Many of the issues are related to cancellation, and there

I think the Rust RFC process needs serious reform. In this blog post, I'll explain why I think that, by covering some of the problems with the current process. Before I get all

The Read and Write traits are key to IO in Rust and designing the async versions of these traits (and migrating runtimes to use them) is crucial for improving interoperability and portability in

Async programming in Rust is built on top of the operating system's async IO facilities. While it is possible to just use async/await for control flow, mostly people use async for async

In previous years, the core team have asked the community to write new years blog posts about Rust in the coming year. They haven't this year, but I wanted to write one anyway.

I made a small crate for easy-to-use IO in Rust. It is called ezio, and 0.1 is released today. It is a simple crate and it is ready to use now. I

A goal of the async foundations working group is for async Rust to be portable and interoperable. I want to dig in to what that means in this blog post. For a little

Unlike other Rust features, you can't just write await in your code and run it. You need to use an async runtime like Tokio or async-std. But why? And what do these runtimes

We're pleased to announce the 0.1 release of the TiKV Rust client. TiKV is a distributed key-value store. TiKV is powerful, mature, and widely used as part of TiDB (a 'NewSQL' database)

RFCs are how changes are made to Rust (language, libraries, core tools, processes and governance, etc.). If you want to keep abreast of changes to Rust or want to deeply understand a feature

One of the more subtle aspects of Rust is how traits can be used as types. In this blog post I will attempt a bit of a deep dive into how to use

Crafting a beautiful PR is not a high priority for a lot of people, but I think it should be! In this post, I'll expound on what a good, well-organised PR looks like,

The TiKV transactions SIG is starting up its reading group. We'll try to read and discuss a paper each month. If you're interested in research in distributed transactions, come join in! We'll start

It's that time of year again - time to think about a roadmap for next year! As I wrote last year, I think a good roadmap should provide focus for the project, but

I'm stepping down from Rust's core team. It's my last official involvement with Rust, and I'm kinda sad about leaving. Rust is exciting and important, and I love the community and technology. It

The TiKV Transactions SIG's documentation quest begins today! It is our first community activity. There are tons of bite-size tasks and some more involved work, with the goal of making TiKV's transaction components

Rustconf 2020 happened last week (August 20th). For the first time, it was an online conference. Ironically that made it more difficult for me to attend because of timezones (and I was on

I've been working on the distributed transaction system in TiKV for about a year now. TiKV is an open-source, distributed and transactional key-value store written in Rust. Recently, I've been helping create a

TiDB is a distributed, MySQL-compatible database. It is built on top of TiKV, a distributed key-value store. Building these projects is easy - clone the Git repos, then run make. Unfortunately running development

In TiDB 4.0, we've extended the transaction system to handle large transactions. Previously, TiDB limited the number of reads and writes in a transaction. In version 4.0 there is a much

This post was originally published on the PingCAP blog. I've been using Go for the past few weeks. It's my first time using Go for a large (-ish), serious project. I've previously looked

This is the third (and last, for now) post in a series on remote work. Previous posts discussed some basics for remote work and communication. In this post I'll talk a bit about

In my last post I talked a bit about some general issues with remote work. In this post I am going to focus on communication - probably the most important thing for remote

I've been working remotely (in various ways and at various companies) for nearly ten years. I love working remotely, I am happier and more productive. However, it takes some adjustment and it's not

We need to work on error handling. It's a difficult thing to work on because a lot of people have strong opinions, but I think we should. Rust's error handling story at the