Skip to content

Instantly share code, notes, and snippets.

@brson brson/ Secret
Last active Mar 17, 2017

What would you like to do?

Rust student project 2017 - WebAssembly showcase

Rust is a new systems programming language that is fast and memory safe. It is growing quickly, is pleasant to contribute to, and is in need of contributions in many areas!

In this project you will be developing a showcase application to demonstrate Rust compiled to WebAssembly, a new bytecode that runs in the web browser. With WebAssembly, authors can write software that runs on the web with near-native performance. It will unlock new capabilities for the web, and Rust, with it's focus on low-level performance, is one of the best-positioned languages to take advantage of WebAssembly.

This is a self-contained project where creativity and persistence will lead to success. Design and implement a client-side web application, written in Rust, that demonstrates the promise of running Rust software on the web, by compiling to WebAssembly. Publish and blog about the result.

This serves two important purpsose: firstly, as a teaching tool, the project demonstrates two bleeding-edge technologies used successfully together. You will be at the forefront of this technology and people will be looking to your early experience as they try it themselves. Second, by writing a real application we will discover new bugs and other problems with the stack. You will report these bugs to their upstream projects, and even fix them yourself. This process of validating our products by actually using them is called "dogfooding", and it's an important part of product development.

At the end of this project you will have your own Rust-language web application, will have new experience with Rust, WebAssembly, JavaScript, and with collaboration in an active and friendly open source community.

The project will run in 3 phases: in the first weeks you will familiarize yourself with the tools: Rust, WebAssembly, emscripten, and their development environment in and out of the web browser. You'll work with your coach to identify a few key features that the project will demonstrate and plan how to create them. The second phase is where you will do planned implementation work. Finally, with a few weeks left to spare, we will evaluate our progress, decide how to present it most effectively, and then spend the remaining time polishing and documenting it for release.

Good candidates will have moderate programming experience, either in JavaScript or in a systems language like C, C++ or Rust. This work will involve investigating and even debugging new compiler and web browser features - much time will probably be spent examining the Rust compiler's WebAssembly output and comparing it to expectations. Students will not be expected to fix bugs the Rust compiler itself on their own, though they are certainly welcome to - their task is to write an interesting web application.

Rust student project 2017 - reproducible builds

Rust is a new systems programming language that is fast and memory safe. It is growing quickly, is pleasant to contribute to, and is in need of contributions in many areas!

In this project you will be making the Rust release builds reproducible. A system with "reproducible builds" can be built multiple times, by independent parties, in differing environments, and each time produce the exact same binary results. Reproducibility is a powerful security property that allows third parties to verify that a given binary release of a software project corresponds exactly to the source code it is created from.

Projects including Debian and Tor have pursued reproducibility in recent years. In the Rust project, we desire others be able to reproduce the official Rust builds as a defense against the potential compromise of the Rust build infrastructure - that is, if a third party is continually verifying the Rust releases via reproducible builds, they would be able to detect if a Rust releases is tampered with.

The project will be run in sprints, where each sprint identifies the next-most-promising source of non-determinism, then proceeds to fix it. At the end of the project, you will write a blog post explaining your findings and progress.

At the end of this project we will expect that the output of the Rust build system is measurably more deterministic, if not completely deterministic. You will gain considerable experience in one specific area of compiler development: controlling the determinism of compiler output. This work will involve hacking directly on the Rust compiler, and so will require modest Rust experience. Candidates should expect to dig into minute details of why certain bits in the Rust toolchain's output are set as they are, and what causes their variation. In addition to eliminating non-determisim in the Rust compiler itself, you will also be looking at the non-deterministic behavior of other tools in the Rust build process, including typical Unix utilities like tar.

Rust student project 2017 - SemVer compatibility tool

Rust is a new systems programming language that is fast and memory safe. It is growing quickly, is pleasant to contribute to, and is in need of contributions in many areas!

In this project you will develop a tool to help Rust library authors correctly follow the SemVer specification for version numbering. In Rust's versioning scheme, certain change to APIs are not allowed in minor releases - that is, between e.g. version 1.0 and 1.1, a program may not break any APIs. This contract about what API changes are or are not allowed in a given release, is not enforced in any way - it is entirely up to Rust library authors to ensure through vigilent code review that they have not violated SemVer.

We think we can do a lot better than that though. In this project you will develop a tool that enforces the SemVer contract for Rust crates by analyzing the differences in type signatures between two releases of the same crate. A tool that does this reliably would have a broad impact on the reliability of the entire Rust ecosystem.

This project will run in two phases. In the first you will make a rough attempt to formulate rules that determine SemVer conformance in Rust, based on its type system. After that you will write a tool that hooks into the compiler pipeline to perform this analysis. This is a research project where the exact work is not known ahead of time; we will attain promising early results and then go from there.

At the end of this project we will not expect to have a complete solution, but a proof of concept that can be released to the wider Rust community. Although you will not deliver a completed tool, you will report on your findings, and package up the results to make it easier for others to continue your work. This is a widely-desired tool, and you may find others interested in collaborating.

A good candidate will have moderate Rust experience, and preferably experience with type systems and compiler writing. This project will involve hacking on compiler internals.

Rust student project 2017 - Rust benchmark suite

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.