1. # Countability and Enumerability

I've sometimes conflated the ideas of a set being countable (a set $$S$$ is countable iff $$\exists I : \mathbb{N} \to S$$) and a set being enumerable (you can write a program that lists them). However, they are very distinct concepts. Here's an example, appealing to the widely-used proof in …

2. # The Future of This Week in Rust

Given that I haven't written a TWiR this week or last, people have been contacting me asking if I have cancelled it. The answer is, emphatically, "no". Though I did have my doubts. I've thought about it for a while, and I've determined what I think is the best path …

3. # A Plan For My Next Five Years

On the drive home from school, my father and I listened to the first day of the SANS course on strategic planning. This was pretty far outside of my usual knowledge area, and it was an experience I certainly don't regret. The first day went over all the basics of …

4. # New Blog

I did something to my environment and my octopress setup exploded. So, I decided it was time to move on. I've been wanting to toss octopress for something less quirky for a while. So now I'm using Pelican with the Elegant theme. Pelican is pretty simple, though I've had trouble …

5. # TBAA Revisited

My original post about alias analysis had some issues, which I clarify and modify the algorithm to handle.

## The Problem

There are two major issues with the algorithm I described. The first is that LLVM's TBAA is not flow-sensitive. This means that given two non-aliasing pointers, it assumes that they …

6. # Simple Type-Based Alias Analysis for Rust

This post examines type-based alias analysis and how a simple one can be implemented for Rust.

## Background

Alias analysis, in the context of LLVM, is an analysis which determines whether two pointers can point to the same data, or "alias". More specifically, two pointers a and b alias if uses …

# Summary

Change the following syntax:

struct Foo<T, U> { ... }
impl<T, U> Trait<T> for Foo<T, U> { ... }
fn foo<T, U>(...) { ... }


to:

forall<T, U> struct Foo { ... }
forall<T, U> impl Trait<T> for Foo<T, U> { ... }
forall<T, U> fn foo(...) { ... }


# The Problem

The immediate, and most pragmatic …

8. # Asus Vivobook X200

I recently upgraded my aging Acer Aspire One with a new Asus Vivobook. It was running a really slow Intel Atom processor, one of the first generations. It literally took a day to bootstrap Rust, and not all of that time was spent swapping! It worked well for what I …

9. # Intellectual Growth

I have a textbook on logic, I found it at the dump probably 3 years ago, during my second year of high school. I tried working through it many times, but simply could not wrap my head around some of the concepts it presents. In particular, I found its treatment …

I'm learning Haskell. I'm doing this for many reasons, but the most important is to expand my knowledge and form a more principled understanding of languages. So, I'm reading a paper. It's a very good paper, but the thing most striking about it is its age. 1977! My father was …

11. # More On Stack Safety

I got a lot of great feedback on my previous post, and I've done some thinking and come up with what I think is a better proposal, and a solid way forward.

1. Teach the task API to allow spawning a task with a fixed stack size.
2. Add the ability to …
12. # On Stack Safety

Stack safety is a sticky topic in Rust right now. There are multiple conflicting tensions. My goal is to lay them bare, untangle the mess, and see if there's a better way forward (spoiler: there is!).

When a program is "stack safe", the stack pointer never points outside of allocated …

13. # ACM ICPC: What I Learned

Yesterday I participated in my first programming contest. It was very fun, though challenging, and I learned a fair bit during it. The content consisted of teams of 3 working to solve 6 problems as fast as possible. The problems ranged from trivial (repeated arithmetic) to moderately complex.

14. # Rust's Memory Management

Note: I accidentally published this. I won't take it down, but it is incomplete and I do not guarantee its correctness.

Note 2: I don't think this post is necessary anymore, as the tutorial has been updated significantly, and is quite understandable. As such I don't plan on finishing this …

15. # Structure and organisation of rustc

This is the second part of a planned series about rustc, the Rust compiler

This post is going to discuss the structure and organisation of rustc, covering the major moving parts and how they interact. I'll start, of course, where it starts, and ending, of course, where it ends.

rustc …

16. # How I got started hacking rustc, and how you can too!

This is the first part of a planned series about rustc, the Rust compiler

I remember first hearing about Rust during the summer of 2011. In fact, I remember the exact moment. I was at MIT, doing their Junction program. It was during a seminar about semiconductors. I remember browsing …