This post is part 3 (and probably the final part) of a multi-part series: part 0 (an intro and brief description of KCL)part 1: unitspart 2: program memorypart 3: look and feelThis

This post is part 2 of a multi-part series: part 0 (an intro and brief description of KCL)part 1: unitspart 2: program memorypart 3: look and feelIn this post I'll cover a

This post is part 1 of a multi-part series: part 0 (an intro and brief description of KCL)part 1: unitspart 2: program memorypart 3: look and feelThis blog post is about numeric

In May last year I wrote a blog post on how Rust had evolved from the 1.0 release to 1.78. I found it really interesting to group all the changes together

This post is part 0 of a multi-part series: part 0 (an intro and brief description of KCL)part 1: unitspart 2: program memorypart 3: look and feelFor roughly the past year, I've

From a user's perspective an uncaught panic in a Rust program is a crash. A panic will terminate the thread and unless the developers have taken some care, that leads to the program

Hi ho! Hi ho! It's back to work I go! After taking a bit of a break from work, I am officially back into it (I've actually been back into it since July,

Over the last few months I've been putting together a new website. It is now all online at https://www.ncameron.org/. The website is mostly about work - I'm available now for

I will be giving a talk at Rustconf this year about Rustfmt and code formatters. The abstract is: How does Rustfmt work? How could it work better? (Demonstrated by a working prototype). Or

How has Rust changed over the years? It's been nine years since 1.0 was released (well, next week, technically). In that time, there have been 78 major releases and two editions, with

(This blog post is an edited version of posts on social media, slightly edited and posted here for completeness/further reach). I'm preparing a training course to teach performance engineering to Rust programmers.

Over the years I've found it pretty important to have a good system for self-organisation. This has evolved over time, with a major influence being the book Getting Things Done by David Allen

I left Microsoft at the beginning of July (after two years) and also stopped working on Rust at the same time. I intended to finish up some work and hand stuff over etc.

I recently read the blog post A decade of developing a programming language by Yorick Peterse (found via Steve Klabnik). I thought it was an interesting blog post which got me thinking, and

I've been a bit quiet on social media the past few months (more on what I've been up to in an upcoming post). I would like to write a bit more in the

Rust is an open source project. More than just the source code for the compiler being available, that means the project works in the open, inclusive of, and collaborating with, the wider community.

It seems to be fashionable to drop language design ideas in blog posts at the moment, so I thought I'd join in the fun with a post about defer blocks (don't run off

I seem to be writing a few of these 'clarification' posts... Anyway, in my last post, I wrote "One partial solution might be to start planning a 2.0 release", I was deliberately

The core team used to call for blog posts to help plan the next year. The core team has pretty much disappeared and certainly hasn't called for blog posts, but I'm going to

I had a good conversation with Ryan Levick (the core team's representative on the Foundation board) about my last blog post, between that and some more thinking, I'd like to refine and clarify

In response to the 'Call for blogs / ideas on Rust Foundation Strategy 2023-25', this post details where I think the Foundation should be headed over the next few years. I think we must

Error handling in Rust is a bit of an intermediate topic. That is in part because error handling in any language is actually more complicated than it seems, partly because it is a

The Rust project is run by its teams, such as the language team, library team, and community team. The teams are the primary structure for organising work and people in the Rust project,

Rust is in a pretty good place; it is getting more and more popular, has more and more contributors, and is used in some pretty significant places. However, it is a time of

In programming and programming language design we often talk about complexity. And for good reason! Complexity often feels like the enemy we are battling when learning a new codebase or new programming language,