[Hyperbole-users] Interesting John Wiegley take on Hyperbole from awhile back

[Robert Weiner]

John, I hope you don't mind me reposting this.  -- Bob

jwiegley GNU Emacs maintainer

To expand on a comment I made to someone else, I decided to write a little document trying to clarify some of what I see as the philosophy behind Hyperbole, and why it may seem hard to understand its utility at first.

Using Hyperbole: A Motivation

Hyperbole can seem hard to grasp at first, because it's not a traditional piece of software offering functionality you don't already have. Instead, it takes something you have a lot of -- information accessible from Emacs -- and simply makes it more useful. It also comes with a few other packages, such as an outliner and window manager, but these are orthogonal to the fundamental problem Hyperbole hopes to solve.

Remember what Wikis did for plain text on a website? They were revolutionary at the time because they reduced the cost of associating information. Creating a link to a new page was as simple as ChangingCase, turning that word into a button you could click on to either visit the page, or create it if it didn't exist. So simple, yet it solved a important problem: that ordinary hyperlinks and pages were a pain to create and manage. There's even a cottage industry now of editing applications whose sole innovation is making Wiki-style content creation entirely seamless.

But Emacs does far more than just view and edit text files. It works with source code, web pages, e-mail messages, directories, remote files, task lists, calculations, etc., etc. The list is ever growing, but what it lacks is a convenient, effortless way of correlating these different kinds of data. Sure, we have addons packages that each solve many parts of the problem: xref, bookmarks, find-file-at-point, bug-reference, etc. Each one of these turns passive content into active content by interpreting some text as a reference to other information.

Hyperbole is a system dedicated to expanding on this idea. We have too much information in our lives, and it's coming in faster than we can organize it. Rather than manually specifying relationships between bits of information, we need a system that can see these connections simply by taking context and content into account. Hyperbole also allows explicit linking, when these two are not enough by themselves, but even without this it's able to supplant all the above mentioned packages, since they're all doing the same thing: inferring data references.

We do this ourselves constantly. For example, when writing a comment in source code, we might say "fixes #43", relying on later readers to understand that, because they cloned the source from GitHub, this refers to a GitHub issue that explains the code we've written. We depend on human readers to infer the meaning of references from context all the time. If we say our algorithm implements a red-black tree, we assume they'll go to Wikipedia or a CS text book if they don't know what red-black trees are.

Hyperbole lifts some of the cognitive burden from Emacs users by defining an extensible, large set of "recognizers" for various types of informational references, and "actions" for doing things with that information, such as visiting referenced documents, or web pages, or dictionary definitions. It's quite easy to add new, contextually-sensitive recognizers, and actions, so that you can teach Emacs to become more aware of how you use it to manage information.

But what's more, with every new recognizer and action you add, the more interactive all your information becomes. It's a multiplying effect, turning inert, standalone documents into more interactive, virtual semi-networks. And very few of these links do you need to update and maintain, because most of the information is inferred based on where you are when you hit the "action key".

Since this functionality is transparently added everywhere, not just special buffer types specific to Hyperbole, it's able to make Org-mode outlines richer, Gnus article reading more interactive, and source code more accessible to new readers -- provided they're using Emacs too. And not because Hyperbole is doing something Emacs couldn't do before; it's just that it unites that functionality under a single modality, rather than a family of disparate key bindings.

And yes, there's also Koutliner, and HyRolo, and a window manager, HyControl. However, these are separate packages with their own problems to solve, that just happen to have interesting use cases combined with Hyperbole.

Hyperbole itself, however, should be thought of as an extensible "information enabler", automatically turning inert documents into active ones, through the process of recognizing implicit buttons and giving you multiple ways to interact with those buttons. It's just like what Wiki did for text, but now for lots of other things, and in many more ways.

-- Bob