1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
# Project Title
Team members:
- Freya Murphy <freya@freyacat.org>
- Audrey Fuller <alf9310@rit.edu>
- Yusif Elsharawy <yse2561@rit.edu>
- Ryan Symons <ras1178@rit.edu>
## Summary Description
Reiterate the summary description of the overall goal of the project (updated as
necessary from the Proposal and/or Checkpoint documents).
## Project Execution Summary
Describe the work done for the project and lessons learned.
## Additional Details
- List any external Rust crates required for the project (i.e., what
`[dependencies]` have been added to `Cargo.toml` files).
- Briefly describe the structure of the code (what are the main components, the
module dependency structure). Why was the project modularized in this way?
- Choose (at least) one code excerpt that is a particularly good example of Rust
features, idioms, and/or style and describe what makes it “Rusty”.
- Were any parts of the code particularly difficult to express using Rust? What
are the challenges in refining and/or refactoring this code to be a better
example of idiomatic Rust?
- Describe any approaches attempted and then abandoned and the reasons why. What
did you learn by undertaking this project?
Review the final project grading rubric and discuss any relevant aspects of the
project.
***
***
The following should be deleted from the final project report, but is included in the initial `Final.md` file for reference.
## Final Project Rubric
- Correctness (15%)
- Free of compilation errors and warnings.
- Correctly accomplishes the goals of the project.
- Correctness is supported by suitable testing.
- Style/Design (15%)
- Project applies one or more elements of Rust design:
- Uses traits. Minimally, makes use of traits from the Rust Standard Library (e.g., `PartialEq` and `Iterator`). Better, implements appropriate traits for the types defined for the project. Best, defines and uses novel traits for the project.
- Uses `struct` and `enum` definitions appropriately.
- Uses types to capture invariants.
- Uses modules appropriately (e.g., place distinct data structures in distinct modules).
- Effort/Accomplishment (30%)
- How “big” is the project?
- A “small” project will have at least 500 Lines of Rust Code per team member. (Significantly less than that corresponds to a “tiny” project and would not be acceptable for this activity.) A “medium” or “large” project may have significantly more and would likely also correspond to a more “difficult” project (see below).
- How “difficult” was the project?
- An “easy” project that required trivial data structures and algorithms. Feedback about how to extend the project was ignored. (Projects falling into this category are likely to lose points in Style/Design as well.)
- A “moderate” project that applied basic course concepts, but did not require the group members to significantly challenge themselves or to learn something new.
- A “challenging” project that demonstrates significant thought in design and implementation. Clear that the group members challenged themselves and learned something new by undertaking the project.
- What work was done for the project? (This includes both the work embodied by the final submission and work not obvious from the final submission (e.g., approaches attempted but then abandoned, suitably described).)
- Did the project require learning advanced features?
- Did all team members contribute to the project?
- Presentation (10\%)
|
