Grit is really cool, the name feels a bit unfortunate as it might have muscle memory overlap with “git” - nothing that can’t be solved with an alias but perhaps something to ponder.
I also sadly see limited use for a task tracking system that I don’t have with me at all times - I would love a way to use grit on my phone and desktop computer with some kind of sync. Otherwise it would be limited to tracking work-related stuff as when I’m not working I really don’t use the computer; the grocery list example was really nice but I don’t carry my laptop to the grocery store :)
I really like Grit, will keep an eye on how it evolves.
- My objective is being able to show a "todo" list that is _actually actionable_. So I think early on its important to build in notions of "availability" (i.e. "this is not waiting on something else, you can work on this now")
- The dual is you kind of need nodes that represent "blockers". Here you have the parenting mechnaism that could get you there, but also stuff like setting dates on nodes (in Omnifocus this looks like the "defer until" date)
- I tried making a UI that handled N-node depth, but ended up figuring out that just displaying at most 2 levels of depth and then having fast loading when zooming in/out saved me a lot of API design headache and gets me 95% of the way there
- Even if your data is a tree structure, a lot of times just showing a flat list (perhaps with "parent node is X" annotation) is going to work out nicer. Notably with search
Pretty much this, unless I'm missing something. An earlier version of the program actually used DAGs, but I found it a little underconstrained. I got pretty excited when I discovered multitrees, as it seemed to be exactly what I needed the whole time.
On the same note, I wonder what is the relation between dags/multitrees and semilattices. They seem to be very similar concepts afaict.
There are so many ways to structure todos. In this case, it appears to be using subtasks specifically to break things down in various ways, and it's a cool implementation.
I personally think of todos as having dependencies, like a simplified PERT chart, which would more require a DAG. If I brought in the ability to generalize groups of that graph (or in the other direction, take a general node and "break it down" into a group of nodes), I guess I'm thinking of a multi-graph there. That sounds really hard. :)
I tried fiddling with it with vim folds but in the end just ended up deleting things I finish.
I learned this from a friend at work.
I noticed:
$ grit add -p 5 Bread
(5) -> (6)
$ grit add -p 5 Milk
(5) -> (7)
$ grit add -p 5 Eggs
(5) -> (8)
├──[ ] Get groceries (5)
│ ├──[ ] Bread (6)
│ ├──[ ] Eggs (8)
│ └──[ ] Milk (7)
(Another thing on the TODO list is adding an optional priority score for each task, and sorting those on top of the list in all tree views.)
One big deficiency of most todo apps is lack of support for making routes through the leaf nodes. I see that you can already do this with Grit via pointers and numeric task prefixes for sorting. But that brings us back to the bad old BASIC style line numbering problems.
Since I never really worked with go, I don't know where to start here.
https://f-droid.org/en/packages/org.dmfs.tasks/
Is this something you're thinking about adding?
Do you have plans to support any form of sync? Like CalDAV or some API on top of which CalDAV or another sync method can be implemented?
You can also self host it.
As for the syncing, that would be really nice, but I haven't come up with an elegant way to do it yet. Suggestions welcome, if anyone has ideas!
You can write git in a weekend or two: https://wyag.thb.lt/
sqlite is the wrong tool for the job, beyond an initial prototype. git and hg figured this stuff out decades ago.
Good job, by the way. This seems like the sort of thing which, if:
* it did store data in git and sync; and
* had a nice Python API
would change how I work.
The Python API, I could probably even handle myself. This is small data, and calls to shell commands are both more than adequate, and easy to script in Python.
.config/grit/graph.db
root@Flipper:/# find . -name graph.db
./home/mike/.config/grit/graph.dbI observed task lists are just for memory references.
[x] Task
├──[x] Sub-task (1)
│ ├──[x] Sub-sub-task (2)
│ └──[x] Sub-sub-task
├──[x] Sub-task (3)
│ ├──[x] Sub-sub-task (2)
│ └──[x] Sub-sub-task
└──[x] Sub-task
Fossil does seems to have issues when the VCS grows into many many gigabytes of data, like the entire OpenBSD source tree didn't work out very well in Fossil, but the chances of a personal task manager ever growing that size is slim to none I would imagine.
I see pieces like this in the Fossil docs:
"Fossil stores its objects in a SQLite database file which provides ACID transactions" -- https://fossil-scm.org/home/doc/trunk/www/fossil-v-git.wiki
The whole point of git is that your only operations on the underlying data structure are:
1. writing an object under its hash
2. incrementing a pointer to the head of a branch, a git tag, or similar, to show which version is current
You can do (1) on an eventually consistent (or even never-really-consistent) backing store, without any sorts of strong guarantees of integrity, and the git data structure continue to guarantee integrity. If (2) goes out-of-sync, you're left in a state very similar to what happens if I'm working on my laptop, and you're working on yours. We need a merge.
With DVCS, the whole point is to make ACID irrelevant.
I hadn't heard of Fossil before, but reading over the docs, I see a lot of red flags like that.
If grit were backed bit literal git, I'll mention, you get a ton of stuff for free, mostly with regards to syncing and finishing tasks on distributed devices (e.g. my cell, my laptop, etc.)
For the record, the people that created SQLite also created Fossil. The SQLite software(and website) was Fossil's initial use-case.
Fossil offers WAY more than what Git does, Fossil includes ticketing, forum, chat, wiki, etc. It's more on par with Gitlab/Github/etc, than it is 'git' alone.
Fossil syncs, etc, just like Git.
I think they serve different use-cases. git is nothing but the data structure(s), it's very very hard to use git, if you don't understand how the data is stored, as the UI is a very thin wrapper around it, which causes all sorts of issues for people that just want to get work done. That said, it makes Git very flexible, which is great.
Git was built for the Linux kernel way of doing things, and got co-opted into the PR model that Github pushed. I'm not saying these are wrong ways to think about the problem, but they are not the only way. Fossil is a different way.
Around ACID vs Git's data structure, the whole point is your data needs to kept safe, who cares how it's done.
I'm not trying to convert you to Fossil, but I think it's important to recognize git isn't perfect, or even perfect for it's use-case. But it clearly won the mindshare of developers because we just blindly followed Linus.
I'm of the opinion that for most projects, Mercurial, Subversion or Fossil would have been the better/easier solution for most people and while arguably not as flexible, the UI is at least 50% better and easier to understand.
git didn't win mindshare of developers because people blindly followed Linus, anymore than relational SQL databases weren't inched out by OODBs, document databases, or all sorts of other technologies because of dumb developer entrenched mindset. git (like SQL) won because it has very, very solid theoretical underpinnings which make it work incredibly well across a surprisingly broad set of use cases and handle data robustly.
Subversion is good for virtually no one. It's like using Excel for a database. It's complex, but doesn't get the job done.
Fossil, on a cursory look, looks like nineties mysql, when it was easy to use, but didn't really work, and was kind of a cargo-cult implementation of a proper database. I will admit I could be wrong (perhaps, just lousy docs).
hg, I agree, is better than git. git is a beautiful backend with a horrible front-end. hg has an equally beautiful backend, with a clean front-end and decent libraries. I wish hg had won. It didn't.
Oh well. At the end of the day, though, for this use-case, back-end matters far more than front-end. Competent developers can and do learn to use git, and are equally productive as in hg once they get over the learning cliff.
An upside is you learn a lot by learning git (or hg) internals. If OP knew git, they would have made a better grit. It's something every developer should do. Once you're past that, the front-end, while far from clean, gets the job done.
svn doesn't get the job done.
There is a reason there are 500,000 git tutorials that start with the basics of how git works, and still practically nobody understands git. Despite knowing the underpinnings of how it works practically required to be useful in git.
I agree the implementation matters from a data safety perspective, I mean Jepsen made a name for himself proving how terrible all the "distributed" databases suck(because it's a very hard problem to solve). But as a user, you don't usually have to care... unless it's git.
FreeBSD successfully used SVN for a long time without any major issues, as one example.
I feel like the statement "FreeBSD successfully used SVN for a long time without any major issues" is a lot like saying "I wrote books on a typewriter without any major issues." Or "Why do I need pointers/references/data structures? I wrote my code in QuickBASIC without any major issues." Or "DOS doesn't have memory protection or multitasking, and I never had any major issues" or "I wrote my system without documentation or test infrastructure, and it's never been a problem."
At the time you switch to correctly using a DVCS, your productivity skyrockets.
If you're using SVN, you DO have a problem. You might not know you have a problem, but you do. If you're using git like svn, you also have a problem.
I agree with you that many programmers have a problem, though. Just not about the root cause or the solution.
Maybe the right solution is to write a Python implementation of git with a sane user-space. The original git was written in a couple weeks, and I don't think it'd be more than a few months of work to have feature parity.