The course will be given as a self study course with a set of introductional seminars and accompanying mandatory assignments, followed by a larger assigmnent (project). The project can be carried out individually or in groups dependent on size. Grading will be individual, based on agreed requirements between the student and the teacher, showing understanding and abilities regarding (in order of introduction):
The course will be given as a self study course with a set of introductional seminars and accompanying mandatory assignments, followed by a larger assigmnent (project). The project can be carried out individually or in groups dependent on size. Grading will be individual, based on agreed requirements between the student and the teacher, showing understanding and abilities regarding (in order of introduction):
1. The Rust ecosystem.
1. The Rust ecosystem.
Rustup (stable vs nightly), crates and toml files, cargo, rustc, llvm, gdb/lldb (and additional tooling rls, rustfmt, racer, xargo etc.) The Rust core and standard library. Building, bebugging/testing, docmunenting and publishing Rust applications and libraries.
Rustup (stable vs nightly), crates and toml files, cargo, rustc, llvm, gdb/lldb (and additional tooling rls, rustfmt, racer, xargo etc.) The Rust core and standard library. Building, bebugging/testing, documenting and publishing Rust applications and libraries.
2. Simple applications in Rust
2. Simple applications in Rust
Prmitive types, tupels, structs, enums, etc. Flow control and functions. Marco usage.
Prmitive types, tupels, structs, enums, etc. Flow control and functions. Marco usage.
3. Rust features
3. Rust features
Closures (and higher order functions).
Generics and polymorphism. Closures (and higher order functions). Iterators. Traits, definitions and implementations (derived and explicit). Marker traits. Type bounds.
4. The Rust Memory Model
Theoretical underpinning, as well as impact to both memory safatey and code generation. Exterior (inherited) and interior mutability (Cell). Move vs. copy semantics, relation to Clone and Copy traits. Lifetimes and scoping. Static lifetimes, and the relation to the Sync trait.
6. Memory Safe Concurrency
UnsafeCell, and synchronization in the RTFM model. Requirements for Stack Resource Policy (SRP) based single-core scheduling.
7. Macros
Macro_rules/matching and expansion. Procedural macros (macros 2.0). Overview of the Rust RTFM implementation.
8. Building and debugginge embedded code in Rust
9. Pre-processing
Custom build.rs build scripts, and the RTFM Concurrent Reactive Component model.
## Course Format
Please fill out the [doodle](http://doodle.com) so we can arrange for a first scheduled seminar. We will use telegram [telegram](http://telegram.com) in order to confirm the preferred date. On the first seminar we will schedule 10 sessions for covering the above topics.
Trait definitions and implementations.
Each topic will be accompanied by a set of small illustartive examles and assigments that each student should master (learning goals). On the following session, each student should prepare to discuss and demonstrate their solutions.
### The Rust Memory Model
Lectures and assigments will be covered over a 4 week period, leaving time for a larger assignment/project.
Theoretical underpinning, as well as impact to both memory safatey and code generation. Exterior (inherited) and interior mutability. Move vs. borrow.
Each project should be reported in terms of a git Rust crate, with sufficient documentation (readme.md) to build, and recreate the result.
There will be two presentation rounds (at end of LP2 and LP3). Students taking (too many other) courses during LP2 may choose to present their project at end of LP3 (instead of LP2). Presentations will be oral, where the student(s), will present and demonstrate their work.
Projects should be related to embedded programming, either on the target side (some application using the RTFM-core or CRC model), or on the host side, communicating with an embedded target running Rust RTFM. E.g., two groups can work together with building a system, e.g., with back-end processing of data collected by the embedded system, or proividing a front-end to the embedded system. Alternatively, host side project could relate the develpment of the RTFM-core/ RTFM-CRC frameworks or related tools (e.g. LLWM-KLEE as a backend for analysis of Rust code).
It's very easy to make some words **bold** and other words *italic* with Markdown. You can even [link to Google!](http://google.com)
<!-- It's very easy to make some words **bold** and other words *italic* with Markdown. You can even [link to Google!](http://google.com) -->
