|
This course seeks to ask, and start to answer, a simple question:
"What are the most important open research challenges for software systems written in Rust?"
CS340R is a graduate research course intended to explore how
Rust, as a language, introduces new research questions. C (and C++) have
dominated software systems for so long that their challenges (e.g.,
asynchrony, memory management, array indexing) are assumed as basic
systems problems. Rust, however, has very different challenges.
How does this change research?
CS340R is not intended to be a primer on the Rust language. While
we will spend the first three weeks learning Rust, this is so that students
can begin reimplementing a recent research system in Rust. Through this
effort, we will learn how a Rust implementation differs and why. Are there
parts of the original system which are hard but are easy in Rust (e.g.,
memory safety)? Are there parts of the system which are much harder in Rust
(e.g., asynchrony, memory layouts, buffer management)? These latter
discoveries may indicate places where research could make a contribution.
We will read a wide range of (advanced) research papers describing systems written
in Rust. If you have not taken a first paper reading course in systems before
(e.g., CS240, CS244, CS244B, or equivalent at another institution), you are not
prepared to take CS340R. There is a tremendous amount of institutional knowledge
in systems research, and if it is new to you, many of the papers will
require a lot of background reading. For example, you should know the answers
to some (but probably not all) of these questions:
- What are some of the tradeoffs between thread-based and event-based concurrency?
- What is livelock?
- What is idempotency?
- What are the advantages of a log-structured file system? What is hard?
- What are some differences between a macrokernel and a microkernel?
- What is scatter-gather I/O and when is it useful?
- What is optimistic concurrency control?
- What are some tradeoffs between garbage collection and reference counting?
- What is a replicated state machine? What are the major algorithms used for them?
- What is information flow and how is it used in secure systems?
The course is split into two parts. In the first 3 weeks, students begin to learn the
basics of Rust. At the end of these three weeks, students form into project groups, picking
a recent system implemented in a language other than Rust. Over the next seven weeks of the
quarter, the groups re-implement the system in Rust while we read research papers
on systems built in Rust. Students write a short summary (300 words) for papers in weeks 4-10,
which we use to guide class discussion.
|
