The ~org-mode~ package is abused and misused in so many ways, that it can be seen as a distinct psychological phenomena in itself.

The underlying mechanism is satisfaction (a dopamine release reward) from repeatedly doing supposedly “the right thing”, which, in turn, is the neurological basis of all repetitive religious rituals.

These “very smart” guys just maintain an elaborate system of mechanistic and semi-automated rituals to reinforce their deeply held unwarranted belief, on which their self-identification is based upon, that they are “very smart”.

The very similar vastly complex and full of elaborate minute details, which all “validated” and justified by seemingly “logical” reasons, systems of daily rituals can be seen within Tibetan tantric sects.

Before that Indian Brahmans were the absolute champions of keeping themselves busy with nothing for other people to marvel upon.

All your micromanagements are just means to keep you busy and to feel good (from continuous dopamine releases) about yourself for doing “the right thing”, and thus being special – “not like everyone else”.

What isn’t bullshit

Headlines are just “vertical” lists – an ordered sequences. We can change the order (sort) according to some “priorities”. M-up and M-down “change the order”.

Then, by adding the notion of “nesting” we could have a whole “horizontal dimension” in which every outline is nested within (is a part of) the previous one. M-left and M-right “change the nesting”.

Ordering and nesting is a half of Universe, on which Life Itself has been evolved upon.

To have a stable structure is to maintain a particular order of elements.

The nested /environments and closures within (cells and enzymes) are possible because of the universal notions of ordering and nesting.

Universal notions

There are the same “universal notions” underlying predicate logic, mathematical set-comprehension notation, sets-and-relations basis of SQL and the query languages like that one of Datomic.

These notions, by the way, are “natural and necessary implications” of the fact that Causality itself “can be seen as a bunch of directed graphs of single steps or transitions”. The Mind just observes and generalizes form the resulting “effects”.

This is not a coincidence that everything in CS can be reduced to such graphs (with no loops, but spirals of recursions) at various levels.

So, the universal notions which org-mode has been built upon are:

  • An ordering (having a particular structure)
  • Nesting (of headlines and tags)
  • Tagging, including type-tagging
  • Sets and “groups” (based on tags)
  • Predicates (on tags and groups)
  • Selecting and queering (such that)

There are “headlines”, which have several levels of outlining (nesting) usually up to 6.

The level of outlining of a headline is dynamic and semantically irrelevant, which means that it can be changed without altering the meaning.

The the outlines may capture the notion of a hierarchy and of general class-subclass, group-subgroup, set-subset relations.

TODO Keywords

When we define additional TODO keywords, such as NEXT or FIXME, we basically specialize them. Think of subsets without any inheritance.

When we decorate headlines with such keywords they are semantically all TODOs (of different kinds). The meanings are up to the user.

They can be pre-defined globally using a variable, or defined in-place per-buffer (ad-hoc).

Tags

In general, decorating with a tag is the same notion as attaching a label.

Words (particular sequences of sounds) of a human language are such labels.

Headlines can be decorated (tagged) with symbolic tags (symbols).

This is closely related to the notion of type-tagging of individual values in memory, used in the early LISPs.

With tags we create the simplest ad-hoc non-systematic type-system.

Some tags signify a major or minor category, some are just labels.

Pre-defined type-tags can be used as simplest types-as-sets markers.

The fundamental notion is that we just decorate (label) and all the “higher-level” grouping and filtering operations are orthogonal, and at are at the higher level of abstraction.

This corresponds to a generalized hierarchical structure, in which a type-system is at a higher level, “above” the terms.

Relations

Just as with Types or mathematical Sets, we could have an item decorated (annotated) more than one tag. This is a fundamental feature.

Some tags, just like Sets, are semantically mutually exclusive, some are proper subsets of the other, some may have a non-empty intersection.

There is no way to systematically and consistently define such constraints.

Again, just as it is with the mathematical Set Theory, the meaning (semantics) is out of scope. Every meaning or “use” is up to the “user”.

Categories

There are simplest examples of tags

  • :math:
  • :programming:
  • :trading:
  • :emacs:
  • :neovim:

The first three are (stands for) whole “categories”, while the last two are just “type-tags”.

Of course, they have the meaning only in how we interpret and use them.

Unlike the traditional classic type-systems, we do not define a set of values by a set of all the possible operations (on individual values), which is what mathematicians do to define their own abstractions rigorously.

Sets, Groups, Monoids, Matrices, Tensors are examples of such “types”.

On capturing we tag ’em

When we capture some new information, we not just create and choose a corresponding new headline, we also tag it with pre-defined (or even new, ad-hoc) tags.

Selecting and grouping

This is what it is all about within the org-mode. We group headlines (and other items) based on the tags.

org-super-agenda provide the way to define such “groups” and there is even a whole “query language” (implemented as a library) in the org-ql package.

This does not mean we have to use them, but it is good to have them ready (and being maintained by other people).

org-ql

This is an implementation of an embedded DSL which corresponds to the mathematical set-comprehension notation, which rely on the such-that notion, based on predicate logic.

Notice that Sets are untyped (and the elements are untagged), and defined in terms of a set of all possible operations.

It is also similar to a query language that Datomic offers.

Again, everything which has been properly captured can be “unfolded” back to the underlying aspects of What Is from which it has been generalized.