summaryrefslogtreecommitdiff
path: root/README.org
blob: 4b0fe5d58cbc0b7081ff332137b7d0270241076e (plain)
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
#+TITLE: Rusty Microphone

[[https://travis-ci.org/JWorthe/rusty_microphone][https://travis-ci.org/JWorthe/rusty_microphone.svg?branch=master]]

* Summary

The goal of this project is to create a dashboard for real-time
feedback to musicians while they are practicing. This is a personal
needs project, and so will at least initially focus only on the
trumpet, and problems that I personally face.

The other goal of this project is to give me a platform for learning
Rust, and various other technologies that I do not get to touch in my
day to day work.

* Getting started

This is a Rust project. The latest version of the Rust compiler and
Cargo are available from your system's package manager, or from
https://www.rust-lang.org/.

To compile the project:

#+BEGIN_SRC sh
cargo build
#+END_SRC

To compile and run:

#+BEGIN_SRC sh
cargo run
#+END_SRC

To compile and run unit tests. Use this as the CI build command if
setting up a CI server.

#+BEGIN_SRC sh
cargo test
#+END_SRC

* Project structure

** File Structure

- Dependencies are declared in ~Cargo.toml~
- The project main function for the project executable is in
  ~src/main.rs~. This should only be an entry point. Any actual
  functionality should be part of the library build.
- The other files to be included in the build are declared in
  ~src/lib.rs~.
- Unit tests are kept in the same files as the units they are testing.
- The main function will launch the GUI in ~src/gui.rs~. From here,
  the GUI can call out to the other parts of the library as required.

** General Architectural Guidelines

- Try to keep functions pure when possible. If not possible, try to
  isolate the impure parts.
- Split functionality into files based on their logical separation of
  concerns. Try to keep mathematical processing separate from
  presentation logic, so that the processing can be reused
  independently.