rust-lab-log VS percival

Several things while I'm between full time gigs, working on learning rust for my own pleasure:

- Rust Lab Log (https://github.com/bryan-lott/rust-lab-log) a simple CLI to take down notes and timestamp them in a single markdown file. I was inspired by my dad's use of logbooks in chemistry labs growing up so that you can always look back and figure out what went right or what went wrong. Has come in very handy during a couple of incidents.

- LogProx (https://github.com/bryan-lott/logprox) a logging proxy with stupid-low added latency. We had an issue where we were accessing a deprecated version of an API and couldn't figure out where the calls were coming from. The API owner was threatening to turn off our access entirely (long story). The idea being LogProx is to send all traffic through it and create rules to log and/or block calls that match a ruleset. Added latency was so low that I had to drop down to measuring in tenths of a millisecond.

Currently use markdown files + dropbox for sync. I can't seem to stick with a single notes app for any appreciable length of time but having files in plain text makes it easier to switch.

Currently using:

- Obsidian: this one has stuck the longest

- iA Writer: really pretty, seems to be more useful for longform

- NeoVim: I live it in anyway... may as well

- rlg: my own "dump thought to single file w/ timestamp" rust app), very janky, written specifically for my own use-case, standard "there may be dragons here, might eat your computer just for fun, etc" - https://github.com/bryan-lott/rust-lab-log

Souffle and Cozo mentioned below already implement the whole of "traditional" datalog.

Percival (https://github.com/ekzhang/percival) has some very nice examples showing how you can interactively write and test rules on top of a datalog interpreter.

Bud (http://bloom-lang.net/bud/) is Hellerstein's proof of concept playground. It has bit-rotted in the past few years, but the examples are readable even if you can't easily get it working.

The complexity can be quite good. You can syntactically determine when you've written linear recursion (equivalent to a for loop) vs not. Otherwise, the complexity is what you'd expect from incremental view maintenance in a normal SQL database. Which is to say O(n^k) with k being the number of relations joined, but usually much, much less with appropriate indexes and skew in the data. All the usual tricks concerning data normalization and indexes from databases apply.

I've worked on percival a bit, it compiles (transpiles?) the datalog ast into javascript code on demand and executes it to get the results, see [1]. Percival's creator, Eric, also submitted a 10m presentation about the project [2] to the HYTRADBOI 'virtual conference' earlier this year [2]. They also submitted a Show HN that received a couple comments [3]. The Have You Tried Rubbing A Database On It conference included several awesome presentations featuring datalog, which readers may find interesting [4].

[1]: https://github.com/ekzhang/percival/blob/main/crates/perciva...

[2]: https://www.hytradboi.com/2022/percival-a-reactive-language-...

[3]: https://news.ycombinator.com/item?id=29521975

[4]: https://www.hytradboi.com/

I haven't written a parser with Chumsky, bit I've played with a little one a bit if you wanna see an example syntax. The error reporting for this project is implemented with `ariadne` which is also really slick.

Parser: https://github.com/ekzhang/percival/blob/main/crates/perciva...

Error reporting: https://github.com/ekzhang/percival/blob/main/crates/perciva...

Datalog playground: https://percival.ink/

To see an error report, delete some punctuation from one of the Datalog code blocks then press shift-return.