Finally we get to the fun stuff, the setup for my “memex” which is basically the interface to my entire operating system. It defines a basic ontology that I use to understand the world, allowing me to quickly reference objects. It also contains a constraint programming system, which allows for the definition of queries and predicates within the system, giving you the ability to reason across sets of facts.
| Dependency | Description |
|---|---|
| org-roam | A wiki system for Emacs. |
| reazon | Logic programming utilitie |
| org-ql | Query language for org mode. |
| plantuml-mode | Mode to make PlantUML code look better. |
| graphviz-dot-mode | Make graphviz also look better. |
(ec-load-deps deps)To display graphs and diagrams, I commonly use graphviz and plantuml, so those are both installed.
(setq graphviz-dot-indent-width 4)I like to use org-roam a lot for personal programming projects, so I have defined a series of simple functions to provide that interface.
(setq org-roam-directory (file-truename "~/Memex"))
(org-roam-db-autosync-mode)Overall my plan is for objects to be contained within an ontology starting with higher level items, and continuing to low level items.
(defhydra memex (global-map "C-c n")
"Run a memex command."
("f" org-roam-node-find "find node")
("n" org-roam-capture "create new node")
("s" org-roam-db-sync "re-sync database"))The ontology is outlined below, and is designed to contain mentions of various objects. Here this system lies under the ontological category of code. The ontology is based on the basic formal ontology, a popular ontology system. While I don’t take a position of ontological realism at all, I do think that formal definitions and structure is useful.
During initial setup the code to define the ontology will be run, and then on successive starts the directories won’t be created.
(Memex
(Continuant
("Independent Continuant"
("Material Entity"
"Object"
"Object Aggregate"
"Flat Object Part")
("Immaterial Entity"
"Site"
"Spatial Entity"
"Continuant Flat Boundry))
You can also define relations between ontological entities.
Once this is done, we define our directory to be the “Memex” and make org-ql search it recursively.
(setq org-directory "~/Memex")
(setq org-ql-search-directories-files-recursive t)Occurants are the set of things that are occuring or will occur.
Unlike previous memex systems, my current one uses a logic programming interface to create and control various files, with editable definitions. This means that files may be tracked, invalidated, and reasoned against.
To do this I use a mixture of org-ql and reazon to create a simple meta-langauge for org-mode. This allows me to extract particulars from a simple BFO based ontology, reason with them, and define extensions to particulars.
Because of how Emacs works, unfortunately I cannot simply allow the user to define facts on the top level. Instead fact definition occcurs on a slightly lower level.
(fact ()) (relat on ()) (query)
To define a fact you simply define a headline with some name and then follow it with a series of paragraphs or lists. The results will be considered an ordered list with a given fact name.
* My Fact
# a simple string
From the above fact we can conclude some things.
- some data in a list
- some further data, also in a list
# a number that will be parsed as such
- 12
# something that will be parsed as a cons cell of (key . value)
- some data :: some more data
However, this is not the only way to define a fact! In fact, one can define facts at the top levels of a file. Therefore, a fact can comprise multiple objects. For example.
#+TITLE: My Fact
From the above we can conclude some things.
Obviously you might not want to just use goals, so you can also define relations between facts in our language. Therefore there is a simple expression for that.
* My Relation ** My Fact - some bit of data - another bit of data ** My Related Fact ** Not My Related Fact
As you can see, the relation (and all disjunctions and operations on it) also take the form of an org-mode structure similar to the first. However, relations add the special ? syntax, allowing for disjunctions and further logical relations beyond the obvious.
But let’s say you happen to have some sort of problem that is not possible ot fully formlaize, but you still want to use logic programming to conduct reasoning on the components that can be formally defined. In such a case you might define a logical system with input / output methods. When updating it will query you for inputs to continue the operation of the system.
To do so consider the definiton of the predicate.
Finally, you can also consider the elements of a predicate to be within an ordered set. That is to say while there is a well ordering, only one element of each exists. When considering ontological categories, the well ordering is alphabetical, and each category is a set of its subcategories, as well as all elements within each subcategory.
To examine what this means for the language, consider the question of if a computer program is “generically dependent continuant”. The answer is obviously yes. For the higher ontological category exists above the concept of a program.
However, ontological categories are not themselves facts like regular predicates are, but are rather defined as follows (using prolog).
In(category_a, category_b)
IsA(p, q) :- In(p, q); IsA(p, ?r), In(?r, q).Therefore, one may define
Finally, you mighta ctually want to include a bit of data from a collection of relations in another function. To do this you can use a query, which will return a collection of relations in a special block. This allows you to define, for example.
Finally, the system does not alwyas run, but rather operates when you specify a transaction.
Now you may wonder, why would you want this in a note taking setup? It seems complicated (I mean, it is). Well, the answer is that logic programming is tremendously useful for various scientific and other applications.
This effectively hides all of the org bullets and indents all org blocks, giving me a tree structure wtih the informational value of numbering and without the visual noise of stars.
(add-hook 'org-mode-hook (lambda () (org-num-mode 1)))
(add-hook 'org-mode-hook (lambda () (org-indent-mode 1)))
(defun ec-org-mode-remove-stars ()
(font-lock-add-keywords
nil
'(("^\\*+ "
(0
(prog1 nil
(put-text-property (match-beginning 0) (match-end 0)
'invisible t)))))))
(add-hook 'org-mode-hook #'ec-org-mode-remove-stars)I also want to improve the UI a bit, so I add some stuff to fix problems I have, namely that the tab key doesn’t alwyas cycle things.
(setq org-cycle-emulate-tab nil)
(setq org-src-preserve-indentation t)We also want there to be a main index, and to create that main index should the system not.
:PROPERTIES:
:ID: 49d9e34b-066b-45e9-ae62-c8ce713dca1c
:END:
#+TITLE: Main Index
* Introduction
This is the main index of your Memex, where you can operate the system and obtain important KPIs.
* Key Performance Indicators
- time on task ::
- tickets closed ::
Then we set the buffer
(setq initial-buffer-choice "~/Memex/main-index.org")Finally, we tangle the file.
(org-babel-tangle-file "~/Memex/emacs-config/memex.org")(setq org-confirm-babel-evaluate nil)
(require 'ob-clojure)
(require 'ob-python)
(require 'ob-css)
(require 'ob-dot)
(require 'ob-plantuml)