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
|
# SDC
This is a C port of [SD](https://git.exozy.me/a/SD), a very efficient (and a tiny bit overengineered) flash cards app. SDC is finished, which means that no new features will be added, only bug fixes.
## Usage
Flash cards are stored in the `cards` table of a SQLite database. There are four columns: `idx INTEGER PRIMARY KEY, weight INTEGER, key TEXT, val TEXT`. The `idx` is a unique index for each card, starting at 0. The weight is how often the card should come up. The key and value are the front and reverse sides of the card.
To create a card deck, use `sqlite3 cards "CREATE TABLE cards (idx INTEGER PRIMARY KEY, weight INTEGER, key TEXT, val TEXT)`. You may be able to double the performance by enabling WAL with `PRAGMA journal_mode=WAL`, because WAL only writes the content once instead of twice.
Now build SDC with `gcc sd.c segmenttree.c -o sd -lsqlite3 -O2 -march=native` and run `./sd` to enjoy a fast flash cards experience! You can also install the `sdc-git` package from the [AUR](https://aur.archlinux.org/packages/sdc-git). The program will display the `key` of a randomly selected card. Press any key to show the `val` of the card. Now press either `y` or `n` depending on whether you got the card correct, and the program adjusts that card's weight.
There is also a Python GUI, `main.py`, which requires PyQt6. This script invokes the `sd` binary in the same directory as the script with the command-line flags that were passed to the script. Alternatively, there is a Tkinter GUI in `tkinter.py` that only requires the Python standard library but does not support Wayland. The GUIs are not compatible with the original unmaintained SD which lacks noninteractive mode, but it would be easy to add that feature to SD.
It should also be fairly easy to write your own SD clone or GUI, so if you write one, I'd be glad to link to it here.
If you're wondering where the name came from, this is the C port of SD, which was named after a common type of flash card. 😀
## Performance
SD is designed to be extremely efficient and [supports decks with hundreds of millions of flash cards](test.py). If `N` is the number of cards, initializing the program requires `O(N)` time and `O(N)` memory. Selecting a random card and adjusting its weight requires `O(log N)` time. Internally SD uses [segment trees](https://en.wikipedia.org/wiki/Segment_tree) to achieve this time complexity.
Some benchmark results using 10 card updates (without WAL):
```
C version: ./sd < test
Time (mean ± σ): 57.4 ms ± 4.5 ms [User: 6.9 ms, System: 2.4 ms]
Range (min … max): 51.9 ms … 70.9 ms 41 runs
Go version: ./sd < test
Time (mean ± σ): 92.7 ms ± 6.8 ms [User: 8.4 ms, System: 4.5 ms]
Range (min … max): 79.4 ms … 108.9 ms 33 runs
```
The C port is about 30% faster than the original Go code.
## Tips and tricks
- View card deck: `sqlite3 cards .dump`
- Get total number of cards: `sqlite3 cards "SELECT COUNT(*) FROM cards"`
- Get total number of cards with positive weight: `sqlite3 cards "SELECT COUNT(*) FROM cards WHERE weight>0"`
- Search for string in keys: `sqlite3 cards "SELECT * FROM cards WHERE key LIKE '%hello%'"`
- Add card to deck: [sd-add.fish](sd-add.fish)
- Edit deck: [sqlitevi.fish](sqlitevi.fish) or sqlitebrowser
|
