[FEATURE] logseq like outliner with back-references to the block level , plain text backend and other misc feedback

[hgkamath]

Is your feature request related to a problem? Please describe.
nope, just hoping for the next best notetaking system

Describe the solution you'd like

1. persuation to consider a logseq style outliner with back-references to the block level
   (emacs org-mode, obsidian, roam are also note-taking outliners)
2. persuation to consider a plain text file format backend with regeneratable indexes

Firstly, thankyou for your attempt at making a note-taking tool in rust.

Its seems obvious that you are attempting to make a hosted notetaking system for office/collaborative/enterprise-deployment situation. Some things I mention here may arrive from a different angle to your design/vision.

I also see that skytable is also your baby.

Unfortunately I didn't get to try out jotsy yet, nor find a youtube demo showing its current 0.1/0.2 versions, except for a few screenshots. As you can see wsl docker-machine setup is a small entry barrier hurdle one needs to overcome. So I'm sorry for being in the blind here, while filing this issue.

Its fine to close this issue if you have already considered this. I am sure most of what I write below, you would have also already surveyed.

As a note taking system user, I just wanted to share/provide some feedback, based on my use of other notetaking systems.

Some general strengths I see in some notetaking systems

• having a plain text or encrypted text backend ( as compared to web interface with database storage)
  • local machine failure is a real risk/hazard. one safe guards that with backups. But the more infrastructure you need to set up like webservers/databases, can make setting-up and configuring things back to original a big chore, before one can access one's notes. One always need one's notes quick at hand for any daily activity, when daily routine is tracked with one's notes. Notetaking systems like logseq, zettler, dendron, etc save notes in plain text. Additionally, some apps keep an any time regenerate-able database for indexing, linking, caching and the like.
• while web backend is good, local-apps are better
  • for the same reasons, it reduces time to setup and get going.
  • no need to do infrastructure setup, like configuring and deployment of web backend and database etc
• syncing to cloud storage
  • this allows for use on multiple devices
  • the advantage of web-only with web-storage is that data is stored in one place, and synchronization is managed easily. the disdvantage is that that host server needs to always run, and local client can't edit offline.
• Being able to just move/relocate the note-base quickly easily from machine to machine
  • moving becomes easy, when all one has to do, is copy over the note-base and just make the new software just reindex the plain-text files.
• Easier to backup
  • for the same reasons
• In plaintext there seem to be some choices: markdown flavor, common-mark, github-mark, djot, yaml, etc. I don't insist on an any given markdown, because one can easily convert between one to another using pandoc. But some human-editable markdown-like standard-fileformat gives a feeling of freedom, no file-format trap, no-lock-in, as well as a ease of edit using whichever editor, though one will usually choose to edit using the same notetaking tool because of instantaneous index updates. Writing auto-structured plaintext/markdown keeps persons writing focus on the note-writing-content instead of the looks/formatting.
• The hierarchical note taking system has problems when a note can belong to multiple hierarchies.
  • I have come to like the outliner style with the tagging, because a tagging system seems to provide natural and better organization. The date based journaling itself acts like a linear order structure and the tags themselves act as a good descriptor of the content. In most cases it obviates the need for a note with its own descriptive title. When one searches for a note, one searches based on tag, and looks for relevant content by date.
• When notes are in plain-text and indexes are regenerated, its possible to move/try different note taking systems, without

I think its a plus if optionally allows the data(notes) to reside outside as plaintext files, while skytable does indexing and other feature support.

logseq

• strengths:
  • outliner, with tagging and back reference, plain text markdown, regeneratable indexes, easy to port, easy to backup, easy to get to notes post disaster
  • can do datalog (a query language)
  • can do sci (embedded clojure scripting language)
  • can do a note-graph
  • can do zotero
  • has mobile/android port
  • has a plugin system
• neutral
  • cljs lang, (clojurescript), has a REPL, fast interpretted language
• weaknesses:
  • slow (at least to start)
  • large software size to install ~200Mb!!

IMHO, logseq has done many things right.

Other seemingly good contenders as of 20221222

• zettlr: implementation lang: typescript, Zettlr seems to be best for keeping academic style zettelkastens, specially liked the zotero integration, not an outliner
• dendron: implementation lang: typescript, requires vscode, not on mobile, some kind of GUID/git based tree
• emanote: implementation lang haskell
• Joplin: implementation lang: typescript, not plaintext backend but uses sqlite backend,
• trillium-notes implementation lang: javascript, not plaintext backend but uses sqlite backend.

Other notetaking systems seen/considered, less preferred

• list
  • jupyter, mediawiki, Zim, turtl, tiddlywiki, wordpress, simplenotes, leanote, rednotebook, cherrytree, opennotes, nextcloud-notes
• disdvantages include
  • used rich text or special text format
  • locked up in database/infrastructure, no plain text access
  • required setting things up like webserver, database and so on
  • require larger install infrastructure like python
  • implementation languages like php that are on the way out

Other notetaking systems seen, over the years,, even less preferred

• boostnote, microsoft-one-note, nixnotes, evernote, standard-notes

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.